Python运算符

Python中的运算符用于执行各种数学和逻辑操作。这些运算符可以对变量、数值、字符串和其他类型的数据进行操作。

运算符的优先级

Python中的运算符优先级决定了在包含多个运算符的表达式中，各个运算符的执行顺序。优先级高的运算符会先于优先级低的运算符执行。以下是Python中所有运算符的优先级列表，按照从高到低的顺序排列。

注意：

1. 幂运算符（**）具有最高的优先级，其次是按位取反（~）和正负号（+x, -x）。
2. 算术运算符（如乘、除、加、减）的优先级高于位运算符（如左移、右移、按位与、按位异或、按位或）。
3. 比较运算符（如小于、大于、等于等）和身份运算符（is, is not）的优先级高于逻辑运算符（not, and, or）。
4. 赋值运算符（如=及其复合形式）具有最低的优先级。

在编写复杂的表达式时，了解并遵循这些优先级规则非常重要，以确保表达式按照预期的方式求值。如果需要改变默认的运算顺序，可以使用括号来明确指定运算的优先级。

此外，当遇到优先级相同的运算符时，Python会根据运算符的结合性（左结合性或右结合性）来决定运算的顺序。例如，算术运算符和比较运算符通常是左结合的，而赋值运算符是右结合的。这意味着在优先级相同的情况下，从左到右或从右到左进行运算。

算术运算符

算术运算符注意事项

• 在进行除法运算时，如果两个操作数都是整数，并且结果不能精确表示为整数时，Python 3 会自动将结果转换为浮点数。
• 赋值运算符（如+=、-=等）提供了一种更简洁的方式来更新变量的值，而无需显式地写出完整的赋值表达式。
• Python中的运算符具有优先级，例如，乘法和除法（*、/、%、//）的优先级高于加法和减法（+、-），幂运算（**）的优先级高于乘法和除法。可以通过使用括号来改变运算的优先级。

赋值运算符

赋值运算符用于将值或表达式的结果赋给变量。Python中的赋值运算符包括：

比较运算符

Python中的比较运算符（也称为关系运算符）用于比较两个值或表达式之间的大小、相等性或其他关系，并返回布尔值True或False。

比较运算代码案例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

# 等于
print(5 == 5)  # 输出: True
print("hello" == "hello")  # 输出: True

# 不等于
print(5 != 3)  # 输出: True
print("hello" != "world")  # 输出: True

# 大于
print(5 > 3)  # 输出: True

# 小于
print(3 < 5)  # 输出: True

# 大于等于
print(5 >= 5)  # 输出: True
print(6 >= 5)  # 输出: True

# 小于等于
print(3 <= 5)  # 输出: True
print(3 <= 3)  # 输出: True

# 身份运算符
a = [1, 2, 3]
b = a
c = [1, 2, 3]
print(a is b)  # 输出: True，a和b指向同一个对象
print(a is c)  # 输出: False，尽管a和c内容相同，但它们不是同一个对象

# 否定身份运算符
print(a is not c)  # 输出: True

比较运算符注意事项：

• 当比较字符串、列表、元组、字典等复杂数据类型时，==运算符比较的是它们的值是否相等，而不是它们的身份（即内存地址）。
• 对于数字类型的比较，Python中的==运算符是可靠的，因为它比较的是数字的值。
• is和is not运算符主要用于比较对象的身份，这在处理可变数据类型（如列表、字典等）和需要确保两个变量引用的是同一个对象时特别有用。
• 在某些情况下，即使两个对象的内容相同，它们也可能不是同一个对象（如上例中的a和c），因此在这种情况下应该使用==而不是is。

逻辑运算符

Python中的逻辑运算符用于比较两个或多个条件，并根据条件的结果返回一个布尔值（True或False）。Python中的逻辑运算符主要有三种：and、or和not。

逻辑运算符的详细解释

1. and运算符：
   • 当使用and运算符连接两个条件时，Python会先评估左边的条件，如果左边的条件为False，则整个表达式的结果立即确定为False，并且不会评估右边的条件（这称为“短路”行为）。
   • 如果左边的条件为True，则继续评估右边的条件，整个表达式的结果由右边的条件决定。
