Python比较运算符与表达式详解：从基础语法到自定义类实现

在实际 Python 项目中，无论是数据筛选、条件判断还是流程控制，都离不开对两个值之间关系的判断。if user_age >= 18:、while not data_queue.empty():、if response.status_code == 200:，这些代码的核心都依赖于比较运算符和比较表达式。很多初学者虽然能写出a > b这样的语句，但面对1 <= x < 5这样的链式比较，或者is与==的区别时，就容易产生困惑。更深入一步，在自定义类中如何让对象支持>、<等比较操作，也是工程实践中提升代码可读性和健壮性的关键。

本文将从最基础的比较运算符语法讲起，逐步深入到链式比较、is与==的本质区别、以及如何为自定义类实现富比较方法。目标是让你不仅会用，更能理解其背后的原理，写出更清晰、更符合 Python 风格的条件判断代码。无论你是正在配置 VSCode Python 环境的新手，还是在处理数据分析、Web 开发（如 FastAPI）中遇到复杂条件判断的开发者，掌握这些基础知识都将使你的代码更加可靠。

1. 理解比较运算符：不仅仅是大于和小于

比较运算符，也称为关系运算符，用于对两个值（可以是变量、常量或表达式结果）进行比较，并返回一个布尔值（True或False）。这个布尔值直接决定了if、while等控制流语句的走向。

1.1 六种基本比较运算符

Python 提供了六种基本的比较运算符，它们是最常被使用的工具。

这些运算符的优先级低于算术运算符（如+,-,*,/），但高于赋值运算符（如=）。这意味着表达式会先计算算术部分，再进行比较。

# 算术运算优先于比较运算 result = 10 + 5 > 3 * 4 # 等价于 (10+5) > (3*4)，即 15 > 12 print(result) # 输出: True # 一个常见的错误：混淆 == 和 = # x = 5 是赋值，将5赋给x # x == 5 是比较，判断x的值是否等于5 x = 10 if x == 5: # 正确：使用 == 进行比较 print("x is 5") else: print(f"x is {x}") # 输出: x is 10

1.2 比较表达式的本质与返回值

一个完整的比较表达式（如a > b）在 Python 中会被求值为一个布尔类型的对象：True或False。你可以将这个结果赋值给变量，或者直接用在需要布尔值的地方。

age = 20 is_adult = age >= 18 # 比较表达式的结果被赋值给变量 is_adult print(is_adult, type(is_adult)) # 输出: True <class 'bool'> # 直接用在条件判断中 if is_adult: print("可以访问成人内容。") # 甚至可以直接打印表达式本身 print(10 == 10.0) # 输出: True (注意：整数10和浮点数10.0在值上相等)

这里有一个关键点：True和False在 Python 中实际上是整数1和0的别名。这意味着它们可以参与数值运算，但这通常不是好的实践，容易让代码意图变得模糊。

# 了解即可，不推荐在实际代码中这样写 count_true = True + True + False # 等价于 1 + 1 + 0 print(count_true) # 输出: 2 # 更清晰的写法应该是： conditions_met = 0 if condition_a: conditions_met += 1 if condition_b: conditions_met += 1

1.3 不同类型数据间的比较

Python 支持在不同数据类型间进行比较，但规则需要明确，否则可能导致TypeError或令人意外的结果。

• 数值类型（int, float, complex）：可以直接比较。复数仅支持==和!=比较。
• 字符串：按字典序（lexicographical order）逐个字符比较 Unicode 码点。这通常符合直觉，但要注意大小写（‘A‘ < ‘a‘）和不同语言字符的顺序。
• 列表、元组等序列：也是按字典序比较，逐个元素进行，要求元素本身可比较。
• 不同类型间比较：除了数值类型之间，其他大多数不同类型比较会引发TypeError。

