人人都会AI编程

7.4 运算符：算术、比较、逻辑、位运算、身份运算、成员运算

更新时间：2026-07-12

运算符是表达式的最小执行单元。Python 提供了丰富的运算符，不仅能完成数值计算，还能进行对象身份判断、成员包含检查等高级操作。下面按照分类逐一说明，并给出实际开发中的常见用法和避坑指南。

7.4.1 算术运算符

这些是最基础的数学运算，所有数值类型（int、float、complex）都能使用。

| 运算符 | 含义 | 示例 | 说明 |
|--------|------|------|------|
| + | 加 | 3 + 2 → 5 | 也可用于序列拼接，如 [1] + [2] → [1,2] |
| - | 减 | 5 - 2 → 3 | 也可用作一元取负 |
| | 乘 | 3 5 → 15 | 序列重复，如 "Hi" * 3 → "HiHiHi" |
| / | 真除 | 7 / 2 → 3.5 | 总是返回 float 类型 |
| // | 整除 | 7 // 2 → 3 | 向下取整，结果是 int（若操作数含 float 则结果为 float） |
| % | 取模 | 7 % 2 → 1 | 求余数，常用于判断奇偶（x % 2 == 0） |
| | 幂 | 2 3 → 8 | 优先级高于左侧的单目运算符，如 -2 ** 2 是 -4 |

实用细节：

  • 整数与浮点数混合运算，结果自动提升为 float（如 3 + 2.0 → 5.0）。
  • 整除对负数向下取整：-7 // 2 → -4，因为 -4 2 = -8 ≤ -7，而 -3 2 = -6 > -7。取模 % 也遵循 a % b = a - (a // b) * b，因此 -7 % 2 → 1。
  • 避免直接将 + 或 * 用于不同类型的序列，除非你明确需要拼接或重复。

7.4.2 比较运算符

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

| 运算符 | 含义 | 说明 |
|--------|------------|------|
| == | 等于 | 值相等即 True，与类型基本无关 |
| != | 不等于 | |
| > | 大于 | |
| < | 小于 | |
| >= | 大于等于 | |
| <= | 小于等于 | |

链式比较：Python 允许将多个比较连接起来，写法接近数学直觉。

age = 25
18 <= age < 60   # True，等价于 (18 <= age) and (age < 60)

这种写法比分开写更简洁，且不会产生额外的临时变量。

注意：== 比较值，与 is（身份运算符）不同，后面会详述。

7.4.3 逻辑运算符

用于布尔值的组合运算，支持短路求值。

| 运算符 | 含义 | 示例 | 结果 |
|--------|------|------|------|
| and | 逻辑与 | True and False | False |
| or | 逻辑或 | True or False | True |
| not | 逻辑非 | not True | False |

短路特性：

  • x and y：若 x 为假，直接返回 x，不再计算 y。
  • x or y：若 x 为真，直接返回 x，不再计算 y。
  • 返回的是参与运算的对象本身，不一定是 True / False。
a = 0 or "hello"       # "hello"，因为 0 为假
b = "hello" and 42     # 42，因为 "hello" 为真，继续求值

这个特性常用于简化条件赋值：

name = user_input or "匿名用户"

优先级：not > and > or。为避免歧义，建议用括号明确意图，比如 (a and b) or c。

7.4.4 位运算符

直接对整数的二进制位进行操作，效率极高，但仅在底层、加密、权限控制等少数场景频繁使用。

| 运算符 | 含义 | 示例 (a=0b1100, b=0b1010) |
|--------|----------|-------------------------------|
| & | 按位与 | a & b → 0b1000 (8) |
| | | 按位或 | a | b → 0b1110 (14) |
| ^ | 按位异或 | a ^ b → 0b0110 (6) |
| ~ | 按位取反 | ~a → -13 (补码表示) |
| << | 左移 | a << 1 → 0b11000 (24) |
| >> | 右移 | a >> 1 → 0b110 (6) |

实用要点：

  • Python 中整数的位数不受限制，右移不会丢失符号位。
  • ~x 等价于 -x - 1。例如 ~0 得到 -1，因为按位取反包括了符号位。
  • 快速乘除 2 的幂：x << n 相当于 x * (2n)，x >> n 相当于 x // (2n)（算术右移）。

7.4.5 身份运算符

用于比较两个对象的内存地址，即判断是否为同一个对象。

| 运算符 | 含义 |
|-----------|------------------------------|
| is | 是同一个对象（地址相同） |
| is not | 不是同一个对象 |

与 == 的关键区别：

  • == 比较值是否相等，由 eq 方法定义。
  • is 比较身份，即 id(a) == id(b)。
a = [1, 2, 3]
b = [1, 2, 3]
a == b        # True  (值相等)
a is b        # False (两个独立的对象)

常见陷阱：小整数（-5 ~ 256）和短字符串由于解释器的驻留机制，可能让 is 意外为 True。

x = 256
y = 256
x is y   # True（驻留）
a = 257
b = 257
a is b   # 通常为 False（CPython 不保证）

因此：除非与 None 这类单例比较，否则用 == 比较值。 判断是否为 None 应写 x is None，这是 PEP 8 推荐写法。

7.4.6 成员运算符

检查某个元素是否包含在可迭代对象中。

| 运算符 | 含义 |
|-----------|--------------|
| in | 在…之中 |
| not in | 不在…之中 |

适用对象：

  • 序列（字符串、列表、元组）：检查元素是否存在。
  • 字典：检查键是否存在，而不是值。
  • 集合：检查成员，速度非常快（基于哈希）。
"Py" in "Python"              # True
3 not in [1, 2, 3, 4]        # False
"age" in {"name": "Tom"}     # False, 检查键

对于自定义对象，只要实现了 contains 方法就可以使用 in，也可以借助 iter 或 getitem 按迭代查找。

7.4.7 运算符优先级速记

完整优先级表官方文档有列，日常只需记住三条：

  1. 算术 > 比较 > 逻辑，例如 x + 1 > 2 and y < 3 先算 x+1，再比较，最后 and。
  2. 括号永远最高，不确定时就加括号，既安全又好读。
  3. 幂运算 从右向左结合，例如 2 3 2 等价于 2 (3 2) → 512，而不是 (2 3) ** 2 → 64。

以上就是 Python 常用运算符的全貌。在实际编码中，合理使用这些运算符可以让代码简洁、意图清晰，也能避开许多“坑”。