2. or运算符：
   • 当使用or运算符连接两个条件时，Python也会先评估左边的条件。
   • 如果左边的条件为True，则整个表达式的结果立即确定为True，并且不会评估右边的条件（短路行为）。
   • 如果左边的条件为False，则继续评估右边的条件，整个表达式的结果由右边的条件决定。
3. not运算符：
   • not运算符仅对单个条件进行取反操作。
   • 无论条件是什么类型（布尔类型、数值类型、字符串等），not运算符都会尝试将其转换为布尔值，然后取反。

位运算符

在Python中，位运算符是对整数的二进制表示形式直接进行操作的运算符。它们主要用于底层开发、算法优化、网络通信等场景，虽然在应用层开发中不常见，但理解它们对于深入理解计算机底层操作非常有帮助。

详细描述

1. 按位与（&）：
   • 运算规则：两个相应的二进制位都为1时，该位的结果才为1，否则为0。
   • 示例：9 & 5 的结果为 1，因为 9 的二进制是 1001，5 的二进制是 0101，按位与后得到 0001，即十进制的 1。
2. 按位或（|）：
   • 运算规则：两个相应的二进制位中只要有一个为1，该位的结果就为1，否则为0。
   • 示例：9 | 5 的结果为 13，因为 9 的二进制是 1001，5 的二进制是 0101，按位或后得到 1101，即十进制的 13。
3. 按位异或（^）：
   • 运算规则：两个相应的二进制位不同时结果为1，相同时结果为0。
   • 示例：9 ^ 5 的结果为 12，因为 9 的二进制是 1001，5 的二进制是 0101，按位异或后得到 1100，即十进制的 12。
4. 按位取反（~）：
   • 运算规则：对操作数的每个二进制位进行取反操作，即0变为1，1变为0。
   • 示例：~5 的结果为 -6，因为 5 的二进制是 0101，取反后得到 1010，但在计算机中负数使用补码表示，所以实际结果为 -6（这里简化了补码转换的过程）。
5. 左移（«）：
   • 运算规则：将数的二进制表示向左移动指定的位数，右边用0填充。
   • 示例：5 << 2 的结果为 20，因为 5 的二进制是 101，左移2位后得到 10100，即十进制的 20。
6. 右移（»）：
   • 运算规则：将数的二进制表示向右移动指定的位数，左边根据符号位填充（正数填充0，负数填充1）。
   • 示例：20 >> 2 的结果为 5，因为 20 的二进制是 10100，右移2位后得到 101，即十进制的 5。

代码案例

1. 按位与（AND）&

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

1
2
3
4

a = 60  # 0011 1100  
b = 13  # 0000 1101  
c = a & b  # 0000 1100  
print(c)  # 输出: 12

2. 按位或（OR）|

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

1
2
3
4

a = 60  # 0011 1100  
b = 13  # 0000 1101  
c = a | b  # 0011 1101  
print(c)  # 输出: 61

3. 按位异或（XOR）^

对两个数的二进制表示进行逐位异或操作。当两个相应的二进制位相异时，结果位为1。

1
2
3
4

a = 60  # 0011 1100  
b = 13  # 0000 1101  
c = a ^ b  # 0011 0001  
print(c)  # 输出: 49

4. 按位取反（NOT）~

对数的二进制表示进行逐位取反操作。所有为0的位变成1，所有为1的位变成0。注意，由于Python中整数通常是补码形式，所以取反后需要考虑符号位。

1
2
3
4
5
6

a = 60  # 0011 1100  
c = ~a  # 1100 0011...（取决于整数大小，这里只展示了8位）  
# 因为Python使用补码，且int类型长度可变，直接打印~a可能不会得到直观的结果  
# 但我们可以打印它与某个数的AND结果来观察  
print(~a & 0xFF)  # 取反后和0xFF（即255或0000 0000 1111 1111）的AND结果，观察低8位  
# 输出结果依赖于Python解释器的整数表示，但通常会显示补码形式的取反低8位

5. 左移（Shift Left）<<