# 数值比较 print(3.14 > 3) # 输出: True print(10 == 10.0) # 输出: True (值相等) # 字符串比较 print("apple" < "banana") # 输出: True (‘a‘ 在 ‘b‘ 之前) print("Apple" < "apple") # 输出: True (大写字母码点小于小写字母) print("10" < "2") # 输出: True! 字符串比较，’1‘ 的码点小于 ‘2‘ # 列表比较 print([1, 2, 3] < [1, 2, 4]) # 输出: True (第三个元素 3 < 4) print([1, 2] < [1, 2, 3]) # 输出: True (较短列表被视为更小) # 不同类型比较 - 可能导致错误 # print(10 < "20") # 这会引发 TypeError: ‘<‘ not supported between instances of ‘int‘ and ‘str‘

注意：字符串与数字的比较会直接报错，这是 Python 的防护机制，避免隐式类型转换带来的潜在 bug。如果你需要比较，必须先进行显式类型转换，例如int(“20“)。

2. 链式比较：Python 的语法糖

如果你在数学中写过0 <= x <= 10这样的区间判断，你会高兴地发现 Python 原生支持这种写法，这被称为链式比较（Chained Comparisons）。

2.1 链式比较的语法与求值顺序

链式比较允许你将多个比较运算符串联起来，形成一个更易读的表达式。Python 会以一种符合直觉的方式对其进行求值。

x = 5 # 传统写法：使用逻辑运算符 and traditional = (0 <= x) and (x <= 10) # Pythonic 写法：链式比较 chained = 0 <= x <= 10 print(traditional) # 输出: True print(chained) # 输出: True # 两者等价

链式比较a op1 b op2 c在内部会被求值为(a op1 b) and (b op2 c)。注意，中间的b只会被计算一次。这对于表达式有副作用时很重要。

def get_value(): print(“函数被调用了！“) return 5 # 使用链式比较，get_value() 只被调用一次 if 0 <= get_value() <= 10: print(“值在区间内“) # 输出: # 函数被调用了！ # 值在区间内 # 如果拆开写，可能会调用两次（取决于具体实现和优化） # if 0 <= get_value() and get_value() <= 10: # 不推荐，可能调用两次

2.2 链式比较的常见应用场景

链式比较极大地提升了区间判断、范围验证等代码的可读性。

• 数值范围检查：这是最经典的用法。

  score = 85 if 90 <= score <= 100: grade = ‘A‘ elif 80 <= score < 90: grade = ‘B‘ # 链式比较可以混合使用 <= 和 < elif 70 <= score < 80: grade = ‘C‘ else: grade = ‘F‘ print(f“分数 {score}，等级 {grade}“) # 输出: 分数 85，等级 B

• 索引有效性验证：在访问列表、字符串元素前，检查索引是否在有效范围内。

  my_list = [‘a‘, ‘b‘, ‘c‘, ‘d‘] index = 2 if 0 <= index < len(my_list): print(f“安全访问: {my_list[index]}“) # 输出: 安全访问: c else: print(“索引越界！“)

• 复杂条件简化：将多个相关条件合并，使逻辑更清晰。

  temperature = 22 humidity = 65 # 判断是否处于舒适的室内环境 if 18 <= temperature <= 26 and 40 <= humidity <= 70: print(“环境舒适“)

2.3 链式比较的陷阱与注意事项

虽然链式比较很方便，但使用时也需注意其边界情况。

1. 运算符方向必须一致：链式比较要求比较的方向（递增或递减）在逻辑上是连贯的。a < b > c在语法上是合法的（被解释为(a < b) and (b > c)），但可读性很差，不推荐使用。a > b < c同理。

   x, y, z = 1, 3, 2 # 合法但难以理解 result = x < y > z # 等价于 (x < y) and (y > z) print(result) # 输出: True (因为 1<3 且 3>2)

2. 不要与赋值运算符混淆：在链式比较中不能插入赋值运算符=。

   # 错误写法 # if 0 <= x = 5 <= 10: # SyntaxError # 正确做法：先赋值，再比较 x = 5 if 0 <= x <= 10: ...

3. 短路求值依然有效：由于链式比较被展开为and连接，所以具有短路特性。如果第一个比较为False，后面的比较将不会进行求值。

   def false_func(): print(“这个函数被调用了“) return False if 10 < 5 and false_func(): # 10<5 为 False，false_func 不会执行 pass # 没有输出 if 10 < 5 <= false_func(): # 链式比较，10<5 为 False，整个表达式为 False，false_func 不会执行 pass # 没有输出

