【Python】入门到放弃之第五章《运算符》

花凝雨

已于 2024-08-13 01:42:03 修改

阅读量1.1k

点赞数 37

分类专栏： Python 文章标签： python 开发语言

于 2024-08-12 16:15:11 首次发布

本文链接：https://blog.csdn.net/MP13537560060/article/details/141130251

版权

Python 专栏收录该内容

16 篇文章 0 订阅

订阅专栏

上一篇：【Python】入门到放弃之第四章《数据类型转换》
下一篇：【Python】入门到放弃之第六章《字符串》

前言

这是本系列的第五章节内容，《运算符》。这又是一篇长文章。

一、定义

运算符（Operator）是一种告诉编译器执行特定数学或逻辑操作的符号，用于表示针对数据的特定操作，也称之为操作符。根据不同的分类标准，运算符可以分为多种类型。

二、算术运算符

算术运算符用于执行基本的数学运算，如加、减、乘、除等。

1.加法 (+)

用于将两个数相加。

result = 5 + 3  # 结果为 8

2.减法 (-)

用于从一个数中减去另一个数。

result = 10 - 3  # 结果为 7

3.乘法 (*)

用于将两个数相乘。

result = 4 * 3  # 结果为 12

4.除法 (/)

用于将一个数除以另一个数，并返回商（浮点数）。

result = 10 / 4  # 结果为 2.5

