Python支持哪些基本运算：算术、比较与逻辑运算符详解

在 Python 编程中，运算是一切逻辑控制与数据加工的物理基石。从最基础的数值累加，到条件分支的真伪判断，再到复杂业务规则的联合短路过滤，代码的底层行为都依赖于运算符的具体规则。Python 将这些高频操作归纳为三大基本体系：负责数值计算的算术运算符、负责关系判定的比较运算符，以及负责布尔决策的逻辑运算符。理解这些运算符的输入约束、边界行为及运算优先级，是编写正确且高效 Python 程序的前提。

一、Python三大基本运算体系全景

Python 的运算符语法设计追求简洁与直观，但在内部机制上保持了强类型的确定性。算术运算面向数值对象并返回数值；比较运算接收任意兼容类型的两个操作数，统一产出布尔结果；逻辑运算则基于对象的真值（Truth Value Testing）执行短路求值，并返回决定最终逻辑走向的真实操作数对象。三者职责分明，相互协同构成了程序执行的核心流水线。

二、算术运算符详解：从常规算式到整除取模边界

Python 提供了 7 种标准的算术运算符。除了经典的加、减、乘以外，Python 在除法操作上细分为“真除法”与“整除（地板除）”，并提供了内建的取模与幂运算。

1. 真除法 (/) 与 整除 (//) 的行为分水岭

在 Python 3 中，单个斜杠 / 称为“真除法（True Division）”。即使参与运算的两个数都是整数，且能够完全除尽，其返回结果也必然是浮点型：

# 示例代码：真除法类型验证
result = 8 / 2
print(result)         # 输出示例: 4.0
print(type(result))   # 输出示例: <class 'float'>

双斜杠 // 称为“地板除（Floor Division）”，其规则是向数轴的左侧（负无穷方向）进行舍入，取不大于计算结果的最大整数。若两操作数均为整数，则返回 int；若至少有一个浮点数，则返回带小数位为 0.0 的 float。

2. 负数参与整除与取模的数学一致性

很多有 C/C++ 或 Java 背景的开发者容易在负数取模时踩坑。在 C/C++ 中，整除是向零截断（Truncate toward zero），余数的符号与被除数一致。而在 Python 中，运算严格遵从计算机科学家 Knuth 提出的地板除定义，始终满足如下恒等式：

a = (a // b) * b + (a % b)

这意味着余数 a % b 的符号始终与除数 b 的符号保持一致（当余数不为 0 时）。

下面是验证上述边界推导的交互式代码片段：

# 正数整除与求余
print(7 // 2)    # 输出示例: 3
print(7 % 2)     # 输出示例: 1

# 负数整除与求余
print(-7 // 2)   # 输出示例: -4 (向负无穷舍入，而非 -3)
print(-7 % 2)    # 输出示例: 1  (因为 -4 * 2 + 1 == -7)

# 除数为负数的情形
print(7 // -2)   # 输出示例: -4
print(7 % -2)    # 输出示例: -1 (因为 -4 * -2 + (-1) == 7)

三、比较运算符详解：布尔判定、链式比较与身份辨析

比较运算符用于衡量两个对象之间的关系，其计算结果在 Python 中必须是明确的布尔值：True 或 False。

1. 优雅的“链式比较”（Chained Comparisons）

在诸如 C、C++ 或 Java 等多数编程语言中，写出 18 <= age <= 60 会触发隐蔽的语法陷阱（先计算 18 <= age 得到布尔值，再拿布尔值与 60 比较）。但在 Python 中，这一语法得到了原生的数学级支持：

age = 25
# Python 原生支持连续链式比较
is_working_age = 18 <= age <= 60
print(is_working_age)  # 输出示例: True

Python 解释器在编译期会将 a < b < c 等价转换为 (a < b) and (b < c)。其关键优势在于：中间的操作数 b 只会被求值一次，即便 b 是一个消耗资源的函数调用，也不会被重复执行。

2. 核心鉴别：等于 (==) 与 身份判断 (is)

在日常开发中，许多初学者经常混淆 == 与 is。它们在底层具有完全不同的判断维度：

• == 比较运算符：由类的 __eq__ 魔术方法驱动，仅比较两者的“内容/值”是否相等。
• is 身份运算符：直接比对两个对象在内存中的实际地址（通过 id(a) == id(b) 衡量），判断它们是否是同一个对象。

list_a = [1, 2, 3]
list_b = [1, 2, 3]

print(list_a == list_b)  # 输出示例: True (因为两者包含相同的元素，值相等)
print(list_a is list_b)  # 输出示例: False (在内存中分别开辟了独立列表实例)

# 比较 None 时官方推荐使用 is
val = None
if val is None:
    print("变量为空")    # 输出示例: 变量为空

四、逻辑运算符详解：真值测试、短路求值与真实返回值

Python 提供了三个逻辑运算符：and（与）、or（或）以及 not（非）。与静态类型语言不同，Python 的逻辑运算建立在“真值测试（Truth Value Testing）”之上，并引入了非常实用的短路求值机制。

1. 对象的真假定义 (Truth Value Testing)

在 Python 中，不仅布尔值能参与逻辑运算，任何对象都可以被隐式转化为布尔真假。根据官方规范，以下对象在逻辑判断中一律被判定为假（False）：

• 布尔常量 False 以及空值单例 None
• 任意数值零：0, 0.0, 0j, Decimal(0), Fraction(0, 1)
• 任意空序列或空容器：""（空字符串）, ()（空元组）, []（空列表）, {}（空字典）, set()（空集合）

除上述特定假值之外的所有对象，默认在条件判断中均被视作真（True）。

2. 短路求值与“返回值即操作数”机制

Python 的 and 与 or 并不机械地返回 True 或 False，而是直接返回最终决定整个表达式结果的那个操作数本身。这一机制由“短路求值（Short-circuit Evaluation）”驱动：

• 对于 X and Y：首先求值 X。若 bool(X) 为假，整个表达式必然为假，解释器立即触发短路，直接返回 X 原对象，完全忽略对 Y 的计算；若 bool(X) 为真，则运算结果取决于 Y，因此继续执行并返回 Y 原对象。
• 对于 X or Y：首先求值 X。若 bool(X) 为真，整个表达式必然为真，解释器立即触发短路，直接返回 X 原对象，跳过 Y；若 bool(X) 为假，则计算并返回 Y 原对象。
• 对于 not X：严格返回标准布尔值。若 bool(X) 为真，返回 False；反之返回 True。

这一机制在工程中被广泛应用于提供“安全防御链”与“默认值备选”：

# 应用场景 1：安全属性访问防报错（短路保护）
user = None
# 若 user 为 None，直接短路返回 None，不会触发 AttributeError
name = user and user.name
print(name)  # 输出示例: None

# 应用场景 2：默认参数兜底回退
input_name = ""
display_name = input_name or "匿名访客"
print(display_name)  # 输出示例: 匿名访客

五、运算符优先级与求值流水线

当一个复杂表达式中同时包含算术、比较和逻辑运算符时，Python 依据固定的优先级由高至低逐步求解。同优先级的运算符按照其结合方向（大多数从左到右，仅幂运算等极少数从右到左）依次计算。

我们可以通过 Python 终端验证上述推导的准确性：

# 表达式实际执行
expression_result = 3 + 4 * 2 > 10 and not False or 5 // 2 == 1
print(expression_result)  # 输出示例: True

# 推荐实践：使用括号提升代码可读性
clean_result = ((3 + (4 * 2)) > 10) and (not False) or ((5 // 2) == 1)
print(clean_result)       # 输出示例: True

六、实战开发中的四大典型陷阱

# 浮点数直接比较的陷阱
print(0.1 + 0.2 == 0.3)  # 输出示例: False
print(0.1 + 0.2)         # 输出示例: 0.30000000000000004

# 正确解决方案：使用 math.isclose 进行容差比较
import math
print(math.isclose(0.1 + 0.2, 0.3))  # 输出示例: True

# 错误示例：位运算符优先级高于比较符，导致先计算 2 & (x < 5) 从而报错
x = 3
# print(x > 1 & x < 5)  # TypeError: unsupported operand type(s) for &: 'int' and 'int'

# 正确写法：使用逻辑 and
print(x > 1 and x < 5)  # 输出示例: True

陷阱 3：链式比较中的副作用（Side Effects）

虽然 Python 确保链式比较中间表达式仅计算一次，但在编写包含函数调用的链式语句时，必须留意各表达式的求值顺序：一旦前置比较为 False，后续所有比较表达式（包括函数）都不会被触发执行。

陷阱 4：赋值符号 (=) 与等于符号 (==)

Python 在设计上禁止将普通赋值语句 = 直接嵌入到条件表达式中（在需要赋值表达式时必须显式使用海象运算符 :=），这一语法限制在语言层面杜绝了其他语言中常犯的 if (x = 1) 笔误错误。

七、总结

掌握 Python 的基本运算体系，关键在于建立清晰的分层视角：

• 算术运算：掌握真除法 /（恒出浮点）与整除 //（向负无穷收敛）的本质差异，理解并牢记负数取模的恒等式约定。
• 比较运算：熟练使用直观简洁的链式比较；在工程中严格区分基于数值比较的 == 与基于内存标识检验的 is。
• 逻辑运算：牢记 and 与 or 的短路特性及其“返回决定性操作数本体”的设计模式，利用真值测试写出精炼安全的防御性代码。
• 工程编码准则：在编写复杂的混合计算表达式时，不要过度依赖优先级记忆，合理使用圆括号 () 不仅能完全规避优先级陷阱，更能为团队协作提供无歧义的高可读代码。