3.is与==：身份比较与值比较的根本区别

这是 Python 面试中最常见的问题之一，也是实际编码中容易产生微妙 bug 的地方。is和==虽然都用于比较，但它们的比较维度完全不同。

3.1==（等于运算符）：值比较

==运算符检查两个对象所包含的值是否相等。它调用的是对象的__eq__()方法。对于内置类型，Python 已经实现了合理的值比较逻辑。

list_a = [1, 2, 3] list_b = [1, 2, 3] list_c = [1, 2, 4] print(list_a == list_b) # 输出: True，内容相同 print(list_a == list_c) # 输出: False，内容不同 dict_a = {‘name‘: ‘Alice‘, ‘age‘: 30} dict_b = {‘age‘: 30, ‘name‘: ‘Alice‘} # 字典键值对顺序不影响相等性 print(dict_a == dict_b) # 输出: True

3.2is（身份运算符）：对象标识比较

is运算符检查两个变量是否指向内存中的同一个对象，即它们的身份标识（id）是否相同。你可以通过内置函数id()获取对象的身份标识（通常代表内存地址）。

list_a = [1, 2, 3] list_b = [1, 2, 3] # 创建了一个新的列表对象 list_c = list_a # list_c 和 list_a 指向同一个对象 print(id(list_a), id(list_b), id(list_c)) # 输出类似: 140245678456000 140245678456896 140245678456000 # list_a 和 list_b 的 id 不同，list_a 和 list_c 的 id 相同 print(list_a is list_b) # 输出: False，不是同一个对象 print(list_a is list_c) # 输出: True，是同一个对象

3.3 关键用例与常见误区

理解两者区别后，我们来看具体怎么用。

• 用is检查None、True、False：在 Python 中，None、True、False是单例对象。检查一个变量是否是None，永远应该使用is或is not。

  def process_data(data): if data is None: # 正确做法 print(“未接收到数据“) return # ... 处理数据 # 错误做法： if data == None: （虽然可能工作，但不Pythonic，且可能被重载的 __eq__ 影响）

• 小整数缓存（Interning）导致的陷阱：Python 会对小整数（通常是 -5 到 256）进行缓存，复用对象以提升性能。这会导致一些令人困惑的现象。

  a = 100 b = 100 print(a is b) # 输出: True (因为小整数缓存，a和b指向同一个对象) c = 1000 d = 1000 print(c is d) # 输出: False (大整数，创建了不同的对象) print(c == d) # 输出: True (值相等) # 重要结论：永远不要用 `is` 来比较数值、字符串等值类型是否相等，只用 `==`。

• 可变对象与不可变对象：对于不可变对象（如字符串、元组），is和==的结果可能因为解释器的优化（如字符串驻留）而偶然相同，但这不能作为依赖。对于可变对象（如列表、字典），is用于检查别名关系非常有用。

  # 字符串驻留（interning）示例 - 不可依赖 s1 = “hello“ s2 = “hello“ print(s1 is s2) # 可能输出 True (CPython 会驻留短字符串) s3 = “hello world!“ s4 = “hello world!“ print(s3 is s4) # 也可能输出 True，但这是实现细节，不是语言保证 # 安全做法：比较字符串永远用 ==

3.4 如何为自定义类定义比较行为

当你定义自己的类时，可以通过实现特殊方法（魔术方法）来控制==和!=的行为。is的行为无法被自定义，因为它比较的是对象标识。

• __eq__(self, other)：定义==的行为。
• __ne__(self, other)：定义!=的行为（通常可以不实现，Python 3 默认会根据__eq__推导）。
• __lt__(self, other)：定义<的行为。
• __le__(self, other)：定义<=的行为。
• __gt__(self, other)：定义>的行为。
• __ge__(self, other)：定义>=的行为。

实现__eq__是最常见的需求。

