Day 03：运算符与流程控制

🎯 学习目标：掌握 Python 全部运算符（7 大类），熟练编写分支和循环逻辑

1. 算术运算符

 
a, b = 10, 3
 
print(a + b)     # 13  加法
 
print(a - b)     # 7   减法
 
print(a * b)     # 30  乘法
 
print(a / b)     # 3.3333333333333335  除法（结果始终是 float）
 
print(a // b)    # 3   整除（向下取整）
 
print(a % b)     # 1   取余（模运算）
 
print(a ** b)    # 1000  幂运算（10³）
 
# 整除的行为
 
print(10 // 3)    # 3
 
print(-10 // 3)   # -4  ← 注意！向下取整所以是 -4 不是 -3
 
print(10 // -3)   # -4
 
# 取余的妙用
 
print(17 % 5)    # 2  判断是否整除：17 ÷ 5 余 2
 
print(17 % 2)    # 1  判断奇偶：余 1 → 奇数
 
print(18 % 2)    # 0  余 0 → 偶数
 
# 幂运算
 
print(2 ** 10)   # 1024
 
print(16 ** 0.5)  # 4.0  （开平方）

取余的常见应用

判断奇偶：n % 2

循环索引：index % length

提取个位：n % 10

2. 赋值运算符

 
# 基本赋值
 
x = 10
 
# 复合赋值
 
x += 5    # x = x + 5
 
x -= 3    # x = x - 3
 
x *= 2    # x = x * 2
 
x /= 4    # x = x / 4
 
x //= 2   # x = x // 2
 
x %= 3    # x = x % 3
 
x **= 2   # x = x ** 2
 
# 多重赋值（Python 特色）
 
a, b, c = 1, 2, 3     # 同时给多个变量赋值
 
# 交换变量（一行搞定，不需要临时变量！）
 
a, b = b, a
 
print(a, b)  # 2, 1
 
# 链式赋值
 
x = y = z = 100       # 三个变量都赋值为 100

3. 比较（关系）运算符

 
print(10 == 10)    # True   等于
 
print(10 != 5)     # True   不等于
 
print(10 > 5)      # True   大于
 
print(10 < 5)      # False  小于
 
print(10 >= 10)    # True   大于等于
 
print(10 <= 5)     # False  小于等于
 
# 链式比较（Python 特色！）
 
age = 25
 
print(18 <= age <= 60)   # True ← 等价于 18 <= age and age <= 60
 
# 字符串也可以比较（按字典序）
 
print("abc" < "abd")   # True
 
print("A" < "a")       # True（大写 ASCII 值 < 小写）

4. 逻辑运算符

 
# and：两边都为 True 才返回 True
 
print(True and True)    # True
 
print(True and False)   # False
 
print(False and True)   # False
 
print(False and False)  # False
 
# or：至少一边为 True 就返回 True
 
print(True or False)    # True
 
print(False or False)   # False
 
# not：取反
 
print(not True)         # False
 
print(not False)        # True

短路运算（重要！⭐）

 
# and 短路：左边为 False 时，右边不执行
 
def check():
 
    print("check 被调用了")
 
    return True
 
print(False and check())  # 只输出 False，check() 没有被调用！
 
# or 短路：左边为 True 时，右边不执行
 
print(True or check())    # 只输出 True，check() 没有被调用！
 
# 利用短路做默认值
 
name = ""
 
display_name = name or "匿名用户"   # "匿名用户"
 
# 原理：空字符串是 False，所以 or 返回右边

5. 位运算符

位运算直接操作二进制位，效率极高：

 
a, b = 0b1100, 0b1010  # a=12, b=10
 
# & 按位与：两位都为 1 才为 1
 
print(bin(a & b))  # 0b1000 = 8
 
# | 按位或：至少一位为 1 就为 1
 
print(bin(a | b))  # 0b1110 = 14
 
# ^ 按位异或：两位不同为 1
 
print(bin(a ^ b))  # 0b0110 = 6
 
# ~ 按位取反
 
print(~a)  # -13（补码机制）
 
# << 左移：二进制位向左移，右边补 0（每移一位 = ×2）
 
print(5 << 1)  # 10  = 5×2
 
print(5 << 2)  # 20  = 5×4
 
print(5 << 3)  # 40  = 5×8
 
# >> 右移：二进制位向右移，左边补符号位（每移一位 = ÷2）
 
print(16 >> 1)  # 8   = 16÷2
 
print(16 >> 2)  # 4   = 16÷4
 
print(16 >> 3)  # 2   = 16÷8

6. 成员运算符

 
# in：判断元素是否在容器中
 
print("a" in "Python")           # False
 
print("th" in "Python")          # True
 
print(3 in [1, 2, 3, 4])        # True
 
print("name" in {"name": "张三"})  # True（判断 key）
 
# not in：不在
 
print(5 not in [1, 2, 3])       # True

7. 身份运算符

 
# ==：判断值是否相等
 
a = [1, 2, 3]
 
b = [1, 2, 3]
 
c = a
 
print(a == b)  # True  （值相等）
 
print(a is b)  # False （不同对象，不同内存地址）
 
print(a is c)  # True  （同一对象）
 
# Python 的整数缓存（-5 到 256）
 
x = 256
 
y = 256
 
print(x is y)  # True  （Python 缓存了小整数）
 
x = 257
 
y = 257
 
print(x is y)  # 可能是 False（超出缓存范围，创建了不同对象）

== vs is

== 比较值 | is 比较是否是同一个对象

日常开发里 99% 的情况用 ==，is 主要用于判断 is None

8. Python 编码规范

正式开发前，先了解 Python 社区统一的代码风格——PEP 8：

 
# 缩进：用 4 个空格（不要混用 Tab！）
 
if True:
 
    print("缩进 4 个空格")      # ✅
 
    # print("Tab 缩进")          # ❌
 
# 空格：运算符两边各一个空格
 
x = 1 + 2                       # ✅
 
x=1+2                           # ❌
 
# 逗号后面加空格
 
items = [1, 2, 3]               # ✅
 
items = [1,2,3]                 # ❌
 
# 函数参数逗号后加空格
 
def func(a, b, c):              # ✅
 
    pass
 
# 过长的行可以用括号换行
 
result = (long_function_name(arg1, arg2, arg3)
 
          + another_function(arg4))
 
# 导入：每个导入独占一行
 
import os                       # ✅
 
import sys                      # ✅
 
import os, sys                  # ❌

善用工具

以后学了 ruff/black 等格式化工具，可以一键自动格式化代码，不需要手动调整。

9. 单分支 if

 
# 基本语法
 
age = 18
 
if age >= 18:
 
    print("已成年")
 
    print("可以进入网吧")
 
# if 后面的条件可以是任意表达式
 
score = 85
 
if score >= 60:
 
    print(f"成绩 {score} 及格")
 
# 利用"非零即真"的特性
 
count = 5
 
if count:          # count != 0
 
    print(f"还有 {count} 个")

10. 双分支 if-else

 
age = 16
 
if age >= 18:
 
    print("已成年")
 
else:
 
    print("未成年")
 
# 实际应用：登录验证
 
password = input("请输入密码：")
 
if password == "123456":
 
    print("✅ 登录成功")
 
else:
 
    print("❌ 密码错误")

11. 多分支 if-elif-else

 
score = 85
 
if score >= 90:
 
    grade = "优秀"
 
elif score >= 80:
 
    grade = "良好"
 
elif score >= 70:
 
    grade = "中等"
 
elif score >= 60:
 
    grade = "及格"
 
else:
 
    grade = "不及格"
 
print(f"成绩等级：{grade}")
 
# 因此条件的顺序很重要！

12. 嵌套分支

 
# 电影票判断
 
age = 25
 
has_ticket = True
 
is_vip = False
 
if has_ticket:
 
    if age >= 18:
 
        if is_vip:
 
            print("VIP 成人场，请进")
 
        else:
 
            print("普通成人场，请进")
 
    else:
 
        print("未成年人场，请进")
 
else:
 
    print("请先购票")
 
# 可以用提前 return 或逻辑运算简化

13. match-case 语句（Python 3.10+，⭐新特性）

传统 if-elif 判断多个值比较啰嗦，match-case 更优雅：

 
# 传统写法
 
status_code = 404
 
if status_code == 200:
 
    msg = "成功"
 
elif status_code == 301 or status_code == 302:
 
    msg = "重定向"
 
elif status_code == 404:
 
    msg = "未找到"
 
elif status_code == 500:
 
    msg = "服务器错误"
 
else:
 
    msg = "未知"
 
# match-case 写法（Python 3.10+）
 
status_code = 404
 
match status_code:
 
    case 200:
 
        msg = "成功"
 
    case 301 | 302:               # | 表示"或"
 
        msg = "重定向"
 
    case 404:
 
        msg = "未找到"
 
    case 500:
 
        msg = "服务器错误"
 
    case _:                       # _ 表示默认（类似 else）
 
        msg = "未知"
 
print(msg)  # "未找到"
 
# match 可以做更复杂的模式匹配
 
point = (0, 5)
 
match point:
 
    case (0, 0):
 
        print("原点")
 
    case (0, y):
 
        print(f"在 Y 轴上，y={y}")    # 匹配这个！
 
    case (x, 0):
 
        print(f"在 X 轴上")
 
    case (x, y):
 
        print(f"坐标 ({x}, {y})")
 
# 输出："在 Y 轴上，y=5"

什么时候用 match-case

多分支判断且条件都是等值比较

需要解构数据（如坐标、元组）

Python 3.10 以下版本不支持，注意兼容性

14. 三目运算符

 
# 语法：结果1 if 条件 else 结果2
 
age = 20
 
status = "成年" if age >= 18 else "未成年"
 
print(status)  # "成年"
 
# 等价于：
 
if age >= 18:
 
    status = "成年"
 
else:
 
    status = "未成年"
 
# 可以嵌套（但不推荐，可读性太差）
 
score = 85
 
result = "优秀" if score >= 90 else ("良好" if score >= 80 else "一般")

15. while 循环

15.1 基本语法

 
# 打印 0 到 4
 
count = 0
 
while count < 5:
 
    print(f"第 {count} 次循环")
 
    count += 1
 
# 输出：0, 1, 2, 3, 4

15.2 三种关键条件

 
# ⚠️ 无限循环必须有退出条件！
 
while True:
 
    user_input = input("输入 'quit' 退出：")
 
    if user_input == "quit":
 
        break          # 跳出循环

15.3 while-else

 
# else 在循环正常结束（非 break）时执行
 
count = 0
 
while count < 3:
 
    print(count)
 
    count += 1
 
else:
 
    print("循环正常结束")    # ✅ 会执行
 
# 如果被 break 中断，else 不执行
 
count = 0
 
while count < 10:
 
    if count == 3:
 
        print("提前退出！")
 
        break
 
    count += 1
 
else:
 
    print("循环正常结束")    # ❌ 不会执行（被 break 了）

15.4 实际应用

 
# 数字猜谜游戏
 
import random
 
answer = random.randint(1, 100)
 
guess = None
 
attempts = 0
 
while guess != answer:
 
    guess = int(input("猜一个 1-100 的数："))
 
    attempts += 1
 
    if guess > answer:
 
        print("大了")
 
    elif guess < answer:
 
        print("小了")
 
print(f"🎉 恭喜！答案就是 {answer}，你用了 {attempts} 次")

速记卡（面试闪卡）

Q1：一句话讲清「Day 03：运算符与流程控制」到底是什么？

A：Python 运算符有七大类，流程控制靠缩进划分代码块；面试常考短路求值、整除向下取整、以及 is（同对象）和 ==（同值）的区别。

Q2：七大类运算符速览 —— 怎么理解？

A：运算符像厨房调料：算术(+ - * / // %)管计算，赋值(+=)管存值，比较(==)管判断，逻辑(and/or)管组合，位(& | ^)管二进制，成员(in)管”在不在”，身份(is)管”是不是同一个”。记住 // 是向下取整，-10//3=-4。

Q3：短路求值与逻辑返回值 —— 怎么理解？

A：and 左边为假就直接返回假、不跑右边；or 左边为真就不跑右边——这就是”短路”。更反直觉：and/or 返回的是那个值本身而非 True/False（1 and 2 得 2）。像问”你有空且愿意？“，前一句否就懒得听后一句。

Q4：is vs == 与整数缓存 —— 怎么理解？

A：比"值相等"，is 比"是不是同一个对象（内存地址）"。日常 99% 用，is 主要判 None。坑：Python 缓存 -5~256 小整数，is 在这区间会骗你返回 True。像两本人一模一样的书，== 说内容同，is 说是不是同一本。

Q5：流程控制——分支与循环 —— 怎么理解？

A：分支用 if/elif/else，注意 elif 排他（命中即停，顺序重要）；循环用 while/for，while-else 在未被 break 时执行。match-case（3.10+）做模式匹配更优雅。缩进就是代码块边界，少一格就报错。

Q6：核心速记主线有哪些？

七大类运算符：算术/赋值/比较/逻辑/位/成员/身份
整除 // 向下取整；链式比较 18<=age<=60
短路：and/or 遇假/真即停，返回原值非布尔
is 比对象身份、== 比值；小整数 -5~256 有缓存

口诀

A：七类运算符先记牢，算术赋值比较逻辑位；

成员身份各司职，整除向下莫忘掉。

短路求值懒执行，and or 返原值不布尔；

is 比身份 == 比值，小整数缓存要记熟。

Python 运算符分类图


graph TD

    A[Python 运算符] --> B["算术运算符<br/>+ - * / // % **"]

    A --> C["赋值运算符<br/>= += -= *= /= //= %= **="]

    A --> D["比较运算符<br/>== != > < >= <="]

    A --> E["逻辑运算符<br/>and or not"]

    A --> F["位运算符<br/>& | ^ ~ << >>"]

    A --> G["成员运算符<br/>in not in"]

    A --> H["身份运算符<br/>is is not"]

    B --> B1["整除向下取整<br/>-10//3=-4"]

    B --> B2["幂运算开方<br/>16**0.5=4.0"]

    D --> D1["链式比较<br/>18<=age<=60"]

    E --> E1["短路求值<br/>False and 其他=False"]

    G --> G1["字符串包含<br/>'a' in 'abc'=True"]

常见坑点

1. 整除向下取整陷阱

 
print(10 // 3)    # 3
 
print(-10 // 3)   # -4 ← 不是 -3！
 
print(10 // -3)   # -4

原理：// 是向下取整（floor division），不是截断
类比：数轴上向左取整，-3.33 向左是 -4
解决：需要截断用 int(a / b)

2. 浮点数除法精度

 
print(0.1 + 0.2)        # 0.30000000000000004
 
print(0.1 + 0.2 == 0.3) # False

原因：0.1 和 0.2 在二进制中是无限循环小数
解决：使用 decimal.Decimal('0.1') 或整数运算

3. 链式比较的短路特性

 
x = 5
 
print(1 < x < 10)   # True
 
print(1 < x > 10)   # False ← x>10 为 False，但不会报错
 
print(1 < x < 3)    # False ← x<3 为 False

原理：链式比较相当于 1 < x and x < 10，短路求值

4. `is` vs `==` 的混淆

 
a = [1, 2, 3]
 
b = [1, 2, 3]
 
print(a == b)   # True（值相等）
 
print(a is b)   # False（不是同一个对象）
 
print(a is a)   # True（同一个对象）

规则：== 比较值，is 比较内存地址（id）
坑点：小整数缓存（-5~256）可能导致 is 返回 True

5. 逻辑运算符的返回值

 
print(1 and 2)    # 2 ← 不是 True！
 
print(0 or 5)     # 5 ← 不是 True！
 
print(1 or 2)     # 1 ← 不是 True！

原理：and 返回第一个假值或最后一个真值；or 返回第一个真值或最后一个假值
记忆：x and y → 如果 x 为假返回 x，否则返回 y

6. 成员运算符的效率

 
# 列表查找 O(n)
 
print(3 in [1, 2, 3, 4, 5])  # True
 
# 集合查找 O(1)
 
print(3 in {1, 2, 3, 4, 5})  # True
 
# 字符串查找 O(n)
 
print('a' in 'abc')           # True

优化：频繁查找用集合（set）而非列表（list）
下一篇：04_循环与列表

PorterYuan · 个人学习博客

探索

Day 03：运算符与流程控制

Day 03：运算符与流程控制

1. 算术运算符

2. 赋值运算符

3. 比较（关系）运算符

4. 逻辑运算符

短路运算（重要！⭐）

5. 位运算符

6. 成员运算符

7. 身份运算符

8. Python 编码规范

9. 单分支 if

10. 双分支 if-else

11. 多分支 if-elif-else

12. 嵌套分支

13. match-case 语句（Python 3.10+，⭐新特性）

14. 三目运算符

15. while 循环

15.1 基本语法

15.2 三种关键条件

15.3 while-else

15.4 实际应用

速记卡（面试闪卡）

相关链接

Python 运算符分类图

常见坑点

1. 整除向下取整陷阱

2. 浮点数除法精度

3. 链式比较的短路特性

4. is vs == 的混淆

5. 逻辑运算符的返回值

6. 成员运算符的效率

关系图谱

目录

反向链接

近期更新

页面走丢了

AI Agent 方法论与产品思维路线图

LeetCode 学习路线图（186 题）

八股文学习路线图

技术学习路线图（AI Agent 开发）

全局导航

4. `is` vs `==` 的混淆