5.整除 (//)

用于将一个数除以另一个数，并返回商的整数部分（向下取整）。

result = 10 // 3  # 结果为 3

6.取模 (%)

用于求两个数相除的余数。

result = 10 % 3  # 结果为 1

7.幂 (**)

用于计算左操作数的右操作数次幂。

result = 2 ** 3  # 结果为 8

8.增强赋值运算符

这些运算符结合了赋值和算术运算，使代码更简洁。（代码参考本章四、赋值运算符–>2.复合赋值运算符）

加法赋值 (+=): x += y 相当于 x = x + y
减法赋值 (-=): x -= y 相当于 x = x - y
乘法赋值 (*=): x *= y 相当于 x = x * y
除法赋值 (/=): x /= y 相当于 x = x / y
整除赋值 (//=): x //= y 相当于 x = x // y
取模赋值 (%=): x %= y 相当于 x = x % y
幂赋值 (**=): x **= y 相当于 x = x ** y

三、比较（关系）运算符

Python中的比较运算符（也称为关系运算符）用于比较两个值之间的关系，并根据比较结果返回布尔值True或False。

1.等于 (==)

检查两个值是否相等。

a = 5  
b = 5  
print(a == b)  # 输出: True

2.不等于 (!=)

检查两个值是否不相等。

a = 5  
b = 6  
print(a != b)  # 输出: True

3.大于 (>)

检查左边的值是否大于右边的值。

a = 5  
b = 3  
print(a > b)  # 输出: True

4.小于 (<)

检查左边的值是否小于右边的值。

a = 3  
b = 5  
print(a < b)  # 输出: True

5.大于等于 (>=)

检查左边的值是否大于或等于右边的值。

a = 5  
b = 5  
print(a >= b)  # 输出: True

6.小于等于 (<=)

检查左边的值是否小于或等于右边的值。

a = 3  
b = 5  
print(a <= b)  # 输出: True

7.小结

以上这些比较运算符不仅适用于数值类型，还适用于字符串、列表等序列类型，但比较的方式会根据数据类型而有所不同。例如，对于字符串，比较是基于字典序的；对于列表，比较是基于列表元素逐一比较的。
值得注意的是，当比较的对象是可变类型（如列表）时，即使两个列表包含相同的元素，如果它们不是同一个对象（即内存地址不同），使用==比较也会返回True，因为==在这里是比较两个列表的内容是否相等，而不是比较它们的身份（即内存地址）。相反，is运算符用于比较两个对象的身份是否相同（即内存地址是否相同）。
此外，Python中的比较运算符还可以用于构建更复杂的表达式，这些表达式可以包含多个比较运算符，并且可以使用逻辑运算符（and、or、not）来组合多个比较结果。

四、赋值运算符

Python 中的赋值运算符主要用于将值或表达式的结果赋给变量。最基本的赋值运算符是单个等号 =，但 Python 还提供了一些复合赋值运算符，它们结合了算术、位或其他运算符与赋值操作。

1.基本赋值运算符

=：最基本的赋值运算符，用于将右侧的值或表达式的结果赋给左侧的变量。

x = 10    # 将 10 赋给变量 x

2.复合赋值运算符

复合赋值运算符结合了算术、位或其他运算符与赋值操作，使代码更简洁易读。

+=：加法赋值运算符。x += y 相当于 x = x + y。
-=：减法赋值运算符。x -= y 相当于 x = x - y。
*=：乘法赋值运算符。x *= y 相当于 x = x * y。
/=：除法赋值运算符。x /= y 相当于 x = x / y。
%=：取模赋值运算符。x %= y 相当于 x = x % y。
**=：幂赋值运算符。x **= y 相当于 x = x ** y（注意：Python 3 中幂运算符是 **，不是 ^，后者是按位异或运算符）。
//=：整除赋值运算符。x //= y 相当于 x = x // y。
&=、|=、^=、<<=、>>=：这些是位运算符与赋值操作的结合，分别用于按位与、按位或、按位异或、左移和右移赋值。

x = 10
x += 1  # x 现在是 11
x -= 2  # x 现在是 9
x *= 2  # x 现在是 18
x /= 3  # x 现在是 6.0
x %= 4  # x 现在是 2.0

# 使用幂赋值运算符  
z = 2
z **= 3  # z 现在是 8（2 的 3 次方）  

# 使用位运算符（这里只是示例，不代表实际有意义的操作）  
a = 6  # 二进制表示为 110  
a &= 3  # a 现在是 2（二进制 110 & 011 = 010）

五、逻辑运算符

Python中的逻辑运算符用于在表达式中执行逻辑运算，这些运算通常返回布尔值（True 或 False）。

1.逻辑与（AND）

使用符号 and（代码中使用“AND”会报错，下同）。如果两个操作数都为真（True），则结果为真（True）。如果任一操作数为假（False），则结果为假（False）。

print(True and True)  # 输出: True  
print(True and False) # 输出: False  
print(False and True) # 输出: False  
print(False and False) # 输出: False

2.逻辑或（OR）

使用符号 or。如果两个操作数中至少有一个为真（True），则结果为真（True）。如果两个操作数都为假（False），则结果为假（False）。

print(True or True)  # 输出: True
print(True or False) # 输出: True
print(False or True) # 输出: True
print(False or False) # 输出: False

3.逻辑非（NOT）

使用符号 not。它用于反转操作数的布尔值。如果操作数为真（True），则结果为假（False）。如果操作数为假（False），则结果为真（True）。

print(not True)  # 输出: False  
print(not False) # 输出: True

4.小结

逻辑运算符经常与比较运算符（如 ==、!=、<、>、<=、>=）和布尔值一起使用，以构建复杂的条件表达式。

# 检查一个数是否同时大于10且小于20
x = 15
if x > 10 and x < 20:  
    print("x 在 10 和 20 之间")

# 检查一个数是否大于10或小于5
y = 15
if y > 10 or y < 5:
    print("y 大于 10 或小于 5")

x 在 10 和 20 之间
y 大于 10 或小于 5

六、位运算符

Python中的位运算符是针对整数类型的数据进行操作的，它们将数字视为二进制数，并在每一位上执行相应的逻辑运算。

1.按位与（&）

对两个数的二进制表示进行逐位与操作。只有两个对应的二进制位都为1时，结果位才为1，否则为0。

a = 60  # 二进制为 0011 1100  
b = 13  # 二进制为 0000 1101  
result = a & b  # 结果为 0000 1100，即12

2.按位或（|）

对两个数的二进制表示进行逐位或操作。只要两个对应的二进制位中有一个为1，结果位就为1，否则为0。

a = 60  # 二进制为 0011 1100  
b = 13  # 二进制为 0000 1101  
result = a | b  # 结果为 0011 1101，即61

3.按位异或（^）

对两个数的二进制表示进行逐位异或操作。只有两个对应的二进制位不同时，结果位才为1，否则为0。

a = 60  # 二进制为 0011 1100  
b = 13  # 二进制为 0000 1101  
result = a ^ b  # 结果为 0011 0001，即49

4.按位取反（~）

对一个数的二进制表示进行取反操作，即将0变为1，将1变为0。注意，Python中的数字是带符号的，因此取反操作后通常会导致结果的符号位也发生变化，进而影响到整个数的值。

a = 60  # 二进制为 0011 1100（在Python中，整数以补码形式存储）  
result = ~a  # 结果为 -61（因为Python是带符号整数，取反后需要按补码规则解释）

5.左移（<<）

将一个数的二进制表示向左移动指定的位数，右侧用0填充。左移操作相当于乘以2的幂次方。

a = 60  # 二进制为 0011 1100  
result = a << 2  # 结果为 1111 0000，即240

6.右移（>>）

将一个数的二进制表示向右移动指定的位数。对于正数，左侧用0填充；对于负数，Python使用算术右移，即用符号位（即最高位）填充左侧。右移操作相当于除以2的幂次方并向下取整。

a = 60  # 二进制为 0011 1100  
result = a >> 2  # 结果为 0000 1111，即15

七、成员运算符

Python中的成员运算符主要用于测试一个序列（如列表、元组、字符串或集合）中是否包含某个特定的值。主要的成员运算符有两个：

in：如果指定的值在序列中，则返回True，否则返回False。
not in：如果指定的值不在序列中，则返回True，否则返回False。

1.列表示例

成员运算符in和not in不仅限于列表，它们也可以用于元组、字符串、集合（set）等任何可迭代对象。
对于字典（dictionary），成员运算符用于检查键（key）是否存在于字典中，而不是值（value）。

# 列表示例
fruits = ['apple', 'banana', 'cherry']

# 使用in运算符
if 'banana' in fruits:
    print("Yes, 'banana' is in the fruits list.")
else:
    print("No, 'banana' is not in the fruits list.")

# 使用not in运算符
if 'grape' not in fruits:
    print("Yes, 'grape' is not in the fruits list.")
else:
    print("No, 'grape' is in the fruits list.")

Yes, 'banana' is in the fruits list.
Yes, 'grape' is not in the fruits list.

2.字典示例

直接检查字典中是否包含某个值（如’John’）是不直观的，因为成员运算符in对字典来说只检查键。要检查值，你需要使用.values()方法，并考虑到in运算符对于集合（如.values()返回的）是有效的。

# 字典示例
my_dict = {'name': 'John', 'age': 30}

# 检查键'name'是否在字典中
if 'name' in my_dict:
    print("Yes, 'name' is a key in the dictionary.")
else:
    print("No, 'name' is not a key in the dictionary.")

# 检查值'John'是否在字典中（这是错误的用法）
# 应该检查键对应的值
if 'John' in my_dict.values():
    print("Yes, 'John' is a value in the dictionary.")
else:
    print("No, 'John' is not a value in the dictionary.")

Yes, 'name' is a key in the dictionary.
Yes, 'John' is a value in the dictionary.

八、身份运算符

Python中的身份运算符用于比较两个对象的身份（即它们在内存中的位置），而不是它们的值。有两个主要的身份运算符：is 和 is not。

is：当两个对象在内存中的位置相同时，使用is运算符将返回True。这通常意味着它们实际上是同一个对象。
is not：与is相反，当两个对象在内存中的位置不同时，使用is not运算符将返回True。

# 示例 1: 使用 is 比较同一个对象
a = [1, 2, 3]
b = a
print(a is b)  # 输出: True，因为 a 和 b 指向同一个对象

# 示例 2: 使用 is 比较两个独立的对象
c = [1, 2, 3]
print(a is c)  # 输出: False，因为 a 和 c 指向不同的对象，尽管它们的内容相同

# 示例 3: 使用 is not 比较
print(a is not c)  # 输出: True，因为 a 和 c 不是同一个对象

# 示例 4: 使用 is with 数字和字符串字面量
x = 1
y = 1
# 对于小的整数和短的字符串，Python解释器可能为了优化内存使用而将它们缓存
# 所以有时候即使是字面量赋值，也可能看到 is 返回 True
print(x is y)  # 可能输出 True，取决于Python解释器的实现和缓存策略

# 示例 5: 比较两个 None 对象
n1 = None
n2 = None
print(n1 is n2)  # 输出: True，因为 None 在 Python 中是单例的