class Person: def __init__(self, name, age): self.name = name self.age = age # 定义如何判断两个 Person 实例“值相等” def __eq__(self, other): if not isinstance(other, Person): return NotImplemented # 告诉 Python 无法比较，让其尝试其他方法或返回 False return self.name == other.name and self.age == other.age # 可选：定义小于 < 的比较规则（例如按年龄比） def __lt__(self, other): if not isinstance(other, Person): return NotImplemented return self.age < other.age # 测试 p1 = Person(“Alice“, 30) p2 = Person(“Alice“, 30) p3 = Person(“Bob“, 25) print(p1 == p2) # 输出: True，调用 p1.__eq__(p2) print(p1 == p3) # 输出: False print(p1 is p2) # 输出: False，始终是不同的对象 print(p3 < p1) # 输出: True，调用 p3.__lt__(p1)，因为 25 < 30 # 实现了 __lt__ 后，sorted() 函数就可以对 Person 列表排序了 people = [p1, p3] print(sorted(people)) # 按年龄排序，输出: [<__main__.Person object at ...>, <__main__.Person object at ...>] # 要友好显示，还可以实现 __repr__ 方法

注意：实现__eq__时，通常也应该考虑实现__hash__方法，特别是如果你打算将类的实例放入集合（set）或作为字典（dict）的键。这是另一个重要话题，但基本原则是：相等（==）的对象应该具有相同的哈希值。

4. 比较运算符的优先级与结合性

在复杂的表达式中，了解比较运算符如何与其他运算符交互至关重要，这决定了表达式的求值顺序。

4.1 优先级规则

Python 运算符的优先级从高到低大致如下（部分列出）：

1. **(指数)
2. +x,-x,~x(正负号，按位取反)
3. *,/,//,%(乘、除、整除、取模)
4. +,-(加、减)
5. <<,>>(位移)
6. &(按位与)
7. ^(按位异或)
8. |(按位或)
9. in,not in,is,is not,<,<=,>,>=,!=,==(比较，包含成员测试和身份测试)
10. not(布尔非)
11. and(布尔与)
12. or(布尔或)

关键点：所有比较运算符的优先级相同，且高于布尔运算符not、and、or，但低于算术运算符和位运算符。

# 算术优先于比较 result1 = 5 + 3 * 2 > 10 # 等价于 (5 + (3*2)) > 10 => 11 > 10 print(result1) # 输出: True # 比较优先于布尔运算 result2 = 5 > 3 and 2 < 4 # 等价于 (5>3) and (2<4) => True and True print(result2) # 输出: True # 容易出错的例子： not 的优先级高于 and/or，但低于比较 flag = True value = 10 # 意图：如果 flag 为 False 或者 value 不在 5 到 15 之间 if not flag or value < 5 or value > 15: print(“条件触发“) # 这个写法是清晰的，因为比较运算符先求值。 # 一个混淆的例子 if not value == 10: # 等价于 not (value == 10) print(“value 不是 10“) # 更好的写法是： if value != 10: print(“value 不是 10“)

4.2 结合性与求值顺序

比较运算符是左结合的，但在链式比较中，求值顺序是特殊的（如前所述，a op1 b op2 c被求值为(a op1 b) and (b op2 c)）。

对于由and或or连接的多个比较表达式，Python 会进行短路求值。

def expensive_check(): print(“执行了昂贵的计算“) return False # 短路求值：如果第一个条件为 False，`and` 后面的不会执行 if False and expensive_check(): print(“这行不会执行“) # 没有输出，expensive_check 未被调用 # 短路求值：如果第一个条件为 True，`or` 后面的不会执行 if True or expensive_check(): print(“条件为真“) # 输出: 条件为真 # expensive_check 未被调用

利用短路求值可以写出更安全、高效的代码，例如在访问对象属性前先检查对象是否为None。

# 安全访问对象属性的模式 class User: def __init__(self, name): self.name = name def get_profile(self): # 假设可能返回 None return Profile() if some_condition else None user = User(“Alice“) profile = user.get_profile() # 安全写法：利用短路求值 if profile is not None and profile.is_active: print(f“{user.name} 的档案是活跃的“) # 如果 profile 为 None，`profile.is_active` 不会被执行，避免了 AttributeError

5. 实战：在常见场景中应用比较表达式

