Python 运算符

学习目标

掌握 Python 中七类运算符的基本用法与语义
理解算术、比较、逻辑、位运算等核心操作的执行规则
熟悉赋值、身份、成员及三元运算符的使用场景
掌握运算符优先级与结合性对表达式求值的影响

什么是运算符

在 Python 中，运算符是用于对操作数执行特定操作的特殊符号。例如，在表达式 a + b 中，+ 是运算符，a 和 b 是操作数。Python 支持多种类型的运算符，主要包括：

算术运算符
比较（关系）运算符
逻辑运算符
位运算符
赋值运算符
身份运算符
成员运算符
三元（条件）运算符

算术运算符

用于执行基本数学运算。

运算符	名称	示例	结果
`+`	加法	`15 + 4`	`19`
`-`	减法	`15 - 4`	`11`
`*`	乘法	`15 * 4`	`60`
`/`	除法	`15 / 4`	`3.75`
`//`	整除（地板除）	`15 // 4`	`3`
`%`	取模（余数）	`15 % 4`	`3`
`**`	幂运算	`15 ** 4`	`50625`

a = 15
b = 4

print("加法:", a + b)           # 19
print("减法:", a - b)           # 11
print("乘法:", a * b)           # 60
print("除法:", a / b)           # 3.75
print("整除:", a // b)          # 3
print("取模:", a % b)           # 3
print("幂运算:", a ** b)        # 50625

注意：在 Python 3 中，/ 总是返回浮点数，即使两个操作数都是整数。若需整数结果，请使用 //。

比较（关系）运算符

用于比较两个值，返回布尔值 True 或 False。

运算符	含义	示例	结果
`==`	等于	`13 == 33`	`False`
`!=`	不等于	`13 != 33`	`True`
`>`	大于	`13 > 33`	`False`
`<`	小于	`13 < 33`	`True`
`>=`	大于等于	`13 >= 33`	`False`
`<=`	小于等于	`13 <= 33`	`True`

a = 13
b = 33

print(a > b)   # False
print(a < b)   # True
print(a == b)  # False
print(a != b)  # True
print(a >= b)  # False
print(a <= b)  # True

逻辑运算符

用于组合多个条件表达式。

运算符	名称	说明	示例	结果
`and`	逻辑与	两者都为真才返回 `True`	`True and False`	`False`
`or`	逻辑或	至少一个为真即返回 `True`	`True or False`	`True`
`not`	逻辑非	取反	`not True`	`False`

优先级（从高到低）

not
and
or

示例

a = True
b = False

print(a and b)  # False
print(a or b)   # True
print(not a)    # False

位运算符

直接对整数的二进制位进行操作。

运算符	名称	示例（a=10, b=4）	说明
`&`	按位与	`10 & 4` → `0`	二进制位都为 1 才得 1
`\|`	按位或	`10 \| 4` → `14`	任一位为 1 即得 1
`^`	按位异或	`10 ^ 4` → `14`	位不同则为 1
`~`	按位取反	`~10` → `-11`	补码取反（含符号位）
`<<`	左移	`10 << 2` → `40`	相当于 ×2²
`>>`	右移	`10 >> 2` → `2`	相当于 ÷2²（向下取整）

二进制表示辅助理解

10 的二进制：1010
 4 的二进制：0100
------------------
10 & 4 → 0000 → 0
10 | 4 → 1110 → 14
10 ^ 4 → 1110 → 14
~10 → ...11110101（补码）→ -11

示例代码

a = 10
b = 4

print(a & b)   # 0
print(a | b)   # 14
print(~a)      # -11
print(a ^ b)   # 14
print(a >> 2)  # 2
print(a << 2)  # 40

赋值运算符

用于将右侧表达式的值赋给左侧变量。

运算符	示例	等价于
`=`	`x = 5`	—
`+=`	`x += 3`	`x = x + 3`
`-=`	`x -= 3`	`x = x - 3`
`*=`	`x *= 3`	`x = x * 3`
`/=`	`x /= 3`	`x = x / 3`
`//=`	`x //= 3`	`x = x // 3`
`%=`	`x %= 3`	`x = x % 3`
`**=`	`x **= 3`	`x = x ** 3`
`<<=`	`x <<= 2`	`x = x << 2`
`>>=`	`x >>= 2`	`x = x >> 2`

a = 10
b = a
print(b)        # 10

b += a          # b = b + a
print(b)        # 20

b -= a
print(b)        # 10

b *= a
print(b)        # 100

b <<= a         # b = b << 10 (100 * 2^10)
print(b)        # 102400

身份运算符

用于判断两个变量是否引用同一个对象（即内存地址是否相同）。

运算符	含义
`is`	为 `True` 当且仅当同一对象
`is not`	为 `True` 当不是同一对象

注意：is 比较的是身份（id），而 == 比较的是值。

示例

a = 10
b = 20
c = a

print(a is not b)  # True（不同对象）
print(a is c)      # True（c 是 a 的引用）

小整数缓存：Python 对 -5 到 256 的整数做了缓存，因此 x = 100; y = 100; print(x is y) 会输出 True，但这属于实现细节，不应依赖。

成员运算符

用于测试某个值是否存在于序列（如列表、字符串、元组等）中。

运算符	含义
`in`	存在于序列中则为 `True`
`not in`	不存在于序列中则为 `True`

x = 24
y = 20
numbers = [10, 20, 30, 40, 50]

if x not in numbers:
    print("x 不在列表中")
else:
    print("x 在列表中")

if y in numbers:
    print("y 在列表中")
else:
    print("y 不在列表中")

x 不在列表中
y 在列表中

三元运算符

提供一种简洁的单行 if-else 写法。

语法

value_if_true if condition else value_if_false

示例

a, b = 10, 20
min_val = a if a < b else b
print(min_val)  # 10

等价于：

if a < b:
    min_val = a
else:
    min_val = b

运算符优先级

1. 优先级（从高到低）

优先级	运算符
最高	`()`
	`**`（幂运算，右结合）
	`~`, `+`, `-`（按位取反、正负号）
	`*`, `/`, `//`, `%`
	`+`, `-`（加减）
	`<<`, `>>`
	`&`
	`^`
	`\|`
	`==`, `!=`, `>`, `<`, `>=`, `<=`
	`is`, `is not`, `in`, `not in`
	`not`
	`and`
最低	`or`

2. 结合性

大多数运算符为 左结合（从左到右计算）
幂运算 ** 是 右结合

示例分析

expr = 10 + 20 * 30
print(expr)  # 610（先算 20*30=600，再 +10）

# 逻辑运算优先级：and 高于 or
if name == "Alex" or name == "John" and age >= 2:
    # 等价于：name == "Alex" or (name == "John" and age >= 2)

print(100 / 10 * 10)   # 100.0（左结合：(100/10)*10）
print(5 - 2 + 3)       # 6（左结合：(5-2)+3）
print(5 - (2 + 3))     # 0（括号优先）
print(2 ** 3 ** 2)     # 512（右结合：2**(3**2) = 2**9 = 512）

重点总结

算术运算符中 / 返回浮点数，// 返回整数。
比较运算符返回布尔值，常用于条件判断。
逻辑运算符遵循 not > and > or 的优先级。
位运算符操作底层二进制，适用于性能敏感或硬件相关场景。
赋值运算符支持复合操作，提升代码简洁性。
is 判断对象身份，== 判断值相等。
成员运算符适用于所有序列和集合类型。
三元运算符可简化简单条件赋值。
始终使用括号明确表达式意图，避免依赖优先级规则。

思考题

为什么 2 ** 3 ** 2 的结果是 512 而不是 64？这体现了什么结合性？
执行以下代码后，a is b 和 a == b 的结果分别是什么？为什么？
```
a = [1, 2, 3]
b = [1, 2, 3]
```
如何用一行代码找出三个数中的最大值？尝试使用三元运算符实现。