将数的二进制表示向左移动指定的位数，右侧超出的位被丢弃，左侧边缘超出的部分用0填充。

1
2
3

a = 60  # 0011 1100  
c = a << 2  # 0011 1100 -> 1111 0000  
print(c)  # 输出: 240

6. 右移（Shift Right）>>

将数的二进制表示向右移动指定的位数，左侧超出的位被丢弃。对于无符号数，右侧边缘超出的部分用0填充；对于有符号数（如Python中的int），则取决于具体实现（通常是算术右移，即符号位被复制）。

1
2
3

a = 60  # 0011 1100  
c = a >> 2  # 0011 1100 -> 0000 1111  
print(c)  # 输出: 15

注意：由于Python的整数是动态大小的，上述右移操作中的“符号位”解释可能不直观，因为Python整数不是固定大小的。然而，对于负数，Python使用补码表示，并在算术右移时保持符号位不变。

成员运算符

Python中的成员运算符主要用于检查某个值是否存在于某个序列（如列表、元组、字符串）或集合中。最常用的成员运算符是in和not in。

详细描述

in运算符：

用途：检查某个值是否存在于指定的序列或集合中。

返回值：如果值存在于序列或集合中，返回True；否则返回False。

适用类型：字符串、列表、元组、集合、字典（此时检查的是字典的键）。

示例：

1
2
3
4
5
6
7

s = "hello"
if 'e' in s:
    print("字符 'e' 在字符串 s 中")  # 输出：字符 'e' 在字符串 s 中

l = [1, 2, 3, 4, 5]
if 3 in l:
    print("数字 3 在列表 l 中")  # 输出：数字 3 在列表 l 中

not in运算符：

用途：检查某个值是否不存在于指定的序列或集合中。

返回值：如果值不存在于序列或集合中，返回True；否则返回False。

适用类型：与in运算符相同。

示例：

1
2
3
4
5
6
7

s = "hello"
if 'z' not in s:
    print("字符 'z' 不在字符串 s 中")  # 输出：字符 'z' 不在字符串 s 中

l = [1, 2, 3, 4, 5]
if 6 not in l:
    print("数字 6 不在列表 l 中")  # 输出：数字 6 不在列表 l 中

注意事项

• 在使用in和not in运算符时，确保被检查的序列或集合不是None，因为对None使用这些运算符会引发TypeError。
• 对于字典，in运算符检查的是字典的键，而不是值。
• 这些运算符在编写条件语句（如if、while等）时非常有用，可以提高代码的可读性和简洁性。

通过合理使用in和not in运算符，可以方便地检查某个值是否存在于某个序列或集合中，从而进行相应的逻辑处理。

海象运算符（Python 3.8+）

Python中的海象运算符（Walrus Operator），英文原名为Assignment Expressions，是一种在表达式内部进行变量赋值并返回该值的运算符。这种运算符的独特之处在于它允许在表达式内部直接进行赋值操作，从而避免了在条件语句或循环语句中多次编写相同的赋值代码，使得代码更加简洁。

代码案例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

# 在if语句中使用海象运算符
if (n := len(a_list)) > 10:
    print(f"List is too long ({n} elements, expected <= 10)")

# 传统写法
n = len(a_list)
if n > 10:
    print(f"List is too long ({n} elements, expected <= 10)")

# 在while循环中使用海象运算符
while (line := file.readline()) != "":
    print(line, end="")

# 传统写法
line = file.readline()
while line != "":
    print(line, end="")
    line = file.readline()

注意事项

1. 可读性与简洁性的权衡：虽然海象运算符可以使代码更简洁，但过度使用可能会降低代码的可读性。因此，在使用时应权衡代码的简洁性和可读性。
2. 版本兼容性：海象运算符是在Python 3.8版本中引入的，因此在使用前请确保您的Python环境版本符合要求。
3. 使用场景：海象运算符特别适用于需要在条件表达式或循环表达式中同时进行赋值和判断的场景，可以有效减少代码的重复和复杂度。

总之，海象运算符是Python中一个非常有用的特性，可以在一定程度上提高代码的简洁性和效率。然而，在使用时需要注意其可读性和兼容性等问题。