理解了原理，我们来看几个结合了热搜词中相关技术的综合应用场景，这些场景在数据分析、Web 开发、自动化脚本中非常普遍。

5.1 场景一：数据清洗与条件替换

在数据分析（如使用 pandas）或处理 Excel/CSV 数据时，经常需要根据条件替换某一列的值。这直接用到比较表达式。

假设我们有一个代表年龄的列表，需要将无效年龄（如负数或大于 150）替换为None。

# 模拟从 Excel/CSV 读取的年龄数据 ages = [25, -5, 30, 160, 42, 0, 99] cleaned_ages = [] for age in ages: # 使用链式比较清晰定义有效年龄范围 if 0 <= age <= 120: cleaned_ages.append(age) else: cleaned_ages.append(None) # 或替换为默认值，如 -1 print(cleaned_ages) # 输出: [25, None, 30, None, 42, 0, 99] # 使用列表推导式更简洁 cleaned_ages_v2 = [age if 0 <= age <= 120 else None for age in ages] print(cleaned_ages_v2) # 输出: [25, None, 30, None, 42, 0, 99]

在 pandas 中，这种操作更为高效：

import pandas as pd df = pd.DataFrame({‘age‘: ages}) # 使用 .loc 和比较表达式进行条件替换 df.loc[~df[‘age‘].between(0, 120), ‘age‘] = None # ~ 表示取反 print(df)

5.2 场景二：API 响应状态码判断

在使用requests库进行网络请求（如爬虫或调用 REST API）时，必须检查响应状态码。

