P1E-Python-7大运算符类别详解：is和==有什么区别？优先级陷阱如何避免？

郑恩赐
68 阅读29分钟

P1E-Python-7大运算符类别详解：is和==有什么区别？优先级陷阱如何避免？

📝 摘要

面向零基础，系统讲解 Python 七大运算符类别（算术、赋值、比较、逻辑、位、成员、身份）；通过生活化比喻与对比示例，帮你理解 is 与 == 的区别、运算符优先级陷阱，掌握写出正确代码的核心技能。

什么是运算符（operator（运算符））？

在深入学习 Python 运算符之前，让我们先理解 运算符（operator（运算符）） 的本质和重要性。

运算符的定义

运算符（operator（运算符）） 是用于执行特定运算或操作的符号，就像数学中的加号（+）、减号（-）、乘号（×）一样。在编程中，运算符用于对 操作数（operand（操作数）） 进行运算，生成结果。

运算符的组成

一个完整的运算表达式通常包含三个部分：

[结果] = [操作数1] [运算符] [操作数2]

例如：

  • result = 3 + 5：result 是结果（变量），3 和 5 是操作数，+ 是运算符
  • is_adult = age >= 18：is_adult 是结果（变量），age 和 18 是操作数，>= 是运算符，结果是布尔值（True 或 False）

说明：在编程中，我们通常将运算结果赋值给变量，所以格式是 变量 = 表达式。当然，表达式本身也可以直接使用，如 3 + 5 或 age >= 18。

运算符的作用

运算符就像编程世界的 工具集，让你能够：

  1. 执行数学运算：计算数值、处理数学问题
  2. 进行比较判断：判断值的大小、相等性等关系
  3. 组合逻辑条件：将多个条件组合起来进行复杂判断
  4. 操作数据：赋值、修改、检查成员关系等

运算符的重要性

想象一下，如果没有运算符，编程会是什么样子：

# 没有运算符的编程世界（假设）
# 每次计算都需要调用复杂的函数
result = add_function(3, 5)
is_adult = greater_or_equal_function(age, 18)

有了运算符，代码变得简洁直观：

# 使用运算符（简洁直观）
result = 3 + 5
is_adult = age >= 18

运算符让代码更接近自然语言和数学表达式，大大提高了代码的可读性和编写效率。

Python 运算符的分类

Python 提供了丰富的运算符，可以按照功能分为以下 七大类别：

运算符类别主要功能典型示例
算术运算符（arithmetic operators（算术运算符））执行数学运算+, -, *, /, //, %, **
赋值运算符（assignment operators（赋值运算符））给变量赋值=, +=, -=, *=, /=
比较运算符（comparison operators（比较运算符））比较值的大小或相等性==, !=, >, <, >=, <=
逻辑运算符（logical operators（逻辑运算符））组合逻辑条件and, or, not
位运算符（bitwise operators（位运算符））操作二进制位`&`, `|`, `^`, `~`, `<<`, `>>`
成员运算符（membership operators（成员运算符））检查成员关系in, not in
身份运算符（identity operators（身份运算符））比较对象身份is, is not

运算符的学习路径

对于初学者，建议按照以下顺序学习运算符：

  1. 基础运算符（必学）：

    • 算术运算符：用于基本计算
    • 赋值运算符：用于变量赋值
    • 比较运算符：用于条件判断

  2. 进阶运算符（重要）：

    • 逻辑运算符：用于组合条件
    • 成员运算符：用于检查元素是否存在
    • 身份运算符：理解 is 和 == 的区别

  3. 高级运算符（可选）：

    • 位运算符：用于底层操作和性能优化

运算符的核心概念

在学习运算符时，需要理解以下几个核心概念：

  1. 运算符优先级（operator precedence（运算符优先级））：不同运算符的执行顺序不同，就像数学中先算乘除后算加减
  2. 运算符的结合性（associativity（结合性））：相同优先级的运算符的执行顺序（从左到右或从右到左）
  3. 操作数的数量：
    • 一元运算符（unary operator（一元运算符））：只有一个操作数，如 not, -x
    • 二元运算符（binary operator（二元运算符））：有两个操作数，如 +, -, *, /
    • 三元运算符（ternary operator（三元运算符））：有三个操作数，如条件表达式 x if condition else y

为什么运算符如此重要？

运算符是编程的 基础语法，几乎每行代码都会用到运算符。掌握运算符意味着：

  • ✅ 能够正确编写表达式和条件判断
  • ✅ 能够理解代码的逻辑和执行顺序
  • ✅ 能够避免常见的语法错误和逻辑错误
  • ✅ 能够写出简洁、高效的代码