import requests try: response = requests.get(‘https://api.example.com/data‘, timeout=5) # 成功的状态码通常在 200 到 299 之间 if 200 <= response.status_code < 300: print(“请求成功！“) data = response.json() # 进一步处理 data... elif response.status_code == 401: print(“认证失败，请检查 Token。“) elif response.status_code == 404: print(“请求的资源不存在。“) elif 500 <= response.status_code < 600: print(f“服务器内部错误，状态码: {response.status_code}“) else: print(f“未处理的 HTTP 状态码: {response.status_code}“) except requests.exceptions.Timeout: print(“请求超时“) except requests.exceptions.RequestException as e: print(f“网络请求发生错误: {e}“)

这里用到了比较表达式200 <= response.status_code < 300来清晰表示成功状态码的范围。

5.3 场景三：配置验证与环境检查

在配置 Python 环境（如 VSCode、PyCharm）或运行脚本前，经常需要检查 Python 版本、依赖包版本等。

import sys import subprocess def check_environment(): """检查运行环境是否满足要求""" # 1. 检查 Python 版本 required_python_version = (3, 8) # 要求 Python 3.8+ current_version = sys.version_info[:2] # (主版本, 次版本) if current_version < required_python_version: print(f“错误：需要 Python {required_python_version[0]}.{required_python_version[1]} 或更高版本，当前是 {sys.version}“) return False print(f“Python 版本检查通过: {sys.version}“) # 2. 尝试导入关键包，检查是否安装 required_packages = [‘requests‘, ‘pandas‘, ‘numpy‘] missing_packages = [] for package in required_packages: try: __import__(package) except ImportError: missing_packages.append(package) if missing_packages: print(f“缺少必需的包: {missing_packages}“) print(“请运行: pip install “ + “ “.join(missing_packages)) return False print(“所有必需包已安装。“) # 3. 检查特定命令或工具是否存在（例如，需要系统命令） try: # 示例：检查 git 命令是否可用 subprocess.run([‘git‘, ‘--version‘], check=True, capture_output=True) print(“Git 可用。“) except (subprocess.CalledProcessError, FileNotFoundError): print(“警告：未找到 Git 命令，某些功能可能受限。“) # 这里不返回 False，因为 Git 可能不是强依赖 return True if check_environment(): print(“环境检查通过，可以启动应用。“) # 启动你的 FastAPI 应用或数据分析脚本... else: print(“环境检查失败，请先解决上述问题。“) sys.exit(1)

这个例子中，current_version < required_python_version使用了元组比较，Python 会逐个元素进行比较，非常直观。

6. 常见问题与排查指南

即使理解了概念，在实际编码和调试中，关于比较运算符的问题依然常见。下面列出典型问题及其排查路径。

6.1 浮点数比较的精度问题

这是数值计算中一个经典陷阱。由于浮点数在计算机中的二进制表示存在精度限制，直接使用==比较两个浮点数是否相等可能不可靠。

现象：理论上应该相等的浮点数比较结果却是False。

print(0.1 + 0.2 == 0.3) # 输出: False print(0.1 + 0.2) # 输出: 0.30000000000000004

原因：十进制小数 0.1、0.2 在二进制中是循环小数，无法精确表示。计算0.1 + 0.2会产生一个极其接近但不完全等于 0.3 的值。

解决方案：

1. 允许一定误差：检查两个浮点数的差的绝对值是否小于一个很小的阈值（epsilon）。

   def float_equal(a, b, epsilon=1e-9): return abs(a - b) < epsilon print(float_equal(0.1 + 0.2, 0.3)) # 输出: True

2. 使用math.isclose(Python 3.5+)：这是标准库提供的更健壮的比较方法。

   import math print(math.isclose(0.1 + 0.2, 0.3)) # 输出: True # 可以调整相对容差(rel_tol)和绝对容差(abs_tol) print(math.isclose(1.0, 1.001, rel_tol=1e-2)) # 输出: True (1%的相对误差内)

3. 使用 Decimal 类型：对于需要精确十进制运算的场景（如金融计算），使用decimal.Decimal。

   from decimal import Decimal a = Decimal(‘0.1‘) b = Decimal(‘0.2‘) c = Decimal(‘0.3‘) print(a + b == c) # 输出: True

6.2is与==误用导致逻辑错误

现象：代码在大部分情况下工作正常，但在某些特定条件下（如使用大整数、从函数返回新对象）判断出错。

排查步骤：

1. 检查代码中所有对None、True、False的比较，是否使用了is/is not。
2. 检查是否对整数、字符串、元组等值类型使用了is进行比较。如果使用了，一律改为==。
3. 如果是在自定义类中，检查是否正确地实现了__eq__方法。使用print(id(obj1), id(obj2))来确认两个变量是否真的是同一个对象。

示例修复：

# 错误代码 cache = {} key = 1000 if cache.get(key) is None: # 问题：get() 返回的是值，用 is 比较可能不可靠（尽管 None 是单例，但习惯不好） cache[key] = compute_value() # 更清晰正确的代码 if key not in cache: # 直接检查键是否存在 cache[key] = compute_value() # 或者明确检查 None if cache.get(key) is None: # 对于 None 检查，is 是合适的，但前一种更直接。 cache[key] = compute_value()

6.3 链式比较中的逻辑错误

现象：链式比较的结果与预期不符，尤其是当比较涉及函数调用或具有副作用的表达式时。

排查步骤：

1. 将链式比较展开为使用and的普通形式，检查逻辑是否正确。a < b < c等价于(a < b) and (b < c)。
2. 确认中间表达式b是否会被求值多次。在链式比较中，b只求值一次，这是安全的。但如果展开写，可能会无意中求值两次。
3. 检查比较运算符的方向是否一致且符合逻辑。避免使用a < b > c这种难以理解的形式。

示例：

# 意图：x 在 0 到 get_limit() 之间（不含边界） limit = get_limit() if 0 < x < limit: # 正确：x 只出现一次，get_limit() 只调用一次（假设在之前调用） ... # 潜在问题：如果 get_limit() 每次调用返回值可能不同 # if 0 < x < get_limit(): # 链式比较中，get_limit() 只调用一次，结果固定 # if 0 < x and x < get_limit(): # 展开写法中，get_limit() 被调用两次，可能返回不同值

6.4 自定义类比较未返回NotImplemented

现象：自定义类的==比较在与非同类对象比较时，没有返回False，而是引发了错误或返回了意外的True。

排查步骤：

1. 在实现__eq__方法时，第一件事就是检查other的类型。
2. 如果other不是当前类的实例，应返回NotImplemented，而不是False。NotImplemented是 Python 的一个特殊单例值，它告诉解释器“我不知道怎么比较，让other那边试试看”。如果对方也不知道怎么比较，Python 会最终返回False（对于==）或引发TypeError。
3. 反之，如果直接返回False，那么MyClass() == 42会得到False，这可能不是你想要的行为（你或许希望它引发 TypeError 或让int的__eq__有机会处理）。

正确实现示例：

class MyClass: def __init__(self, value): self.value = value def __eq__(self, other): if not isinstance(other, MyClass): return NotImplemented # 关键！ return self.value == other.value obj = MyClass(10) print(obj == MyClass(10)) # True print(obj == MyClass(20)) # False print(obj == 10) # False (因为 int.__eq__(MyClass) 也不知道怎么比) # 如果没有返回 NotImplemented，而是 return False，上一行结果也是 False，但语义不同。

7. 最佳实践与性能考量

写出正确且高效的比较代码，需要遵循一些约定俗成的规则。

7.1 比较运算符使用风格指南

1. 优先使用链式比较表示范围：if 0 <= index < len(array):比if index >= 0 and index < len(array):更清晰、更 Pythonic。
2. None检查用is和is not：这是 PEP 8 明确推荐的风格。
3. 布尔值不要用==比较：直接写if is_valid:，而不是if is_valid == True:。写if not is_valid:，而不是if is_valid == False:。
4. 警惕隐式类型转换：==和!=在比较不同类型时，可能会进行隐式转换（如1 == 1.0为True）。确保这是你期望的行为。对于需要严格类型匹配的场景，可以考虑先检查类型type(a) is type(b) and a == b，或者使用isinstance。
5. 为自定义类实现富比较方法时，考虑实现全套：如果你实现了__lt__，通常也应该实现__gt__、__le__、__ge__。可以使用functools.total_ordering装饰器来简化，只需定义__eq__和其中一个（如__lt__），它会自动补全其他方法。

   from functools import total_ordering @total_ordering class Student: def __init__(self, name, grade): self.name = name self.grade = grade def __eq__(self, other): if not isinstance(other, Student): return NotImplemented return self.grade == other.grade def __lt__(self, other): if not isinstance(other, Student): return NotImplemented return self.grade < other.grade # __le__, __gt__, __ge__ 由 total_ordering 自动生成 def __repr__(self): return f“Student({self.name}, {self.grade})“ s1 = Student(“Alice“, 85) s2 = Student(“Bob“, 92) print(s1 < s2) # True print(s1 >= s2) # False print(s1 != s2) # True

7.2 性能考量与小优化

1. 短路求值是朋友：在and连接的条件中，将最可能为假、或计算成本最低的条件放在前面。在or连接的条件中，将最可能为真、或计算成本最低的条件放在前面。

   # 较慢的检查放后面 if user is not None and user.has_permission(‘admin‘): # 先检查 None，避免在 None 上调用方法 ... # 更可能失败的条件放前面 if not data or len(data) == 0: # 先检查 data 是否存在/是否为空 return

2. 成员测试用in，而非循环比较：检查元素是否在集合或列表中时，使用in运算符，它通常比手写循环比较更高效，尤其是对于集合（set）和字典（dict）的键，其时间复杂度接近 O(1)。

   valid_statuses = {200, 201, 202} # 使用集合，查找更快 if response.status_code in valid_statuses: ...

3. 避免在循环中重复计算不变的比较项：将循环中不变的部分提到循环外部。

   # 低效 threshold = calculate_threshold() # 假设这个函数很耗时 for item in large_list: if item.value > threshold: process(item) # 高效 threshold = calculate_threshold() for item in large_list: if item.value > threshold: process(item)

掌握比较运算符和表达式，是编写清晰、正确 Python 代码的基石。从最简单的if a > b到复杂的链式比较和自定义类比较，理解其背后的原理能让你避免许多隐蔽的 bug。下次当你写下条件判断时，不妨多思考一下：我是在比较值还是身份？这个范围判断用链式写法是否更清晰？这个浮点数比较是否需要容错？养成这些习惯，你的代码质量会自然提升。