运算符就像建造代码大厦的砖块，没有它们，就无法构建任何程序。现在，让我们开始深入学习每一类运算符的具体用法！

目录

1. 前置知识点

在深入学习运算符之前，你需要了解以下基础概念：

  • 变量（variable（变量））：用于存储数据的容器，就像生活中的 盒子，可以在里面存放不同的物品
  • 数据类型（data type（数据类型））：Python 中的基本数据类型包括整数（int）、浮点数（float）、字符串（string）、布尔值（bool）等
  • 表达式（expression（表达式））：由运算符和操作数（operand（操作数））组成的计算式，例如 3 + 5 就是一个表达式
  • 布尔值（boolean（布尔值））：只有两个值 True 和 False，用于表示逻辑判断的结果

2. 快速上手（3 分钟）

🔥 Must（必做实践）｜依赖：Python 3.6+

目的：用一个最小示例快速了解运算符的基本用法——

  • 算术运算：加减乘除，就像使用计算器一样简单
  • 比较判断：判断两个值的大小关系，就像比较两件商品的价格
  • 逻辑组合：将多个条件组合起来，就像筛选商品时同时考虑价格和质量
# 算术运算：像使用计算器一样简单
a = 10
b = 3
print(a + b)   # 输出：13（加法）
print(a - b)   # 输出：7（减法）
print(a * b)   # 输出：30（乘法）
print(a / b)   # 输出：3.3333333333333335（除法）
print(a // b)  # 输出：3（整除，只取整数部分）
print(a % b)   # 输出：1（取余，就像 10 ÷ 3 = 3 余 1）
print(a ** b)  # 输出：1000（幂运算，10 的 3 次方）

# 比较判断：就像比较两件商品的价格
age = 18
print(age >= 18)  # 输出：True（是否成年）
print(age == 18)  # 输出：True（是否等于 18）
print(age != 20)  # 输出：True（是否不等于 20）

# 逻辑组合：就像筛选商品时同时考虑多个条件
score = 85
print(score >= 60 and score < 90)  # 输出：True（是否在 60-90 之间）
print(score < 60 or score >= 90)   # 输出：False（是否不及格或优秀）

输出结果：

13
7
30
3.3333333333333335
3
1
1000
True
True
True
True
False

运算符的价值：让代码更简洁易读

运算符是编程的基础工具，合理使用运算符可以让代码更简洁、可读性更强。下面的对比展示了运算符组合使用 vs 分别判断的区别：

# ✅ 使用运算符组合（简洁明了）
age = 25
score = 85

# 一行清晰表达复杂条件，使用逻辑运算符组合
is_qualified = (age >= 18) and (score >= 60) and (score < 90)
print(is_qualified)  # 输出：True

# 使用链式比较运算符，更直观
age_valid = 18 <= age <= 60
print(age_valid)  # 输出：True

# ❌ 不使用运算符组合（代码冗长且不易读）
age = 25
score = 85

# 需要分别判断每个条件，然后手动嵌套 if 语句
is_qualified = False
if age >= 18:
    if age <= 60:
        if score >= 60:
            if score < 90:
                is_qualified = True

print(is_qualified)  # 输出：True（但代码冗长，嵌套深）

# 判断年龄范围需要分开写
age_valid = False
if age >= 18:
    if age <= 60:
        age_valid = True
print(age_valid)  # 输出：True（不如链式比较直观）

对比结论：运算符让代码更简洁、可读性更强，是编程中不可或缺的基础工具。合理使用运算符（特别是运算符组合）可以减少代码行数、降低嵌套层级，提高代码的可维护性。

3. 算术运算符（arithmetic operators（算术运算符））

🔥 Must（必做实践）｜依赖：任意 Python 3 版本

算术运算符就像 数学计算器，用于执行基本的数学运算。想象一下，你正在计算购物账单：需要加法计算总价、减法计算找零、乘法计算批量购买的总数。

3.1 基本算术运算符

运算符名称功能示例结果
+加法（addition（加法））两数相加10 + 313
-减法（subtraction（减法））两数相减10 - 37
*乘法（multiplication（乘法））两数相乘10 * 330
/除法（division（除法））两数相除，返回浮点数10 / 33.333...
//整除（floor division（整除））两数相除，返回整数部分10 // 33
%取模（modulus（取模））返回除法的余数10 % 31
**幂运算（exponentiation（幂运算））返回第一个数的第二个数次方10 ** 31000

3.2 详细示例与说明

# 基本算术运算
a = 10
b = 3

print(f"加法：{a} + {b} = {a + b}")           # 输出：加法：10 + 3 = 13
print(f"减法：{a} - {b} = {a - b}")           # 输出：减法：10 - 3 = 7
print(f"乘法：{a} * {b} = {a * b}")           # 输出：乘法：10 * 3 = 30
print(f"除法：{a} / {b} = {a / b}")           # 输出：除法：10 / 3 = 3.3333333333333335
print(f"整除：{a} // {b} = {a // b}")         # 输出：整除：10 // 3 = 3
print(f"取模：{a} % {b} = {a % b}")           # 输出：取模：10 % 3 = 1
print(f"幂运算：{a} ** {b} = {a ** b}")       # 输出：幂运算：10 ** 3 = 1000

生活化比喻：

  • 整除（//）：就像分糖果，10 颗糖果分给 3 个人，每人分到 3 颗（忽略余数）
  • 取模（%）：就像分糖果后的余数，10 颗糖果分给 3 个人后，还剩 1 颗
  • 幂运算（**）：就像计算复利，10 元本金，每年增长 3 倍，最终得到 1000 元

3.3 字符串与算术运算符

字符串拼接：+ 运算符可以用于连接字符串（concatenation（连接）），就像把两个句子连在一起。

# 字符串拼接
first_name = "张"
last_name = "三"
full_name = first_name + last_name
print(full_name)  # 输出：张三

# 字符串重复
greeting = "Hello! " * 3
print(greeting)   # 输出：Hello! Hello! Hello!

对比示例：字符串拼接的不同方法

# ✅ 使用 + 运算符（简洁直观，适合少量字符串）
first_name = "张"
last_name = "三"
full_name = first_name + last_name
print(full_name)  # 输出：张三（一行搞定，清晰易读）

# 三个字符串拼接也很简单
greeting = "你好，" + first_name + last_name
print(greeting)  # 输出：你好，张三

# ❌ 不使用 + 运算符的方法 1：使用 join（适合大量字符串，但两个字符串时显得繁琐）
first_name = "张"
last_name = "三"
full_name = "".join([first_name, last_name])  # 需要先放入列表
print(full_name)  # 输出：张三（功能相同，但代码更复杂）

# 三个字符串时 join 稍微清晰一些
greeting = "".join(["你好，", first_name, last_name])
print(greeting)  # 输出：你好，张三

# ❌ 不使用 + 运算符的方法 2：使用 f-string（格式化，但目的不同）
first_name = "张"
last_name = "三"
full_name = f"{first_name}{last_name}"  # f-string 主要用于格式化，不是专门的拼接运算符
print(full_name)  # 输出：张三（能实现，但 `+` 更直接表达"拼接"的意图）

对比结论：对于简单的字符串拼接（2-3 个字符串），使用 + 运算符是最直观、最简洁的方式。join 方法适合大量字符串拼接，f-string 适合需要格式化的场景，但都不如 + 运算符表达"拼接"的意图那么直接。

4. 赋值运算符（assignment operators（赋值运算符））

⚙️ Should（建议实践）｜依赖：任意 Python 3 版本

赋值运算符就像 自动更新计数器，可以让你在修改变量值的同时进行计算，代码更简洁。

4.1 基本赋值运算符

运算符名称功能等同于
=基本赋值（assignment（赋值））将右侧值赋给左侧变量x = 5
+=加法赋值（addition assignment（加法赋值））先相加再赋值x += 3 等同于 x = x + 3
-=减法赋值（subtraction assignment（减法赋值））先相减再赋值x -= 3 等同于 x = x - 3
*=乘法赋值（multiplication assignment（乘法赋值））先相乘再赋值x *= 3 等同于 x = x * 3
/=除法赋值（division assignment（除法赋值））先相除再赋值x /= 3 等同于 x = x / 3
//=整除赋值（floor division assignment（整除赋值））先整除再赋值x //= 3 等同于 x = x // 3
%=取模赋值（modulus assignment（取模赋值））先取模再赋值x %= 3 等同于 x = x % 3
**=幂赋值（exponentiation assignment（幂赋值））先幂运算再赋值x **= 3 等同于 x = x ** 3

赋值运算符的通用规律：

所有的复合赋值运算符（compound assignment operators（复合赋值运算符））都遵循相同的规律：

x op= y  等同于  x = x op y

其中 op 可以是 +、-、*、/、//、%、** 等算术运算符。

记忆技巧：

  • 复合赋值运算符 = 运算符 + 等号：把算术运算符和 = 组合在一起
  • 操作顺序：先运算，后赋值（先执行 x op y，再把结果赋给 x）
  • 简化写法：x += 3 比 x = x + 3 更简洁，变量名只需写一次

生活化比喻：就像银行账户的余额更新，x += 100 表示"账户余额增加 100"，等价于"新余额 = 旧余额 + 100"。

4.2 详细示例

# 基本赋值
x = 10
print(f"初始值：x = {x}")  # 输出：初始值：x = 10

# 加法赋值：就像银行账户余额增加
x += 5
print(f"x += 5 后：x = {x}")  # 输出：x += 5 后：x = 15

# 减法赋值：就像银行账户余额减少
x -= 3
print(f"x -= 3 后：x = {x}")  # 输出：x -= 3 后：x = 12

# 乘法赋值：就像商品价格翻倍
x *= 2
print(f"x *= 2 后：x = {x}")  # 输出：x *= 2 后：x = 24

# 除法赋值：就像商品价格减半
x /= 4
print(f"x /= 4 后：x = {x}")  # 输出：x /= 4 后：x = 6.0

对比示例：

# ❌ 不使用赋值运算符（冗长）
count = 10
count = count + 5   # 需要写两遍变量名
count = count - 3
count = count * 2
count = count / 4
print(count)  # 输出：6.0

# ✅ 使用赋值运算符（简洁）
count = 10
count += 5    # 只需写一次变量名
count -= 3
count *= 2
count /= 4
print(count)  # 输出：6.0（代码更简洁）

5. 比较运算符（comparison operators（比较运算符））

🔥 Must（必做实践）｜依赖：任意 Python 3 版本

比较运算符就像 天平，用于比较两个值的大小关系，返回 True 或 False。就像在超市购物时比较商品价格，判断哪个更便宜。

5.1 基本比较运算符

运算符名称功能示例结果
==等于（equal（等于））判断两值是否相等5 == 5True
!=不等于（not equal（不等于））判断两值是否不等5 != 3True
>大于（greater than（大于））判断左值是否大于右值5 > 3True
<小于（less than（小于））判断左值是否小于右值5 < 3False
>=大于等于（greater than or equal（大于等于））判断左值是否大于等于右值5 >= 5True
<=小于等于（less than or equal（小于等于））判断左值是否小于等于右值5 <= 3False

5.2 详细示例

# 数值比较
a = 10
b = 20
c = 10

print(f"{a} == {b}: {a == b}")   # 输出：10 == 20: False
print(f"{a} != {b}: {a != b}")   # 输出：10 != 20: True
print(f"{a} > {b}: {a > b}")     # 输出：10 > 20: False
print(f"{a} < {b}: {a < b}")     # 输出：10 < 20: True
print(f"{a} >= {c}: {a >= c}")   # 输出：10 >= 10: True
print(f"{a} <= {b}: {a <= b}")   # 输出：10 <= 20: True

# 字符串比较（按字典序）
name1 = "Alice"
name2 = "Bob"
print(f"'{name1}' < '{name2}': {name1 < name2}")  # 输出：'Alice' < 'Bob': True

生活化比喻：

  • 比较运算符：就像购物时比较价格，10 < 20 表示 10 元商品比 20 元商品便宜
  • 字符串比较：就像按字母表顺序排列名字，"Alice" 在 "Bob" 之前

5.3 链式比较

Python 支持链式比较，就像数学中的不等式，让代码更自然：

# 链式比较：判断年龄是否在合理范围内
age = 25
print(18 <= age <= 60)  # 输出：True（年龄在 18-60 之间）

# 等同于
print(18 <= age and age <= 60)  # 输出：True

对比示例：

# ❌ 不使用链式比较（需要写两遍变量）
age = 25
if 18 <= age and age <= 60:
    print("年龄合理")

# ✅ 使用链式比较（更直观）
age = 25
if 18 <= age <= 60:
    print("年龄合理")  # 代码更简洁易读

6. 逻辑运算符（logical operators（逻辑运算符））

🔥 Must（必做实践）｜依赖：任意 Python 3 版本

逻辑运算符就像 筛选器，用于组合多个条件，就像筛选商品时同时考虑价格和质量。

6.1 基本逻辑运算符

运算符名称功能说明
and逻辑与（logical AND（逻辑与））两个条件都为 True 时返回 True就像"既要...又要..."
or逻辑或（logical OR（逻辑或））至少一个条件为 True 时返回 True就像"要么...要么..."
not逻辑非（logical NOT（逻辑非））将 True 变为 False，False 变为 True就像"不是..."

6.2 逻辑运算符真值表

aba and ba or bnot a
TrueTrueTrueTrueFalse
TrueFalseFalseTrueFalse
FalseTrueFalseTrueTrue
FalseFalseFalseFalseTrue

6.3 详细示例

# 逻辑与（and）：两个条件都要满足
age = 25
has_license = True
can_drive = age >= 18 and has_license
print(f"可以开车：{can_drive}")  # 输出：可以开车：True

# 逻辑或（or）：至少满足一个条件
score = 85
is_excellent = score >= 90 or score == 100
print(f"是否优秀：{is_excellent}")  # 输出：是否优秀：False

# 逻辑非（not）：取反
is_raining = False
can_go_out = not is_raining
print(f"可以出门：{can_go_out}")  # 输出：可以出门：True

# 组合使用
age = 25
score = 85
is_qualified = (age >= 18 and age <= 60) and (score >= 60)
print(f"是否合格：{is_qualified}")  # 输出：是否合格：True

生活化比喻：

  • and：就像招聘要求"既要有学历，又要有经验"，两个条件缺一不可
  • or：就像优惠活动"要么是会员，要么消费满 100 元"，满足一个即可
  • not：就像"不是周末"等同于"工作日"

6.4 短路求值（short-circuit evaluation（短路求值））

Python 的逻辑运算符支持短路求值，就像电路中的短路保护：

# and 短路：如果第一个条件为 False，不再计算第二个条件
def check_value(x):
    print(f"检查值：{x}")
    return x > 0

result = False and check_value(5)  # check_value 不会被调用
print(result)  # 输出：False（没有打印"检查值：5"）

# or 短路：如果第一个条件为 True，不再计算第二个条件
result = True or check_value(5)  # check_value 不会被调用
print(result)  # 输出：True（没有打印"检查值：5"）

对比示例：

# ❌ 不使用逻辑运算符（需要嵌套 if）
age = 25
has_license = True
if age >= 18:
    if has_license:
        can_drive = True
    else:
        can_drive = False
else:
    can_drive = False

# ✅ 使用逻辑运算符（简洁清晰）
age = 25
has_license = True
can_drive = age >= 18 and has_license  # 一行搞定

7. 位运算符（bitwise operators（位运算符））

💡 Could（可选实践）｜依赖：任意 Python 3 版本

位运算符就像 二进制开关，直接操作整数的二进制位（bit（位）），适用于底层编程和性能优化场景。

7.1 基本位运算符

运算符名称功能说明
&按位与（bitwise AND（按位与））两个位都为 1 时结果为 1就像两个开关都打开时灯才亮
|按位或（bitwise OR（按位或））至少一个位为 1 时结果为 1就像两个开关任意一个打开时灯就亮
^按位异或（bitwise XOR（按位异或））两个位不同时结果为 1就像两个开关状态不同时灯才亮
~按位取反（bitwise NOT（按位取反））将每个位取反（0 变 1，1 变 0）就像反转所有开关状态
<<左移（left shift（左移））将二进制位向左移动，右侧补 0相当于乘以 2 的 n 次方
>>右移（right shift（右移））将二进制位向右移动，左侧补符号位相当于除以 2 的 n 次方

7.2 详细示例

# 二进制表示：60 = 0011 1100，13 = 0000 1101
a = 60
b = 13

print(f"a = {a}（二进制：{bin(a)}）")  # 输出：a = 60（二进制：0b111100）
print(f"b = {b}（二进制：{bin(b)}）")  # 输出：b = 13（二进制：0b1101）

# 按位与：只有两个位都为 1 时结果为 1
result = a & b
print(f"{a} & {b} = {result}（二进制：{bin(result)}）")  # 输出：60 & 13 = 12（二进制：0b1100）

# 按位或：至少一个位为 1 时结果为 1
result = a | b
print(f"{a} | {b} = {result}（二进制：{bin(result)}）")  # 输出：60 | 13 = 61（二进制：0b111101）

# 按位异或：两个位不同时结果为 1
result = a ^ b
print(f"{a} ^ {b} = {result}（二进制：{bin(result)}）")  # 输出：60 ^ 13 = 49（二进制：0b110001）

# 按位取反
result = ~a
print(f"~{a} = {result}")  # 输出：~60 = -61

# 左移：相当于乘以 2 的 n 次方
result = a << 2
print(f"{a} << 2 = {result}（相当于 {a} * 4 = {a * 4}）")  # 输出：60 << 2 = 240（相当于 60 * 4 = 240）

# 右移：相当于除以 2 的 n 次方（向下取整）
result = a >> 2
print(f"{a} >> 2 = {result}（相当于 {a} // 4 = {a // 4}）")  # 输出：60 >> 2 = 15（相当于 60 // 4 = 15）

生活化比喻：

  • 按位与（&）：就像两个开关串联，只有两个都打开时灯才亮
  • 按位或（|）：就像两个开关并联，任意一个打开时灯就亮
  • 左移（<<）：就像数字后面加 0，60 左移 2 位相当于 60 × 4 = 240
  • 右移（>>）：就像去掉后面的位，60 右移 2 位相当于 60 ÷ 4 = 15

对比示例：

# ❌ 不使用位运算符计算 2 的 n 次方（需要调用函数）
import math
result = math.pow(2, 8)
print(result)  # 输出：256.0

# ✅ 使用位运算符（更高效）
result = 1 << 8  # 1 左移 8 位 = 2^8 = 256
print(result)  # 输出：256（性能更好）

8. 成员运算符（membership operators（成员运算符））

⚙️ Should（建议实践）｜依赖：任意 Python 3 版本

成员运算符就像 查找工具，用于检查某个值是否存在于序列（sequence（序列））中，就像在名单中查找某个人。

8.1 基本成员运算符

运算符名称功能说明
in成员运算符（membership operator（成员运算符））如果值在序列中找到，返回 True就像"在...中"
not in非成员运算符（not membership operator（非成员运算符））如果值在序列中未找到，返回 True就像"不在...中"

8.2 详细示例

# 列表（list（列表））中的成员检查
fruits = ["苹果", "香蕉", "橙子"]
print("苹果" in fruits)      # 输出：True
print("葡萄" in fruits)      # 输出：False
print("葡萄" not in fruits)  # 输出：True

# 字符串（string（字符串））中的字符检查
text = "Python"
print("P" in text)           # 输出：True
print("p" in text)           # 输出：False（区分大小写）
print("thon" in text)        # 输出：True（可以检查子串）

# 字典（dictionary（字典））中的键（key（键））检查
student = {"name": "张三", "age": 20, "grade": "A"}
print("name" in student)     # 输出：True（检查键，不是值）
print("张三" in student)     # 输出：False（值不在键中）
print("score" not in student)  # 输出：True

# 集合（set（集合））中的成员检查
numbers = {1, 2, 3, 4, 5}
print(3 in numbers)          # 输出：True
print(6 not in numbers)      # 输出：True

生活化比喻：

  • in 运算符：就像在班级名单中查找某个学生，找到了返回 True
  • not in 运算符：就像确认某个学生不在名单中

对比示例：

# ❌ 不使用成员运算符（需要编写循环）
fruits = ["苹果", "香蕉", "橙子"]
target = "苹果"
found = False
for fruit in fruits:
    if fruit == target:
        found = True
        break
print(found)  # 输出：True

# ✅ 使用成员运算符（简洁高效）
fruits = ["苹果", "香蕉", "橙子"]
print("苹果" in fruits)  # 输出：True（一行搞定）

9. 身份运算符（identity operators（身份运算符））

⚙️ Should（建议实践）｜依赖：任意 Python 3 版本

身份运算符就像 身份证验证，用于比较两个变量是否指向 同一个对象（object（对象）），而不仅仅是值是否相等。这是理解 Python 对象模型的关键！

9.1 基本身份运算符

运算符名称功能说明
is身份运算符（identity operator（身份运算符））如果两个变量指向同一个对象，返回 True比较对象的 身份（identity（身份））
is not非身份运算符（not identity operator（非身份运算符））如果两个变量指向不同对象，返回 True比较对象的 身份

9.2 is 与 == 的本质区别

这是 Python 中 最容易混淆 的概念之一！让我们用比喻来理解：

  • ==（等于）：比较 内容是否相同，就像比较两本书的内容是否一样
  • is（身份）：比较 是否为同一本书，就像确认两本书是否为同一本实体书

9.3 详细示例

# 情况 1：小整数和字符串（Python 会缓存）
a = 100
b = 100
print(a == b)   # 输出：True（值相等）
print(a is b)   # 输出：True（指向同一个对象，Python 缓存了小整数）

# 情况 2：大整数（Python 不缓存）
a = 1000
b = 1000
print(a == b)   # 输出：True（值相等）
print(a is b)   # 输出：False（不同对象，Python 3.8+ 可能为 False）

# 情况 3：列表（list（列表））（总是创建新对象）
list1 = [1, 2, 3]
list2 = [1, 2, 3]
print(list1 == list2)   # 输出：True（内容相同）
print(list1 is list2)   # 输出：False（不同对象）

# 情况 4：变量赋值（指向同一个对象）
list1 = [1, 2, 3]
list2 = list1  # list2 指向 list1 的对象
print(list1 == list2)   # 输出：True（内容相同）
print(list1 is list2)   # 输出：True（同一个对象）

# 情况 5：None（None 是单例，只有一个对象）
x = None
y = None
print(x is None)    # 输出：True（推荐写法）
print(x == None)    # 输出：True（不推荐，应该用 is）

生活化比喻：

  • == 与列表：就像两本内容完全相同的书，但它们是 不同的实体书
  • is 与列表：就像确认这两本书是否为 同一本实体书
  • None 检查：就像确认某个位置是否"空无一人"，应该用 is None（确认是否为同一个"空"对象）

9.4 最佳实践

# ✅ 推荐：使用 is 检查 None
value = None
if value is None:
    print("值为空")

# ❌ 不推荐：使用 == 检查 None（虽然可以，但不 Pythonic）
if value == None:
    print("值为空")

# ✅ 推荐：使用 == 比较值
list1 = [1, 2, 3]
list2 = [1, 2, 3]
if list1 == list2:  # 比较内容
    print("内容相同")

# ❌ 错误：误用 is 比较值
if list1 is list2:  # 这通常是 False！
    print("内容相同")  # 不会执行

对比示例：

# ❌ 误用 is 比较值（常见错误）
def check_equality(a, b):
    if a is b:  # 错误！应该用 ==
        return "相等"
    else:
        return "不等"

result = check_equality([1, 2], [1, 2])
print(result)  # 输出：不等（错误结果！）

# ✅ 正确使用 == 比较值
def check_equality(a, b):
    if a == b:  # 正确！
        return "相等"
    else:
        return "不等"

result = check_equality([1, 2], [1, 2])
print(result)  # 输出：相等（正确结果）

10. 运算符优先级（operator precedence（运算符优先级））

🔥 Must（必做实践）｜依赖：任意 Python 3 版本

运算符优先级就像 数学运算顺序，决定了表达式中运算符的执行顺序。就像数学中先算乘除后算加减，Python 也有自己的优先级规则。

10.1 优先级规则概览

从高到低的优先级顺序（部分常见运算符）：

  1. 括号 ()：最高优先级，强制改变计算顺序
  2. 幂运算 `**`：次方运算
  3. 正负号 +x, -x：一元运算符
  4. 乘除取模 *, /, //, %：乘法和除法类
  5. 加减 +, -：加法和减法
  6. 比较运算符 ==, !=, <, >, <=, >=：比较判断
  7. 身份运算符 is, is not：身份检查
  8. 成员运算符 in, not in：成员检查
  9. 逻辑非 not：逻辑取反
  10. 逻辑与 and：逻辑与
  11. 逻辑或 or：逻辑或
  12. 赋值运算符 =, +=, -= 等：最低优先级

10.2 详细示例

# 示例 1：算术运算符优先级
result = 2 + 3 * 4  # 先算乘法，再算加法
print(result)  # 输出：14（不是 20！）

# 使用括号改变优先级
result = (2 + 3) * 4
print(result)  # 输出：20

# 示例 2：混合运算符
result = 10 > 5 + 3  # 先算 5+3=8，再比较 10>8
print(result)  # 输出：True

# 示例 3：逻辑运算符优先级
result = True or False and False  # and 优先级高于 or
print(result)  # 输出：True（相当于 True or (False and False)）

# 示例 4：容易出错的优先级
age = 20
score = 85
# ❌ 错误：优先级问题
result = age >= 18 and score >= 60 and score < 90
# ✅ 正确：使用括号明确优先级（虽然这里不需要，但更清晰）
result = (age >= 18) and (score >= 60) and (score < 90)
print(result)  # 输出：True

10.3 优先级陷阱与解决方案

# 陷阱 1：混合算术和比较
# ❌ 容易混淆
result = 5 + 3 > 7  # 正确：先算 5+3=8，再比较 8>7，结果为 True
print(result)  # 输出：True

# ✅ 推荐：使用括号提高可读性
result = (5 + 3) > 7
print(result)  # 输出：True（更清晰）

# 陷阱 2：逻辑运算符优先级
# ❌ 容易出错
result = not True or False  # not 优先级最高，相当于 (not True) or False
print(result)  # 输出：False

# ✅ 推荐：使用括号明确意图
result = not (True or False)  # 如果想让 or 先算，需要括号
print(result)  # 输出：False

生活化比喻：

  • 运算符优先级：就像做数学题，先算括号里的，再算乘除，最后算加减
  • 使用括号：就像明确标注计算顺序，避免歧义

对比示例：

# ❌ 不明确优先级（容易出错）
result = 2 + 3 * 4 ** 2  # 结果是多少？
print(result)  # 输出：50（4**2=16, 3*16=48, 2+48=50）

# ✅ 使用括号明确优先级（清晰易懂）
result = 2 + (3 * (4 ** 2))  # 一目了然
print(result)  # 输出：50（代码更易读）

10.4 优先级速查表

# 从高到低示例
result1 = (1 + 2) * 3      # 括号最高：9
result2 = 2 ** 3 ** 2      # 幂运算从右到左：512（相当于 2**(3**2)）
result3 = -5 + 3           # 正负号：-2
result4 = 10 / 2 * 3       # 乘除同级，从左到右：15.0
result5 = 5 + 3 - 2        # 加减同级，从左到右：6
result6 = 5 < 3 + 2        # 比较运算符：False（先算 3+2=5，再比较 5<5，结果为 False）
result7 = 10 > 3 + 2       # 比较运算符：True（先算 3+2=5，再比较 10>5，结果为 True）

11. 常见错误与对比修正

🔥 Must（必做实践）｜依赖：任意 Python 3 版本

11.1 错误 1：混淆 is 和 ==

# ❌ 错误：使用 is 比较值
list1 = [1, 2, 3]
list2 = [1, 2, 3]
if list1 is list2:  # 这通常是 False！
    print("相等")  # 不会执行

# ✅ 正确：使用 == 比较值
if list1 == list2:  # 正确！
    print("相等")  # 会执行

11.2 错误 2：使用 == 检查 None

# ❌ 不推荐：使用 == 检查 None
value = None
if value == None:  # 虽然可以，但不 Pythonic
    print("为空")

# ✅ 推荐：使用 is 检查 None
if value is None:  # Pythonic 写法
    print("为空")

11.3 错误 3：运算符优先级混淆

# ❌ 错误：优先级理解错误
result = 2 + 3 * 4  # 你可能以为是 20，但实际是 14
print(result)  # 输出：14（不是 20！）

# ✅ 正确：使用括号明确优先级
result = (2 + 3) * 4  # 明确表达意图
print(result)  # 输出：20

11.4 错误 4：字符串与数字比较

# ❌ 错误：字符串和数字不能直接比较大小
age = "18"  # 字符串
if age > 20:  # TypeError: '>' not supported between instances of 'str' and 'int'
    print("成年")

# ✅ 正确：先转换为同一类型
age = int("18")  # 转换为整数
if age > 20:
    print("成年")  # 不会执行，因为 18 < 20

11.5 错误 5：逻辑运算符误用

# ❌ 错误：误用逻辑运算符
age = 25
if age >= 18 and <= 60:  # SyntaxError: invalid syntax
    print("年龄合理")

# ✅ 正确：每个条件都要完整
if age >= 18 and age <= 60:  # 或者使用链式比较
    print("年龄合理")

# ✅ 更简洁：使用链式比较
if 18 <= age <= 60:
    print("年龄合理")

12. 📚 参考资料与学习资源

13. 总结

通过本文的学习，你已经掌握了 Python 七大运算符类别的核心用法：

✅ 算术运算符：像计算器一样进行数学运算，包括加减乘除、整除、取模和幂运算

✅ 赋值运算符：让代码更简洁，可以同时进行计算和赋值

✅ 比较运算符：像天平一样比较两个值的大小关系，返回布尔值

✅ 逻辑运算符：像筛选器一样组合多个条件，实现复杂的逻辑判断

✅ 位运算符：直接操作二进制位，适用于底层编程和性能优化

✅ 成员运算符：像查找工具一样检查值是否存在于序列中

✅ 身份运算符：理解 is 与 == 的本质区别，掌握对象身份比较

✅ 运算符优先级：理解运算顺序规则，避免优先级陷阱

核心要点：

  • is 比较对象身份，== 比较值是否相等——这是最容易混淆的概念，务必牢记！
  • 使用括号明确优先级——当表达式复杂时，括号能让代码更清晰、更安全
  • 成员运算符和身份运算符的使用场景——in 用于检查成员，is 用于检查对象身份

运算符是 Python 编程的基础，就像 工具箱中的基本工具，熟练掌握它们能让你写出更简洁、更高效的代码。继续实践，你会在实际项目中不断发现运算符的强大之处！加油，未来的 Python 开发者！🚀

厦门工学院人工智能创作坊 -- 郑恩赐
2025 年 11 月 02 日

avatar
文章
阅读
粉丝