Python基础语法教程

🐍 Python 基础语法这一篇就够了

适用版本: Python 3.8+ 目标读者: 初学者及有一定基础想要系统复习的开发者 最后更新: 2026-07-21

目录

1. Python 简介

1.1 什么是 Python？

Python 是一种高级、解释型、面向对象的编程语言，由 Guido van Rossum 于 1991 年发布。它以简洁易读的语法和强大的标准库而闻名。

1.2 Python 的特点

1.3 Python 的应用领域

• Web 开发: Django、Flask、FastAPI
• 数据科学与人工智能: NumPy、Pandas、PyTorch、TensorFlow
• 自动化运维: Ansible、SaltStack
• 网络爬虫: Scrapy、BeautifulSoup、Selenium
• 桌面应用: PyQt、Tkinter
• 游戏开发: Pygame

2. 环境搭建与第一个程序

2.1 安装 Python

从 python.org 下载安装包。安装时务必勾选 “Add Python to PATH”。

验证安装：

python –version
# 输出示例: Python 3.11.5

2.2 第一个程序：Hello, World!

💡 代码说明：创建第一个 Python 程序，用 print() 函数在屏幕上输出文字：

# hello.py
print("Hello, World!")

🔑 要点总结：运行后屏幕上将显示 Hello, World! ——你已经成功编写了第一个 Python 程序。

运行：

python hello.py
# 输出: Hello, World!

2.3 交互式解释器（REPL）

在终端输入 python 即可进入交互模式：

💡 代码说明：在终端输入 python 进入交互模式，可以逐行输入代码并立即看到结果，适合快速测试：

>>> 1 + 2
3
>>> print("你好，世界！")
你好，世界！
>>> exit() # 退出交互模式

🔑 要点总结：REPL 是学习 Python 的利器——每学一个新语法都可以先在交互环境中试一试。输入 exit() 即可退出。

2.4 IDE 推荐

3. 变量与数据类型

3.1 变量命名规则

💡 代码说明：Python 变量名由字母、数字和下划线组成，但不能以数字开头，也不能使用关键字。来看几个例子：

# ✅ 合法的变量名
name = "Alice"
age = 25
first_name = "Bob"
_name = "hidden"
user123 = "valid"

# ❌ 非法的变量名
# 123abc = "error" # 不能以数字开头
# my-name = "error" # 不能包含连字符
# class = "error" # 不能使用关键字

🔑 要点总结：记住三条核心规则：不能数字开头、不能用关键字、区分大小写。按照 snake_case 风格命名是最佳实践。

命名规范（PEP 8）:

• 变量和函数：小写 + 下划线 snake_case
• 类名：大驼峰 PascalCase
• 常量：全大写 UPPER_CASE

3.2 Python 关键字

💡 代码说明：Python 保留了一些有特殊含义的单词（关键字），不能用作变量名。通过 keyword 模块可以查看完整列表：

import keyword
print(keyword.kwlist)
# ['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await',
# 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except',
# 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is',
# 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return',
# 'try', 'while', 'with', 'yield']

🔑 要点总结：总共 35 个关键字（Python 3.8+），像 if、for、class、def 等都在其中，取名时注意避开。

3.3 基本数据类型

💡 代码说明：Python 有六大基本数据类型：整数(int)、浮点数(float)、复数(complex)、布尔值(bool)、字符串(str)和空值(None)。下面的代码展示了每种类型的用法：

# — 数值型 —
# int（整数）：无大小限制
a = 10
b = –5
big = 999999999999999999999999999999

# float（浮点数）：双精度，约 15-17 位有效数字
pi = 3.14159
sci = 1.5e-3 # 科学计数法 = 0.0015

# complex（复数）
c = 3 + 4j
print(c.real) # 3.0
print(c.imag) # 4.0

# — 布尔型 —
# bool：True 或 False（首字母大写）
is_active = True
is_empty = False
# bool 是 int 的子类：True == 1, False == 0
print(True + True) # 2
print(isinstance(True, int)) # True

# — 字符串 —
# str：使用单引号或双引号
name = 'Alice'
message = "Hello"
multiline = """第一行
第二行
第三行"""

# — None 类型 —
# None：表示"没有值"或"空"
result = None

🔑 要点总结：Python 的整数没有大小限制，布尔值是 int 的子类（True==1），None 表示无值。这些都是日常编程最基础的数据类型。

3.4 类型检查与转换

💡 代码说明：使用 type() 查看变量类型，isinstance() 检查继承关系，以及用 int()、float()、str() 等函数在不同类型间转换：

# type() 查看类型
x = 42
print(type(x)) # <class 'int'>

# isinstance() 检查类型
print(isinstance(x, int)) # True
print(isinstance(x, (int, float))) # True（多种类型之一）

# 类型转换（显式转换）
num_str = "123"
num = int(num_str) # 字符串 -> 整数: 123
f = float("3.14") # 字符串 -> 浮点数: 3.14
s = str(100) # 整数 -> 字符串: "100"
b = bool(1) # -> True （非0为True，0/空/None为False）
lst = list("hello") # 字符串 -> 列表: ['h', 'e', 'l', 'l', 'o']

🔑 要点总结：isinstance() 比 type() 更灵活（支持子类判断），显式类型转换时要确保数据格式正确，否则会抛出 ValueError。

3.5 动态类型

💡 代码说明：Python 是动态类型语言，同一个变量可以在不同时刻指向不同类型的值，无需提前声明：

# Python 是动态类型语言，变量可以随时改变类型
x = 10
print(type(x)) # <class 'int'>

x = "hello"
print(type(x)) # <class 'str'>

x = [1, 2, 3]
print(type(x)) # <class 'list'>

🔑 要点总结：动态类型让代码更灵活简洁，但也意味着要小心类型错误——这也是类型注解（第22章）存在的意义。

3.6 可变与不可变类型

💡 代码说明：理解可变（list/dict/set）和不可变（int/str/tuple）类型的区别，是掌握 Python 内存行为的关键：

# 不可变类型：int, float, complex, str, tuple, frozenset, bool
a = "hello"
# a[0] = "H" # ❌ TypeError: 'str' object does not support item assignment

# 可变类型：list, dict, set, bytearray
b = [1, 2, 3]
b[0] = 10 # ✅ 可以修改
print(b) # [10, 2, 3]

🔑 要点总结：不可变对象无法原地修改，任何修改操作实际是创建新对象；可变对象则可以直接改变其内容。这影响了赋值、传参和拷贝的行为。

4. 运算符

4.1 算术运算符

💡 代码说明：Python 支持加减乘除、整除、取余、幂运算等基本算术运算，以及 abs()、round()、divmod() 等内置数学函数：

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 幂运算
print(abs(–5)) # 5 绝对值
print(round(3.14159, 2)) # 3.14 四舍五入
print(pow(2, 3)) # 8 等价于 2**3

# divmod：同时返回商和余数
quotient, remainder = divmod(10, 3)
print(quotient, remainder) # 3 1

🔑 要点总结：注意 / 总是返回 float，// 是向下取整。divmod() 同时返回商和余数，非常实用。

4.2 比较运算符

💡 代码说明：比较运算符用于比较两个值的大小关系，返回布尔值。Python 还支持链式比较和 is / == 两种相等性检查：

a, b = 10, 20

print(a == b) # False 等于
print(a != b) # True 不等于
print(a > b) # False 大于
print(a < b) # True 小于
print(a >= b) # False 大于等于
print(a <= b) # True 小于等于

# 链式比较（Python 特有）
x = 5
print(0 < x < 10) # True（等价于 0 < x and x < 10）

# is 和 == 的区别
# == 比较值是否相等
# is 比较是否为同一个对象（内存地址相同）
list_a = [1, 2, 3]
list_b = [1, 2, 3]
print(list_a == list_b) # True 值相等
print(list_a is list_b) # False 不同对象

# 对于小整数（-5 ~ 256）和短字符串，Python 使用缓存
a = 256; b = 256
print(a is b) # True（同一缓存对象）
a = 257; b = 257
print(a is b) # 可能 True 也可能 False（取决于实现）

🔑 要点总结：== 比较值，is 比较身份（内存地址）。对于小整数（-5~256），Python 使用缓存机制，所以 is 也可能返回 True——这是常见的面试考点。

4.3 逻辑运算符

💡 代码说明：Python 使用 and、or、not（而不是 &&、||、!）。逻辑运算支持短路求值，且可以作用于非布尔值：

# and, or, not（注意：不是 &&, ||, !）
x, y = True, False

print(x and y) # False 且
print(x or y) # True 或
print(not x) # False 非

# 短路求值
def get_true():
print("get_true 被调用")
return True

def get_false():
print("get_false 被调用")
return False

# and：第一个 False 后面的不会执行
print(get_false() and get_true()) # 只输出 get_false 被调用，返回 False

# or：第一个 True 后面的不会执行
print(get_true() or get_false()) # 只输出 get_true 被调用，返回 True

# 非布尔值的逻辑运算：返回第一个能决定结果的值
print(0 and 10) # 0 (0 是 "假值"，直接返回)
print([] and 10) # [] (空列表是 "假值")
print(0 or 10) # 10 (0 是假值，返回 10)
print("" or "default") # "default"
print("hello" or "world") # "hello" (第一个是真值)

# 常见的默认值模式
name = "" or "匿名用户"
print(name) # 匿名用户

🔑 要点总结：短路求值是性能优化的好帮手。非布尔值的逻辑运算返回第一个能决定结果的值，常用于设置默认值（如 name = input_name or ‘匿名’）。

4.4 位运算符

💡 代码说明：位运算符直接操作二进制位，包括按位与(&)、或(|)、异或(^)、取反(~)、左移(<<)、右移(>>)：

a, b = 5, 3 # 二进制: 0101, 0011

print(a & b) # 1 (0101 & 0011 = 0001) 按位与
print(a | b) # 7 (0101 | 0011 = 0111) 按位或
print(a ^ b) # 6 (0101 ^ 0011 = 0110) 按位异或
print(~a) # -6 按位取反
print(a << 1) # 10 (0101 << 1 = 1010) 左移
print(a >> 1) # 2 (0101 >> 1 = 0010) 右移

🔑 要点总结：位运算在底层操作、权限标志、性能优化等场景很有用，但可读性较差，使用时建议加注释说明意图。

4.5 赋值运算符

💡 代码说明：除了基本赋值 =，Python 还支持复合赋值（+=、-= 等）和 Python 3.8 新增的海象运算符 :=：

x = 10
x += 5 # 等价于 x = x + 5 → 15
x -= 3 # 等价于 x = x – 3 → 12
x *= 2 # 等价于 x = x * 2 → 24
x /= 4 # → 6.0
x //= 2 # → 3.0
x **= 2 # → 9.0
x %= 5 # → 4.0

# 海象运算符（Python 3.8+）：在表达式中赋值
# 语法: (变量名 := 表达式)
if (n := len("hello")) > 3:
print(f"字符串长度为 {n}，大于3") # 字符串长度为 5，大于3

# 经典用法：循环中避免重复计算
# 传统写法
import re
while True:
line = input()
if not line:
break
# 海象写法
# while line := input():
# # 处理 line

🔑 要点总结：海象运算符 := 能在表达式内部完成赋值，常用于 if 和 while 中避免重复计算，如 while (line := file.readline())。

4.6 成员运算符

💡 代码说明：in 和 not in 用于检查元素是否存在于序列（列表、字符串、字典的键等）中：

# in 和 not in：检查元素是否在序列中
fruits = ["apple", "banana", "orange"]

print("apple" in fruits) # True
print("grape" not in fruits) # True
print("e" in "hello") # True（字符串也是序列）

# 字典中检查键
user = {"name": "Alice", "age": 25}
print("name" in user) # True
print("Alice" in user) # False（检查的是键，不是值）
print("Alice" in user.values()) # True

🔑 要点总结：对于字典，in 默认检查键而非值；检查值需要用 .values()。in 对集合的判断是 O(1) 的，非常高效。

4.7 运算符优先级（从高到低）

# ** 幂运算
# +x, -x, ~x 一元运算符
# *, /, //, % 乘除取余
# +, – 加减
# <<, >> 位移
# & 按位与
# ^ 按位异或
# | 按位或
# ==, !=, >, <, >=, <=, is, is not, in, not in 比较
# not 逻辑非
# and 逻辑与
# or 逻辑或
# := 海象运算符

# 不确定时就加括号！
result = (2 + 3) * 4 # 20

5. 字符串详解

5.1 字符串创建

💡 代码说明：Python 提供了四种字符串定义方式：单引号、双引号、三单引号、三双引号，以及原始字符串（r-string）来忽略转义：

# 四种引号方式
s1 = '单引号字符串'
s2 = "双引号字符串"
s3 = '''三单引号
可以跨行'''
s4 = """三双引号
也可以跨行"""

# 引号嵌套
s5 = "It's a book" # 双引号内包含单引号
s6 = 'He said "Hello"' # 单引号内包含双引号
s7 = 'It\\'s a book' # 转义字符

# 原始字符串（raw string）：不处理转义
path = r"C:\\Users\\name\\new_folder"
print(path) # C:\\Users\\name\\new_folder（\\n 不会被当成换行）

🔑 要点总结：日常用单/双引号即可；多行文本用三引号；处理 Windows 路径或正则表达式时，原始字符串 r’…’ 能省去大量转义的麻烦。

5.2 转义字符

💡 代码说明：反斜杠 \\ 用于引入特殊字符，如换行 \\n、制表符 \\t、引号 " 等：

print("Hello\\nWorld") # 换行
print("Hello\\tWorld") # 制表符
print("Hello\\rWorld") # 回车
print("He said \\"Hi\\"") # 双引号
print('It\\'s a book') # 单引号
print("Path: C:\\\\data") # 反斜杠
print("Line1\\\\\\nLine2") # 续行（行末的反斜杠表示下一行继续）

🔑 要点总结：转义字符让字符串能表达任意特殊字符。需要输出反斜杠本身时用 \\，或使用原始字符串 r’…'。

5.3 字符串索引与切片

💡 代码说明：字符串支持索引（单个字符）和切片（子字符串）。语法为 [start:stop:step]，start 包含、stop 不包含、step 为步长：

text = "Python编程"

# 索引（从0开始）
print(text[0]) # P
print(text[–1]) # 程 （负数索引从右边开始，-1 是最后一个）
print(text[6]) # 编

# 切片 [start:stop:step]
# start: 起始索引（包含），默认0
# stop: 结束索引（不包含），默认末尾
# step: 步长，默认1
text = "0123456789"

print(text[0:5]) # 01234 索引0到4
print(text[2:7]) # 23456
print(text[:5]) # 01234 省略start，从0开始
print(text[5:]) # 56789 省略stop，到末尾
print(text[::2]) # 02468 步长为2
print(text[::–1]) # 9876543210 反转字符串！
print(text[–3:]) # 789 最后3个字符

🔑 要点总结：切片是 Python 最优雅的特性之一。[::-1] 反转字符串、[-3:] 取最后三个字符——简洁而强大。切片操作同样适用于列表和元组。

5.4 字符串常用方法

💡 代码说明：字符串有丰富的方法用于大小写转换、空白处理、查找替换、判断和分割连接。以下是完整的参考示例：

s = " Hello, Python World! "

# — 大小写转换 —
print(s.upper()) # " HELLO, PYTHON WORLD! " 全大写
print(s.lower()) # " hello, python world! " 全小写
print(s.title()) # " Hello, Python World! " 每个单词首字母大写
print(s.capitalize()) # " hello, python world! " 首字母大写
print(s.swapcase()) # " hELLO, pYTHON wORLD! " 大小写翻转

# — 空白处理 —
print(s.strip()) # "Hello, Python World!" 去两端空白
print(s.lstrip()) # "Hello, Python World! " 去左端空白
print(s.rstrip()) # " Hello, Python World!" 去右端空白

# — 查找与替换 —
print(s.find("Python")) # 9 找到返回索引，找不到返回 -1
print(s.index("Python")) # 9 找到返回索引，找不到抛出 ValueError
print(s.rfind("o")) # 16 从右边查找
print(s.count("o")) # 3 统计出现次数
print(s.replace("World", "大家")) # " Hello, Python 大家! "
print(s.replace("o", "O", 1)) # " HellO, Python World! " 只替换1次

# — 判断方法 —
print(s.startswith(" He")) # True 是否以指定前缀开始
print(s.endswith("! ")) # True 是否以指定后缀结束
print("abc123".isalnum()) # True 是否只含字母和数字
print("abc".isalpha()) # True 是否只含字母
print("123".isdigit()) # True 是否只含数字
print("abc".islower()) # True 是否全小写
print("ABC".isupper()) # True 是否全大写
print(" ".isspace()) # True 是否全空白字符
print("Title".istitle()) # True 是否是标题格式

# — 分割与连接 —
csv = "apple,banana,orange"
print(csv.split(",")) # ['apple', 'banana', 'orange']
print(csv.split(",", 1)) # ['apple', 'banana,orange'] 只分割1次
print("a b c".split()) # ['a', 'b', 'c'] 默认按空白分割且会合并多个空白

# rsplit：从右边开始分割
print("a,b,c".rsplit(",", 1)) # ['a,b', 'c']

# splitlines：按行分割
multiline = "line1\\nline2\\nline3"
print(multiline.splitlines()) # ['line1', 'line2', 'line3']
print(multiline.splitlines(keepends=True)) # ['line1\\n', 'line2\\n', 'line3']

# join：用分隔符连接可迭代对象
words = ["Python", "is", "awesome"]
print(" ".join(words)) # Python is awesome
print("-".join(words)) # Python-is-awesome
print(", ".join(["a", "b", "c"])) # a, b, c

# partition：分割成三部分 (前, 分隔符, 后)
print("hello world".partition(" ")) # ('hello', ' ', 'world')
# rpartition：从右边开始
print("hello world hello".rpartition(" ")) # ('hello world', ' ', 'hello')

# — 填充与对齐 —
print("42".zfill(5)) # 00042 用0填充左侧
print("hi".ljust(10, "-")) # hi——– 左对齐
print("hi".rjust(10, "-")) # ——–hi 右对齐
print("hi".center(10, "-")) # —-hi—- 居中对齐

🔑 要点总结：这些方法都不会修改原字符串（字符串不可变），而是返回新字符串。特别推荐记住 split()、join()、strip() 和 replace()——它们是日常编程中使用频率最高的字符串方法。

5.5 字符串格式化

💡 代码说明：Python 提供了四种字符串格式化方式。f-string（Python 3.6+）是最推荐的，支持表达式嵌入、格式说明符和调试模式：

name = "Alice"
age = 25
pi = 3.1415926

# 方法1：f-string（Python 3.6+，推荐！）
print(f"我叫{name}，今年{age}岁")
print(f"π ≈ {pi:.2f}") # π ≈ 3.14
print(f"{name:>10}") # ' Alice' 右对齐，宽度10
print(f"{name:*^10}") # '**Alice***' 居中，* 填充
print(f"{1000000:,}") # 1,000,000 千分位
print(f"{0.25:.1%}") # 25.0% 百分比
print(f"{255:#x}") # 0xff 十六进制
print(f"{age=}") # age=25 (调试模式)

# 方法2：str.format()
print("我叫{}，今年{}岁".format(name, age))
print("我叫{0}，今年{1}岁，{0}来自北京".format(name, age)) # 按索引
print("我叫{name}，今年{age}岁".format(name="Bob", age=30)) # 按名称

# 方法3：% 格式化（旧式，不推荐）
print("我叫%s，今年%d岁" % (name, age))
print("π ≈ %.2f" % pi)

# 方法4：format() 内置函数
print(format(pi, ".2f")) # 3.14

🔑 要点总结：f-string 不仅最简洁，而且是效率最高的格式化方式。{age=} 调试模式能打印变量名和值，在排查问题时非常方便。

5.6 字符串不可变性

💡 代码说明：字符串是不可变类型——不能通过索引直接修改某个字符。正确的做法是创建新字符串：

s = "Hello"
# s[0] = "h" # ❌ TypeError: 'str' object does not support item assignment

# 正确做法：创建新字符串
s = "h" + s[1:]
print(s) # "hello"

🔑 要点总结：理解不可变性有助于理解 Python 的内存模型：每次修改字符串实际都在创建新对象，频繁拼接时推荐用 join() 而非 + 以获得更好性能。

6. 列表（List）

列表是 Python 中最常用的可变序列类型，元素可重复，用 [] 表示。

6.1 创建列表

💡 代码说明：列表用 [] 或 list() 创建，可以包含任意类型的元素，支持乘法重复和嵌套。但要注意嵌套列表乘法的陷阱：

# 多种创建方式
empty = []
nums = [1, 2, 3, 4, 5]
mixed = [1, "hello", 3.14, True, [1, 2]] # 可以包含不同类型
nested = [[1, 2], [3, 4], [5, 6]] # 嵌套列表

# 用构造函数创建
chars = list("hello") # ['h', 'e', 'l', 'l', 'o']
range_list = list(range(5)) # [0, 1, 2, 3, 4]

# 列表乘法
zeros = [0] * 5 # [0, 0, 0, 0, 0]

# ⚠️ 陷阱：嵌套列表乘法
grid = [[0] * 3] * 3 # 看起来是3×3矩阵
grid[0][0] = 1
print(grid) # [[1, 0, 0], [1, 0, 0], [1, 0, 0]] ← 三行指向同一个子列表！

# ✅ 正确做法
grid = [[0] * 3 for _ in range(3)]
grid[0][0] = 1
print(grid) # [[1, 0, 0], [0, 0, 0], [0, 0, 0]]

🔑 要点总结：嵌套列表乘法 [[0]*3]*3 会创建指向同一子列表的多个引用——这是一个经典陷阱！正确的做法是使用列表推导式 [[0]*3 for _ in range(3)]。

6.2 访问与切片

💡 代码说明：列表的索引和切片语法与字符串完全一致——正向下标从0开始，负向下标从-1开始：

fruits = ["苹果", "香蕉", "橙子", "葡萄", "西瓜"]

# 索引
print(fruits[0]) # 苹果
print(fruits[–1]) # 西瓜

# 切片（和字符串一样）
print(fruits[1:3]) # ['香蕉', '橙子']
print(fruits[::2]) # ['苹果', '橙子', '西瓜']
print(fruits[::–1]) # ['西瓜', '葡萄', '橙子', '香蕉', '苹果'] 反转

🔑 要点总结：列表切片返回新列表，不影响原列表。fruits[::-1] 可以快速反转列表，而且切片语法适用于所有序列类型。

6.3 修改列表

💡 代码说明：列表是可变的——可以修改单个元素、用切片批量替换、删除元素或清空整个列表：

fruits = ["苹果", "香蕉", "橙子"]

# 修改元素
fruits[1] = "草莓"
print(fruits) # ['苹果', '草莓', '橙子']

# 用切片批量修改
fruits[1:3] = ["芒果", "葡萄"]
print(fruits) # ['苹果', '芒果', '葡萄']

# 删除元素
del fruits[0]
print(fruits) # ['芒果', '葡萄']

# 清空列表
fruits.clear()
print(fruits) # []

🔑 要点总结：切片赋值 fruits[1:3] = […] 可以一次替换多个元素，替换的元素数量不必相等——这是列表的一大灵活性。

6.4 列表方法

💡 代码说明：列表提供了丰富的方法用于添加（append/extend/insert）、删除（remove/pop）、查找（index/count）和排序（sort）：

# — 添加元素 —
nums = [1, 2, 3]

nums.append(4) # [1, 2, 3, 4] 末尾添加一个元素
nums.extend([5, 6, 7]) # [1, 2, 3, 4, 5, 6, 7] 末尾添加多个元素
nums.insert(0, 0) # [0, 1, 2, 3, 4, 5, 6, 7] 在指定位置插入

# append vs extend
a = [1, 2]
a.append([3, 4])
print(a) # [1, 2, [3, 4]] ← 整个列表作为一个元素
b = [1, 2]
b.extend([3, 4])
print(b) # [1, 2, 3, 4] ← 元素逐个加入

# — 删除元素 —
nums = [1, 2, 3, 2, 4]

nums.remove(2) # [1, 3, 2, 4] 删除第一个匹配值（找不到则 ValueError）
popped = nums.pop() # 弹出并返回最后一个元素 → 4; nums = [1, 3, 2]
popped = nums.pop(1) # 弹出并返回索引1的元素 → 3; nums = [1, 2]
# del nums[0] # 删除索引0的元素

# — 查找与统计 —
nums = [1, 2, 3, 2, 4, 2]

print(nums.index(2)) # 1 第一个出现的索引（找不到则 ValueError）
print(nums.index(2, 2)) # 3 从索引2开始查找
print(nums.count(2)) # 3 统计出现次数
print(len(nums)) # 6 列表长度

# — 排序 —
nums = [3, 1, 4, 1, 5, 9]

nums.sort() # 原地升序排序 → [1, 1, 3, 4, 5, 9]
nums.sort(reverse=True) # 原地降序排序 → [9, 5, 4, 3, 1, 1]

# sorted()：返回新列表，不改变原列表
original = [3, 1, 4, 1, 5]
sorted_list = sorted(original) # [1, 1, 3, 4, 5]
print(original) # [3, 1, 4, 1, 5] 不变

# 自定义排序：按字符串长度
words = ["apple", "kiwi", "banana", "pear"]
words.sort(key=len) # ['kiwi', 'pear', 'apple', 'banana']
words.sort(key=lambda w: w[–1]) # 按最后一个字母排序

# — 其他常用方法 —
nums = [1, 2, 3]
nums.reverse() # 原地反转 → [3, 2, 1]
# 或用切片：reversed_list = nums[::-1]

nums_copy = nums.copy() # 浅拷贝
# 等价于 nums_copy = nums[:] 或 list(nums)

🔑 要点总结：注意 append 和 extend 的关键区别：append 把参数整体作为一个元素加入，extend 则逐个加入。sort() 原地排序，sorted() 返回新列表。

6.5 浅拷贝 vs 深拷贝

💡 代码说明：嵌套列表的拷贝需要特别注意——浅拷贝只复制外层引用，深拷贝才会递归复制所有层级：

import copy

original = [[1, 2], [3, 4]]

# 浅拷贝：只复制外层
shallow = original.copy() # 或 original[:] 或 list(original)
shallow[0][0] = 99
print(original) # [[99, 2], [3, 4]] ← 受影响！

# 深拷贝：递归复制所有层级
deep = copy.deepcopy(original)
deep[0][0] = 100
print(original) # [[99, 2], [3, 4]] ← 不受影响

🔑 要点总结：对于嵌套结构，使用 copy.deepcopy() 才能做到真正独立的复制。但深拷贝性能开销较大，只在确实需要时使用。

6.6 enumerate 与 zip

💡 代码说明：enumerate() 同时获取索引和元素值，zip() 将多个列表打包成一对对元组，是遍历中最常用的两个内置函数：

fruits = ["苹果", "香蕉", "橙子"]

# enumerate: 同时获取索引和值
for i, fruit in enumerate(fruits):
print(f"{i}: {fruit}")
# 0: 苹果
# 1: 香蕉
# 2: 橙子

for i, fruit in enumerate(fruits, start=1):
print(f"{i}: {fruit}")
# 1: 苹果
# 2: 香蕉
# 3: 橙子

# zip: 同时遍历多个列表
names = ["Alice", "Bob", "Charlie"]
ages = [25, 30, 35]

for name, age in zip(names, ages):
print(f"{name} 今年 {age} 岁")

# zip 会在最短的列表结束时停止
a = [1, 2, 3]
b = ['a', 'b']
print(list(zip(a, b))) # [(1, 'a'), (2, 'b')]

# 需要严格匹配长度？用 zip_longest
from itertools import zip_longest
print(list(zip_longest(a, b, fillvalue=None)))
# [(1, 'a'), (2, 'b'), (3, None)]

🔑 要点总结：enumerate(seq, start=1) 让序号从1开始，zip() 按最短列表截断，需要严格匹配时用 zip_longest()。

7. 元组（Tuple）

元组是不可变序列类型，用 () 表示。一旦创建，不可修改。

7.1 创建元组

💡 代码说明：元组用 () 或 tuple() 创建。特别注意：单元素元组必须在元素后加逗号，否则会被当成普通括号表达式：

t1 = (1, 2, 3)
t2 = 1, 2, 3 # 逗号创建，括号可省略（不推荐省略）
t3 = (1,) # ⚠️ 单元素元组必须有逗号！
t4 = (1) # 这不是元组，是整数1！
t5 = () # 空元组
t6 = tuple([1, 2, 3]) # 从其他序列创建
t7 = tuple("hello") # ('h', 'e', 'l', 'l', 'o')

🔑 要点总结：(1,) 是元组，(1) 只是整数 1——逗号才是元组的真正标识，括号在很多情况下可以省略。

7.2 元组的不可变性

💡 代码说明：元组创建后不能修改——不能赋值、不能添加、不能删除。但如果元组包含可变对象（如列表），该可变对象的内容可以改变：

t = (1, 2, 3)
# t[0] = 10 # ❌ TypeError: 'tuple' object does not support item assignment
# t.append(4) # ❌ AttributeError: 'tuple' object has no attribute 'append'

# 【注意】如果元组包含可变对象，可变对象的内容可以改！
t = ([1, 2], 3)
t[0].append(3)
print(t) # ([1, 2, 3], 3) 元组本身不变，但内部的列表变了

🔑 要点总结：元组的不可变指的是引用不可变——元组中存储的每个元素的引用不能改变，但如果这个引用指向一个可变对象，该对象本身还是可以修改的。

7.3 元组解包

💡 代码说明：序列解包是 Python 的一大特色，可以一次性将元组（或列表）的元素赋值给多个变量。* 可以收集多余元素：

# 序列解包（unpacking）
point = (3, 4)
x, y = point
print(x, y) # 3 4

# 多变量同时赋值（本质是元组打包再解包）
a, b = 1, 2

# 交换变量（Python 特有写法）
a, b = b, a

# 星号表达式：收集多余元素
first, *middle, last = [1, 2, 3, 4, 5]
print(first) # 1
print(middle) # [2, 3, 4]
print(last) # 5

head, *tail = [1, 2, 3]
print(head) # 1
print(tail) # [2, 3]

# 忽略不需要的值（_ 作为占位符）
_, _, z = (1, 2, 3)
print(z) # 3

🔑 要点总结：解包让交换变量 a, b = b, a 变得异常简洁，*middle 收集中间元素、_ 忽略不关心的值——这些都是 Pythonic 的编码风格。

7.4 为什么使用元组？

💡 代码说明：元组不只是「不可变的列表」——它还可以作为字典键、利用 namedtuple 创建轻量数据类：

# 元组作为字典的键
scores = {("Alice", "Math"): 95, ("Alice", "English"): 88}
print(scores[("Alice", "Math")]) # 95

# namedtuple：带名称的元组
from collections import namedtuple

Point = namedtuple("Point", ["x", "y"])
p = Point(3, 4)
print(p.x, p.y) # 3 4
print(p[0], p[1]) # 3 4（仍支持索引访问）
# p.x = 5 # ❌ 不可修改（和普通元组一样）

🔑 要点总结：当你有一组不应被修改的数据（如坐标、RGB值、数据库记录）时，元组通过不可变性传达了一组数据的语义。namedtuple 则是轻量数据类的绝佳选择。

8. 字典（Dictionary）

字典是键值对的集合，键必须不可变（字符串、数字、元组），{key: value} 表示。Python 3.7+ 字典保持插入顺序。

8.1 创建与访问

💡 代码说明：字典是 Python 的核心数据结构，用 {} 或 dict() 创建，有六种创建方式。访问时推荐使用 get() 而非直接索引：

# 创建字典
d1 = {"name": "Alice", "age": 25, "city": "北京"}
d2 = dict(name="Bob", age=30) # 键为字符串时可用
d3 = dict([("name", "Charlie"), ("age", 35)]) # 从键值对序列创建
d4 = dict(zip(["a", "b", "c"], [1, 2, 3])) # {'a': 1, 'b': 2, 'c': 3}
d5 = dict.fromkeys(["a", "b", "c"], 0) # {'a': 0, 'b': 0, 'c': 0}
d6 = {} # 空字典

# 访问值
print(d1["name"]) # Alice
# print(d1["gender"]) # ❌ KeyError（键不存在时）

# get()：键不存在时返回默认值（推荐！）
print(d1.get("name")) # Alice
print(d1.get("gender", "未知")) # 未知（键不存在，返回默认值）

# setdefault()：如果键不存在，设置默认值并返回
d1.setdefault("score", 0) # 不存在则设置为 0
print(d1) # {…, 'score': 0}

🔑 要点总结：get(key, default) 在键不存在时返回默认值而不抛异常；setdefault() 则在键不存在时同时设置默认值——两者都能避免 KeyError。

8.2 修改字典

💡 代码说明：字典支持添加、修改、更新、删除和合并操作。Python 3.9+ 还引入了 | 和 |= 字典合并运算符：

user = {"name": "Alice", "age": 25}

# 添加/修改
user["city"] = "上海" # 添加新键
user["age"] = 26 # 修改已有键
print(user) # {'name': 'Alice', 'age': 26, 'city': '上海'}

# update()：批量更新
user.update({"age": 27, "email": "alice@example.com"})
print(user) # {'name': 'Alice', 'age': 27, 'city': '上海', 'email': 'alice@example.com'}
# 也可以用 update(key=value, …)
user.update(phone="123456", country="中国")

# 删除
del user["phone"] # 删除指定键（不存在则 KeyError）
popped = user.pop("email") # 弹出并返回值（不存在则 KeyError）
popped = user.pop("email", None) # 不存在时返回默认值
last = user.popitem() # 弹出最后一个键值对（Python 3.7+ LIFO）
user.clear() # 清空

# 字典合并（Python 3.9+）
d1 = {"a": 1, "b": 2}
d2 = {"b": 3, "c": 4}
merged = d1 | d2 # {'a': 1, 'b': 3, 'c': 4} 后者覆盖前者
d1 |= d2 # 原地合并

🔑 要点总结：pop(key, default) 比 del 更安全。d1 | d2 合并字典时，相同键的值会被 d2 覆盖，非常直观。

8.3 遍历字典

💡 代码说明：字典支持遍历键(.keys())、值(.values())和键值对(.items())。遍历时不要直接修改字典大小：

user = {"name": "Alice", "age": 25, "city": "北京"}

# 遍历键
for key in user:
print(key)

for key in user.keys():
print(key)

# 遍历值
for value in user.values():
print(value)

# 遍历键值对
for key, value in user.items():
print(f"{key}: {value}")

# 安全遍历并修改：先收集再修改
# ❌ 不要在遍历时修改字典大小
# for key in user:
# del user[key] # RuntimeError!

# ✅ 先收集要删除的键
to_delete = [key for key in user if key.startswith("a")]
for key in to_delete:
del user[key]

🔑 要点总结：遍历字典时修改其大小会引发 RuntimeError。正确的做法是先收集要删除的键，循环结束后再批量删除。

8.4 字典推导式

💡 代码说明：字典推导式用 {key: value for …} 语法快速创建或变换字典，支持条件过滤：

# {key_expr: value_expr for item in iterable}

# 平方数字典
squares = {x: x**2 for x in range(5)}
print(squares) # {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

# 交换键值
original = {"a": 1, "b": 2, "c": 3}
swapped = {v: k for k, v in original.items()}
print(swapped) # {1: 'a', 2: 'b', 3: 'c'}

# 条件过滤
even_squares = {x: x**2 for x in range(10) if x % 2 == 0}
print(even_squares) # {0: 0, 2: 4, 4: 16, 6: 36, 8: 64}

🔑 要点总结：字典推导式比传统的 for 循环更简洁，是 Pythonic 风格的体现。常见用法包括创建映射表、交换键值、过滤特定项等。

8.5 defaultdict 与 Counter

💡 代码说明：collections 模块的 defaultdict 和 Counter 是字典的强力扩展，能极大简化分组和统计类代码：

# — defaultdict: 带默认值的字典 —
from collections import defaultdict

# 按类型统计（无需检查键是否存在）
words = ["apple", "banana", "apple", "orange", "banana", "apple"]
word_count = defaultdict(int) # int() 返回 0
for word in words:
word_count[word] += 1 # 不存在自动初始化为 0
print(word_count) # defaultdict(<class 'int'>, {'apple': 3, 'banana': 2, 'orange': 1})

# 分组
groups = defaultdict(list)
for word in words:
groups[len(word)].append(word)
print(groups) # defaultdict(<class 'list'>, {5: ['apple', 'apple'], 6: ['banana', 'orange', 'banana']})

# — Counter: 计数器 —
from collections import Counter

cnt = Counter(words)
print(cnt) # Counter({'apple': 3, 'banana': 2, 'orange': 1})
print(cnt.most_common(2)) # [('apple', 3), ('banana', 2)] 前2个最常见元素
print(cnt["grape"]) # 0 (不存在的键返回 0)

🔑 要点总结：defaultdict 省去了检查键是否存在的样板代码；Counter 让频率统计变为一行代码。两者都是日常编程中的高频工具。

9. 集合（Set）

集合是无序、不重复元素的集合，用 {} 表示。元素必须不可变。

9.1 创建集合

💡 代码说明：集合用 {} 或 set() 创建，元素自动去重且无序。注意：set() 创建空集合，{} 创建的是空字典：

# 创建集合
s1 = {1, 2, 3, 4}
s2 = set([1, 2, 2, 3, 3, 4]) # {1, 2, 3, 4} 自动去重
s3 = set("hello") # {'h', 'e', 'l', 'o'} l只出现一次
s4 = set() # 空集合（不能用 {}，那是空字典）

# 集合推导式
squares = {x**2 for x in range(10)} # {0, 1, 4, 9, 16, 25, 36, 49, 64, 81}

🔑 要点总结：集合支持推导式，和列表推导式语法类似。因为元素不可变，集合中不能包含列表或字典。

9.2 集合操作

💡 代码说明：集合支持数学中的交、并、差、对称差运算，以及子集/超集判断。运算符（| & – ^）和方法效果相同：

a = {1, 2, 3, 4}
b = {3, 4, 5, 6}

# — 数学集合运算 —
print(a | b) # {1, 2, 3, 4, 5, 6} 并集（a.union(b)）
print(a & b) # {3, 4} 交集（a.intersection(b)）
print(a – b) # {1, 2} 差集（a.difference(b)）
print(b – a) # {5, 6}
print(a ^ b) # {1, 2, 5, 6} 对称差集（a.symmetric_difference(b)）

# — 集合关系 —
print(a <= b) # False a 是 b 的子集？(a.issubset(b))
print(a >= b) # False a 是 b 的超集？(a.issuperset(b))
print(a.isdisjoint({7, 8})) # True 没有交集？

# — 修改方法 —
s = {1, 2, 3}
s.add(4) # {1, 2, 3, 4} 添加元素
s.update([5, 6]) # {1, 2, 3, 4, 5, 6} 批量添加
s.remove(3) # 删除（元素不存在则 KeyError）
s.discard(3) # 删除（元素不存在也不报错！推荐）
s.pop() # 随机弹出一个元素（空集合则 KeyError）
s.clear() # 清空

# 集合的原地运算（以 _update 结尾）
a = {1, 2, 3}
a.intersection_update({2, 3, 4}) # a 变为 {2, 3}

🔑 要点总结：原地运算方法（如 intersection_update()）以 _update 结尾，直接修改原集合。discard() 比 remove() 更安全——元素不存在时不会报错。

9.3 集合的应用场景

💡 代码说明：集合在实际应用中最常见的三个场景：去重、快速成员检查（O(1)）、集合运算（找交集/差集）。frozenset 是不可变版本，可作为字典键：

# 1. 去重
numbers = [1, 2, 2, 3, 3, 3, 4]
unique = list(set(numbers)) # [1, 2, 3, 4]（顺序不保证）

# 保持顺序的去重（Python 3.7+）
unique_ordered = list(dict.fromkeys(numbers)) # [1, 2, 3, 4]

# 2. 成员检查（O(1) 比列表的 O(n) 快）
large_set = set(range(1000000))
print(500000 in large_set) # 非常快

# 3. 找共同元素
list1 = [1, 2, 3, 4]
list2 = [3, 4, 5, 6]
common = set(list1) & set(list2) # {3, 4}

# 4. Frozen Set（不可变集合，可作为字典的键）
fs = frozenset([1, 2, 3])
# fs.add(4) # ❌ AttributeError
d = {fs: "frozen"} # ✅ 可以作为键

🔑 要点总结：当需要频繁判断元素是否存在时，将列表转为集合可以大幅提升性能（从 O(n) 降到 O(1)）。保持顺序的去重可以用 dict.fromkeys() 实现。

10. 条件判断

10.1 if / elif / else

💡 代码说明：条件判断是程序流程控制的基础。Python 使用 if-elif-else 结构，注意每个条件后必须有冒号：

score = 85

if score >= 90:
grade = "A"
elif score >= 80:
grade = "B"
elif score >= 70:
grade = "C"
elif score >= 60:
grade = "D"
else:
grade = "F"

print(f"成绩等级: {grade}") # 成绩等级: B

# 简写（适合简单情况）
x = 10
status = "正数" if x > 0 else "非正数"
# 等价于:
# if x > 0:
# status = "正数"
# else:
# status = "非正数"

# 嵌套的三元运算符
y = 5
result = "大" if y > 10 else ("小" if y > 0 else "零或负")
print(result) # 小

🔑 要点总结：三元表达式 a if condition else b 适合简单的条件赋值。Python 3.10 之前用 elif 链替代 switch-case。

10.2 真值测试

Python 中以下值被视为 False（假值），其余为 True：

💡 代码说明：Python 中以下值被视为假：False、None、各种零值、空序列和空集合。其余所有值都是真。自定义类的真值由 bool() 或 len() 决定：

# 假值列表
falsy = [
False, # 布尔假
None, # 空值
0, # 整数零
0.0, # 浮点零
0j, # 复数零
"", # 空字符串
[], # 空列表
(), # 空元组
{}, # 空字典
set(), # 空集合
range(0), # 空范围
]

for value in falsy:
print(f"{value!r:10} -> {bool(value)}")

# 真值测试在条件判断中的应用
name = ""
if name:
print(f"你好，{name}")
else:
print("名称为空") # 输出这个

# 自定义类的真值：实现 __bool__() 或 __len__() 方法
class MyCollection:
def __init__(self, items):
self.items = items

def __len__(self):
return len(self.items)

c = MyCollection([])
print(bool(c)) # False

🔑 要点总结：利用真值测试可以写出简洁的代码：if name: 代替 if name != ‘’，if items: 代替 if len(items) > 0。这是 Pythonic 风格的体现。

10.3 match / case（Python 3.10+）

💡 代码说明：Python 3.10 引入的结构化模式匹配 match-case 比传统的 if-elif 更强大——支持多值匹配、序列解构、字典匹配和守卫条件：

# 类似其他语言的 switch
def describe(status_code):
match status_code:
case 200:
return "成功"
case 301 | 302: # 多个值
return "重定向"
case 404:
return "未找到"
case 500:
return "服务器错误"
case _: # 默认（通配符）
return "未知状态"

# 结构匹配（更强大的用法）
def process_point(point):
match point:
case (0, 0):
return "原点"
case (0, y):
return f"Y 轴, y={y}"
case (x, 0):
return f"X 轴, x={x}"
case (x, y) if x == y: # 带守卫条件
return f"在第一/三象限对角线上"
case (x, y):
return f"坐标 ({x}, {y})"

print(process_point((0, 0))) # 原点
print(process_point((0, 5))) # Y 轴, y=5
print(process_point((3, 3))) # 在第一/三象限对角线上
print(process_point((2, 5))) # 坐标 (2, 5)

# 匹配列表结构
def analyze_list(lst):
match lst:
case []:
return "空列表"
case [first, *rest]:
return f"首元素: {first}, 剩余: {rest}"

print(analyze_list([1, 2, 3])) # 首元素: 1, 剩余: [2, 3]

# 匹配字典结构
def analyze_dict(d):
match d:
case {"name": name, "age": age}:
return f"姓名: {name}, 年龄: {age}"
case {"name": name}:
return f"姓名: {name}, 年龄未知"
case _:
return "未知格式"

🔑 要点总结：match-case 不是简单的 switch 替代品——它是真正的模式匹配，能同时匹配结构并绑定变量。特别适合解析复杂数据结构、实现状态机等场景。

11. 循环语句

11.1 for 循环

💡 代码说明：for 循环是 Python 最常用的循环方式，可以遍历列表、字典、range 对象等任何可迭代对象：

# 遍历列表
fruits = ["苹果", "香蕉", "橙子"]
for fruit in fruits:
print(fruit)

# 遍历字典
user = {"name": "Alice", "age": 25}
for key, value in user.items():
print(f"{key}: {value}")

# 遍历范围
for i in range(5): # 0, 1, 2, 3, 4
print(i)

for i in range(2, 7): # 2, 3, 4, 5, 6 (start, stop)
print(i)

for i in range(0, 10, 2): # 0, 2, 4, 6, 8 (start, stop, step)
print(i)

for i in range(10, 0, –1): # 10, 9, 8, …, 1 倒序
print(i)

# 用 enumerate 获取索引
for i, fruit in enumerate(fruits, start=1):
print(f"{i}. {fruit}")

🔑 要点总结：range(start, stop, step) 生成整数序列，enumerate() 同时获取索引和值。Python 的 for 循环简洁而强大。

11.2 while 循环

💡 代码说明：while 循环在条件为真时反复执行。适合不知道循环次数的场景，或者实现无限循环+break 的模式：

# 基本 while 循环
count = 0
while count < 5:
print(count)
count += 1

# 使用标志的 while 循环
running = True
attempts = 0
while running:
attempts += 1
# … 处理逻辑 …
if attempts >= 3:
running = False

# 无限循环 + break
while True:
user_input = input("输入 'quit' 退出: ")
if user_input == "quit":
break
print(f"你输入了: {user_input}")

🔑 要点总结：注意防止无限循环——确保循环条件最终会变为 False，或者在循环体内使用 break 退出。while True + break 是一种常见的交互式程序模式。

11.3 循环控制

💡 代码说明：break 立即退出循环，continue 跳过当前迭代，pass 什么都不做只作占位。for…else 在循环正常结束（非 break 退出）时执行：

# break：立即退出整个循环
for i in range(10):
if i == 5:
break
print(i, end=" ") # 0 1 2 3 4

print() # 换行

# continue：跳过当前迭代，进入下一次
for i in range(10):
if i % 2 == 0:
continue
print(i, end=" ") # 1 3 5 7 9

print()

# pass：占位符，什么都不做
for i in range(5):
if i == 2:
pass # 以后再来处理
print(i, end=" ") # 0 1 2 3 4

print()

# for … else：循环正常结束时执行 else
for i in range(5):
print(i)
else:
print("循环正常结束") # 会执行

for i in range(5):
if i == 3:
break
else:
print("不会执行") # ← break 后不执行 else

# while … else 同样适用
n = 0
while n < 5:
n += 1
else:
print("while 正常结束") # 执行

🔑 要点总结：for…else 是 Python 特有的语法，特别适合搜索-未找到的模式：在循环中找到目标就 break，else 块处理未找到的情况。

11.4 循环技巧

💡 代码说明：利用 zip() 同时遍历多个序列、reversed() 反向遍历、sorted() 按排序遍历——这些技巧让你的循环代码更优雅：

# 遍历两个序列（zip）
names = ["Alice", "Bob", "Charlie"]
scores = [95, 87, 92]
for name, score in zip(names, scores):
print(f"{name}: {score}分")

# 反向遍历
for i in reversed(range(5)):
print(i, end=" ") # 4 3 2 1 0
print()

# 排序遍历
nums = [3, 1, 4, 1, 5]
for n in sorted(nums):
print(n, end=" ") # 1 1 3 4 5
print()

for n in sorted(nums, reverse=True):
print(n, end=" ") # 5 4 3 1 1
print()

🔑 要点总结：掌握这些内置函数，可以大幅减少循环中的索引操作，写出更 Pythonic 的代码。

12. 函数

12.1 定义与调用

💡 代码说明：使用 def 关键字定义函数，return 返回值。函数文档字符串（docstring）用三引号书写，可通过 doc 或 help() 查看：

# 基本函数
def greet(name):
"""向指定的人打招呼（函数文档字符串）"""
return f"你好，{name}！"

print(greet("Alice")) # 你好，Alice！
print(greet.__doc__) # 向指定的人打招呼（函数文档字符串）
help(greet) # 返回更详细的信息

# 多个参数
def add(a, b):
return a + b

# 无返回值：默认返回 None
def log_message(msg):
print(f"[LOG] {msg}")
# 隐式 return None

result = log_message("test")
print(result) # None

🔑 要点总结：Python 函数如果没有显式 return，默认返回 None。养成写 docstring 的好习惯，它能被 IDE 和 help() 识别。

12.2 参数类型

💡 代码说明：Python 函数支持四种参数类型：位置参数、默认参数、*args（可变位置参数）、**kwargs（可变关键字参数）。参数顺序必须严格按照这个顺序：

# — 位置参数 —
def power(base, exp):
return base ** exp

print(power(2, 3)) # 8（位置参数）
print(power(exp=3, base=2)) # 8（关键字参数）

# — 默认参数 —
def greet(name, greeting="你好"):
return f"{greeting}，{name}！"

print(greet("Alice")) # 你好，Alice！
print(greet("Bob", "早上好")) # 早上好，Bob！

# ⚠️ 默认参数的陷阱：不要用可变对象作为默认值！
def bad_append(item, lst=[]):
lst.append(item)
return lst

print(bad_append(1)) # [1]
print(bad_append(2)) # [1, 2] ← 累积了！默认列表是函数定义时创建的，每次调用共享

# ✅ 正确做法
def good_append(item, lst=None):
if lst is None:
lst = []
lst.append(item)
return lst

# — 可变参数 *args（位置参数） —
def my_sum(*args):
"""接受任意数量的位置参数"""
total = 0
for num in args:
total += num
return total

print(my_sum(1, 2)) # 3
print(my_sum(1, 2, 3, 4, 5)) # 15
print(my_sum()) # 0

# — 可变参数 **kwargs（关键字参数） —
def print_info(**kwargs):
"""接受任意数量的关键字参数"""
for key, value in kwargs.items():
print(f"{key}: {value}")

print_info(name="Alice", age=25, city="北京")
# name: Alice
# age: 25
# city: 北京

# — 所有参数类型组合 —
def all_params(pos1, pos2, *args, default="默认值", **kwargs):
"""
参数顺序（必须严格遵守）：
1. 位置参数（必填）
2. *args（可变位置）
3. 默认参数（关键字参数）
4. **kwargs（可变关键字）
"""
print(f"pos1: {pos1}")
print(f"pos2: {pos2}")
print(f"args: {args}")
print(f"default: {default}")
print(f"kwargs: {kwargs}")

all_params(1, 2, 3, 4, 5, default="自定义", name="Alice", age=25)

🔑 要点总结：最常见的陷阱是可变默认参数（如 def f(lst=[])）——默认值在函数定义时只创建一次，多次调用会共享！正确做法是用 None 作默认值，函数内再初始化。

12.3 仅限关键字参数

💡 代码说明：在参数列表中使用 * 可以强制后面的参数必须以关键字形式传递，提高代码可读性。/ 则相反，强制前面的参数只能按位置传递：

# * 之后的参数必须以关键字形式传递
def config(host, *, port=8080, debug=False):
print(f"host={host}, port={port}, debug={debug}")

config("localhost") # host=localhost, port=8080, debug=False
config("localhost", port=3000) # ✅
config("localhost", debug=True) # ✅
# config("localhost", 3000) # ❌ TypeError: 位置参数太多了

# 仅限位置参数（Python 3.8+）/ 之前的参数只能按位置传递
def func(a, b, /, c, d):
"""
a, b: 仅限位置参数（不能以关键字形式传递）
c, d: 可以是位置或关键字
"""
print(f"a={a}, b={b}, c={c}, d={d}")

func(1, 2, 3, 4) # ✅
func(1, 2, c=3, d=4) # ✅
# func(a=1, b=2, c=3, d=4) # ❌ TypeError: a 和 b 仅限位置

🔑 要点总结：仅限关键字参数让 API 设计更清晰——调用者必须显式写出参数名，减少参数顺序出错的可能。

12.4 参数解包

💡 代码说明：* 将列表/元组解包为位置参数，** 将字典解包为关键字参数。两种解包可以组合使用：

# 列表/元组解包为位置参数
def add(a, b, c):
return a + b + c

nums = [1, 2, 3]
print(add(*nums)) # 6 等价于 add(1, 2, 3)
print(add(*(4, 5, 6))) # 15

# 字典解包为关键字参数
def greet(name, age):
return f"{name} 今年 {age} 岁"

info = {"name": "Alice", "age": 25}
print(greet(**info)) # Alice 今年 25 岁

# 组合使用
def full_func(a, b, c, d, e):
return a + b + c + d + e

nums1 = [1, 2]
nums2 = {"d": 4, "e": 5}
print(full_func(*nums1, 3, **nums2)) # 15

🔑 要点总结：参数解包让你能动态地构建函数调用，在编写通用工具函数和转发调用时特别有用。

12.5 作用域与 global / nonlocal

💡 代码说明：Python 变量遵循 LEGB 查找规则（Local -> Enclosing -> Global -> Built-in）。使用 global 在函数内修改全局变量，nonlocal 修改外层函数的变量：

# — LEGB 规则（变量查找顺序）—
# L: Local — 函数内部
# E: Enclosing — 外层函数内部
# G: Global — 模块级别
# B: Built-in — 内置命名空间

x = "global" # 全局变量

def outer():
x = "enclosing" # 闭包变量

def inner():
x = "local" # 局部变量
print(f"inner: {x}") # local

inner()
print(f"outer: {x}") # enclosing

outer()
print(f"global: {x}") # global

# — global 关键字：在函数内修改全局变量 —
count = 0

def increment():
global count
count += 1

increment()
print(count) # 1

# — nonlocal 关键字：修改外层函数的变量 —
def make_counter():
count = 0

def counter():
nonlocal count # 使用外层的 count
count += 1
return count

return counter

c = make_counter()
print(c()) # 1
print(c()) # 2
print(c()) # 3

🔑 要点总结：尽量避免滥用 global——它会让代码难以理解和测试。nonlocal 在闭包中很有用，能让内部函数修改外层函数的局部变量。

12.6 闭包

💡 代码说明：闭包是函数式编程的核心概念——内部函数记住并访问其创建时的外层变量，即使外层函数已经返回：

# 闭包：内部函数记住了其创建时的环境
def make_multiplier(factor):
def multiplier(x):
return x * factor # factor 被"记住"了
return multiplier

double = make_multiplier(2)
triple = make_multiplier(3)

print(double(5)) # 10
print(triple(5)) # 15

# 查看闭包变量
print(double.__closure__[0].cell_contents) # 2

🔑 要点总结：闭包是实现装饰器、工厂函数和回调的基础。closure 属性可以查看闭包捕获的变量，有助于调试。

13. Lambda 表达式

Lambda 是创建小型匿名函数的语法，只能包含单个表达式。

💡 代码说明：闭包是函数式编程的核心概念——内部函数记住并访问其创建时的外层变量，即使外层函数已经返回：

# 语法: lambda 参数: 表达式

# 基本用法
add = lambda a, b: a + b
print(add(3, 5)) # 8

# 等价于
def add(a, b):
return a + b

# — 常见使用场景 —
# 1. sort() 的 key 参数
students = [
{"name": "Alice", "score": 85},
{"name": "Bob", "score": 92},
{"name": "Charlie", "score": 78},
]
students.sort(key=lambda s: s["score"], reverse=True)
print(students)
# [{'name': 'Bob', 'score': 92}, {'name': 'Alice', 'score': 85}, {'name': 'Charlie', 'score': 78}]

# 2. filter()：过滤序列
nums = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
even = list(filter(lambda x: x % 2 == 0, nums))
print(even) # [2, 4, 6, 8, 10]

# 3. map()：映射序列
squared = list(map(lambda x: x ** 2, nums))
print(squared) # [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

# 4. reduce()：累积（需要导入）
from functools import reduce
total = reduce(lambda acc, x: acc + x, nums)
print(total) # 55

# — Lambda vs 列表推导式 —
# 大部分情况下列表推导式更 Pythonic：

# 用 filter + lambda
even1 = list(filter(lambda x: x % 2 == 0, nums))

# 用列表推导式（推荐！）
even2 = [x for x in nums if x % 2 == 0]

# 用 map + lambda
squared1 = list(map(lambda x: x ** 2, nums))

# 用列表推导式（推荐！）
squared2 = [x ** 2 for x in nums]

🔑 要点总结：闭包是实现装饰器、工厂函数和回调的基础。closure 属性可以查看闭包捕获的变量，有助于调试。

14. 列表推导式与生成器表达式

14.1 列表推导式

💡 代码说明：列表推导式是 Python 的标志性特性，用 [expression for item in iterable if condition] 语法在一行内完成映射和过滤：

# 基本语法: [expression for item in iterable if condition]

nums = list(range(10))

# 基本
squares = [x ** 2 for x in nums]
print(squares) # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

# 带条件过滤
even_squares = [x ** 2 for x in nums if x % 2 == 0]
print(even_squares) # [0, 4, 16, 36, 64]

# if-else 表达式（注意位置）
parity = ["even" if x % 2 == 0 else "odd" for x in nums]
print(parity) # ['even', 'odd', 'even', 'odd', 'even', 'odd', 'even', 'odd', 'even', 'odd']

# 嵌套推导式
# 展平二维列表
matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
flattened = [num for row in matrix for num in row]
print(flattened) # [1, 2, 3, 4, 5, 6, 7, 8, 9]

# 等价于
flattened = []
for row in matrix:
for num in row:
flattened.append(num)

# 笛卡尔积
pairs = [(x, y) for x in range(3) for y in range(3)]
print(pairs)
# [(0, 0), (0, 1), (0, 2), (1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]

🔑 要点总结：列表推导式比传统的 for+append 更简洁高效（底层是 C 实现的）。但不要过度嵌套——超过两层的推导式会牺牲可读性。

14.2 生成器表达式

💡 代码说明：生成器表达式语法和列表推导式一样，只是用 () 替代 []。它惰性求值，适合处理海量数据：

# 语法和列表推导式一样，只是用 () 而不是 []
# 优势：惰性求值，节省内存（适合海量数据）

# 列表推导式：立即生成所有数据到内存
squares_list = [x ** 2 for x in range(1000000)] # 占用大量内存

# 生成器表达式：按需生成，几乎不占内存
squares_gen = (x ** 2 for x in range(1000000)) # 轻量级

# 迭代生成器
for i in squares_gen:
print(i)
if i > 50:
break # 只计算需要的部分

# sum/max/min 等可以直接接受生成器表达式
total = sum(x ** 2 for x in range(1000000)) # 不需要再写一层括号
print(total)

🔑 要点总结：当数据量很大（百万级）时，生成器表达式几乎不占内存。传递给 sum()、max() 等函数时，可以省略额外的括号。

14.3 字典推导式

💡 代码说明：字典推导式 {key: value for …} 快速创建或变换字典，是从两个列表创建映射表的绝佳方式：

# {key_expr: value_expr for item in iterable if condition}

# 基本
squares = {x: x**2 for x in range(5)}
print(squares) # {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

# 过滤
even_squares = {x: x**2 for x in range(10) if x % 2 == 0}
print(even_squares) # {0: 0, 2: 4, 4: 16, 6: 36, 8: 64}

# 从两个列表创建字典
keys = ["name", "age", "city"]
values = ["Alice", 25, "北京"]
info = {k: v for k, v in zip(keys, values)}
print(info) # {'name': 'Alice', 'age': 25, 'city': '北京'}

🔑 要点总结：结合 zip() 使用字典推导式，可以一行代码将两个列表变为字典。支持条件过滤，语法与列表推导式一致。

14.4 集合推导式

💡 代码说明：集合推导式 {expr for …} 自动去重，本质上就是花括号包裹的列表推导式：

# {expression for item in iterable if condition}

# 基本
squares_set = {x**2 for x in range(–5, 6)}
print(squares_set) # {0, 1, 4, 9, 16, 25} 自动去重

# 字符串去重并保持顺序（用字典推导式）
text = "abracadabra"
unique_chars = "".join(dict.fromkeys(text))
print(unique_chars) # "abrcd"

🔑 要点总结：集合推导式在需要去重的同时做变换时非常有用，比先建列表再转集合更高效。

15. 迭代器与生成器

15.1 可迭代对象 vs 迭代器

💡 代码说明：可迭代对象（Iterable）可以放进 for 循环，迭代器（Iterator）则是记住遍历位置的懒加载对象。用 iter() 从可迭代对象获取迭代器，next() 逐个取值：

# 可迭代对象 (Iterable)：实现了 __iter__() 方法
# 迭代器 (Iterator)：实现了 __iter__() 和 __next__() 方法

# 判断类型
from collections.abc import Iterable, Iterator

lst = [1, 2, 3]
print(isinstance(lst, Iterable)) # True （列表是可迭代对象）
print(isinstance(lst, Iterator)) # False （列表不是迭代器）

it = iter(lst)
print(isinstance(it, Iterator)) # True

# iter() 和 next()
it = iter(lst)
print(next(it)) # 1
print(next(it)) # 2
print(next(it)) # 3
# print(next(it)) # StopIteration 异常

🔑 要点总结：迭代器只能前进不能后退，遍历结束后再调用 next() 会抛出 StopIteration。这种一次性的特性让迭代器非常节省内存。

15.2 生成器函数（yield）

💡 代码说明：使用 yield 关键字的函数是生成器——每次 yield 暂停并返回值，下次调用 next() 时从暂停处继续。yield from 可以委托给子生成器：

# yield：暂停函数，返回值，下次从暂停处继续

# 基本生成器
def countdown(n):
print(f"开始倒计时: {n}")
while n > 0:
yield n
n -= 1
print("结束！")

for num in countdown(3):
print(f"倒计时: {num}")
# 开始倒计时: 3
# 倒计时: 3
# 倒计时: 2
# 倒计时: 1
# 结束！

# — 无限序列生成器 —
def fibonacci():
"""生成无限的斐波那契数列"""
a, b = 0, 1
while True:
yield a
a, b = b, a + b

fib = fibonacci()
print([next(fib) for _ in range(10)])
# [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]

# — yield from: 委托给子生成器 —
def flat_list(nested):
"""递归展平任意嵌套的列表"""
for item in nested:
if isinstance(item, list):
yield from flat_list(item) # Python 3.3+
else:
yield item

nested = [1, [2, 3], [4, [5, 6]]]
print(list(flat_list(nested))) # [1, 2, 3, 4, 5, 6]

# — 管道生成器 —
def read_lines(filename):
"""逐行读取文件"""
with open(filename, "r", encoding="utf-8") as f:
for line in f:
yield line.strip()

def filter_comments(lines):
"""过滤注释行"""
for line in lines:
if not line.startswith("#"):
yield line

# 使用
# valid_lines = filter_comments(read_lines("config.txt"))
# for line in valid_lines:
# print(line)

🔑 要点总结：生成器是实现流式处理、惰性计算的利器。yield from 在需要递归处理嵌套结构时特别有用，比如展平任意深度的嵌套列表。

15.3 send() 与双向通信

💡 代码说明：生成器不仅可以通过 yield 向外产出值，还可以通过 send() 接收外部传入的值，实现双向通信（协程的基础）：

# 生成器不仅可以产出值，还可以通过 send() 接收值
def running_average():
"""维持运行平均值的协程"""
total = 0
count = 0
average = None
while True:
# yield 的返回值是通过 send() 传入的值
x = yield average
if x is None:
break
total += x
count += 1
average = total / count

avg = running_average()
next(avg) # 启动生成器（推进到第一个 yield）
print(avg.send(10)) # 10.0
print(avg.send(20)) # 15.0
print(avg.send(30)) # 20.0
avg.close() # 关闭生成器

🔑 要点总结：send() 让生成器升级为协程。首次调用必须用 next() 或 send(None) 启动。用完后调用 close() 关闭生成器释放资源。

16. 装饰器

装饰器是一种在不修改原函数代码的情况下增强其功能的设计模式。

16.1 函数是一等公民

💡 代码说明：在 Python 中，函数是一等公民——可以赋值给变量、作为参数传递、作为返回值返回。这是理解装饰器的基础：

# Python 中函数是对象，可以赋给变量、作为参数、作为返回值
def greet(name):
return f"Hello, {name}"

# 赋值给变量
say_hello = greet
print(say_hello("Alice")) # Hello, Alice

# 作为参数传递
def call_twice(func, arg):
return func(arg), func(arg)

print(call_twice(greet, "Bob")) # ('Hello, Bob', 'Hello, Bob')

# 作为返回值（内部函数/闭包）
def make_greeting(prefix):
def greeting(name):
return f"{prefix}, {name}"
return greeting

hello = make_greeting("Hello")
print(hello("Charlie")) # Hello, Charlie

🔑 要点总结：正因为函数是一等公民，Python 才能优雅地实现装饰器、回调、高阶函数等函数式编程模式。

16.2 基本装饰器

💡 代码说明：装饰器本质上是一个接受函数、返回新函数的包装器。使用 @decorator 语法糖，@functools.wraps 保留原函数的元信息：

import functools
import time

# — 装饰器模式 —
def timer(func):
"""记录函数执行时间的装饰器"""
@functools.wraps(func) # 保留原函数的元信息
def wrapper(*args, **kwargs):
start = time.perf_counter()
result = func(*args, **kwargs)
elapsed = time.perf_counter() – start
print(f"{func.__name__} 执行耗时: {elapsed:.4f} 秒")
return result
return wrapper

# 使用装饰器（语法糖）
@timer
def slow_function(n):
"""一个耗时的函数"""
total = sum(i ** 2 for i in range(n))
return total

# 等价于: slow_function = timer(slow_function)
slow_function(1000000) # slow_function 执行耗时: 0.1234 秒

print(slow_function.__name__) # slow_function（被 @wraps 保留了）
print(slow_function.__doc__) # 一个耗时的函数

# 不带 @wraps 的话 __name__ 会变成 "wrapper"

🔑 要点总结：@functools.wraps(func) 至关重要——没有它，被装饰函数的 name 和 doc 会变成 wrapper 的信息。这是装饰器最常见也最容易忘记的细节。

16.3 带参数的装饰器

💡 代码说明：带参数的装饰器本质上是装饰器工厂——外层函数接收参数，返回真正的装饰器：

# 装饰器工厂：返回装饰器的函数
def retry(max_attempts=3, delay=1):
"""重试装饰器：函数失败后自动重试"""
def decorator(func):
@functools.wraps(func)
def wrapper(*args, **kwargs):
for attempt in range(1, max_attempts + 1):
try:
return func(*args, **kwargs)
except Exception as e:
if attempt == max_attempts:
raise # 最后一次尝试仍然失败则抛出异常
print(f"[重试 {attempt}/{max_attempts}] {e}")
time.sleep(delay)
return None
return wrapper
return decorator

@retry(max_attempts=3, delay=0.5)
def unstable_network_call():
import random
if random.random() < 0.7:
raise ConnectionError("网络连接失败")
return "成功"

# 尝试调用
# result = unstable_network_call()
# print(result)

🔑 要点总结：装饰器工厂比基本装饰器多一层嵌套。理解装饰器本质上是函数调用这一点，就不会对三层嵌套感到困惑。

16.4 常用装饰器

💡 代码说明：Python 内置了三个常用装饰器：@staticmethod（静态方法）、@classmethod（类方法）和 @property（属性访问控制）。@property 让你能用属性语法调用方法，同时保留验证逻辑：

# — @staticmethod: 静态方法 —
class MyClass:
@staticmethod
def helper():
"""不需要访问 self 或 cls"""
return "I'm a static method"

# — @classmethod: 类方法 —
class Person:
species = "Homo sapiens"

def __init__(self, name):
self.name = name

@classmethod
def from_birth_year(cls, name, birth_year):
"""工厂方法"""
return cls(f"{name} ({2026 – birth_year}岁)")

@classmethod
def get_species(cls):
return cls.species

# — @property: 属性装饰器 —
class Circle:
def __init__(self, radius):
self._radius = radius

@property
def radius(self):
"""getter"""
return self._radius

@radius.setter
def radius(self, value):
"""setter: 设置时添加验证"""
if value < 0:
raise ValueError("半径不能为负数")
self._radius = value

@radius.deleter
def radius(self):
"""deleter"""
del self._radius

@property
def area(self):
"""只读计算属性"""
return 3.14159 * self._radius ** 2

c = Circle(5)
print(c.radius) # 5（调用 getter，不需要 c.radius()）
print(c.area) # 78.53975
c.radius = 10 # 调用 setter（带验证）
# c.radius = -1 # 抛出 ValueError

🔑 要点总结：@property 是 Python 实现 getter/setter 的优雅方式——外部代码用 obj.attr 访问，内部自动调用相应方法。@classmethod 常用于实现工厂方法。

17. 模块与包

17.1 模块导入

💡 代码说明：Python 的模块系统通过 import 导入外部代码，支持多种导入方式和条件导入：

# — 导入方式 —
# 1. 导入整个模块
import math
print(math.sqrt(16)) # 4.0

# 2. 导入模块并起别名
import numpy as np
# arr = np.array([1, 2, 3])

# 3. 从模块导入特定函数/类
from math import sqrt, pi
print(sqrt(25)) # 5.0
print(pi) # 3.141592…

# 4. 从模块导入全部（不推荐，会污染命名空间）
# from math import *

# 5. 条件导入
try:
import ujson as json # 如果装了更快的版本
except ImportError:
import json # 使用标准库

# — 模块搜索路径 —
import sys
print(sys.path) # 模块搜索路径列表

# — 查看模块内容 —
import math
print(dir(math)) # 列出模块所有属性和方法
print(math.__doc__) # 模块文档
# help(math) # 在 REPL 中查看帮助

🔑 要点总结：推荐用 import module 或 from module import specific_item，避免 from module import *（会污染命名空间）。条件导入让代码在不同环境下自动适配。

17.2 包的结构

💡 代码说明：包是包含 init.py 的目录，用于组织多个模块。init.py 中可以定义 all 控制导出、导入子模块方便用户使用：

# 包是一个包含 __init__.py 文件的目录

# 典型包结构:
# my_package/
# ├── __init__.py # 包的初始化文件
# ├── core.py # 核心模块
# ├── utils/
# │ ├── __init__.py
# │ ├── helpers.py
# │ └── validators.py
# └── tests/
# ├── __init__.py
# └── test_core.py

# — __init__.py 示例 —
"""
my_package 包初始化
"""
# 控制 from my_package import * 导出的内容
__all__ = ["core_func", "utils"]

# 可在此处导入子模块，方便用户
from .core import core_func
from . import utils

# 包的版本
__version__ = "1.0.0"

🔑 要点总结：即使 init.py 为空文件也没关系，它的存在标志着该目录是一个 Python 包（Python 3.3+ 的隐式命名空间包除外）。

17.3 相对导入与绝对导入

💡 代码说明：在包内部，使用 .（当前目录）和 …（上级目录）进行相对导入。绝对导入从项目根目录开始：

# — 在包内部，使用相对导入 —
# 文件: my_package/utils/helpers.py

# 相对导入: . 表示当前目录，.. 表示上级目录
# from . import validators # 同目录
# from ..core import core_func # 上级目录的 core 模块

# 绝对导入: 从顶层开始
# from my_package.core import core_func

🔑 要点总结：包内部推荐使用相对导入（更灵活、不依赖项目名），对外公开的 API 使用绝对导入。

17.4 常用标准库模块

💡 代码说明：Python 标准库极其丰富，覆盖了操作系统接口、日期时间、JSON 处理、正则表达式、高级集合类和迭代工具等：

# — os: 操作系统接口 —
import os
print(os.name) # 'nt' (Windows) 或 'posix' (Linux/Mac)
print(os.getcwd()) # 当前工作目录
# os.listdir(".") # 列出目录内容
# os.mkdir("new_dir") # 创建目录
# os.remove("file.txt") # 删除文件
print(os.path.join("dir", "subdir", "file.txt")) # 跨平台路径拼接
print(os.path.exists("some_file.txt")) # 文件是否存在
print(os.path.dirname("/path/to/file.txt")) # /path/to
print(os.path.basename("/path/to/file.txt")) # file.txt

# — sys: 系统相关 —
import sys
print(sys.version) # Python 版本
print(sys.argv) # 命令行参数
# sys.exit(0) # 退出程序

# — random: 随机数 —
import random
print(random.random()) # [0.0, 1.0) 的随机浮点数
print(random.randint(1, 10)) # [1, 10] 的随机整数
print(random.choice([1, 2, 3])) # 随机选择一个元素
print(random.sample(range(100), 5)) # 随机选择5个不重复的元素
random.shuffle([1, 2, 3, 4, 5]) # 原地打乱列表
random.seed(42) # 设置随机种子（可复现）

# — datetime: 日期时间 —
from datetime import datetime, timedelta, date

now = datetime.now()
print(now) # 2026-07-21 14:30:00.123456
print(now.strftime("%Y-%m-%d %H:%M:%S")) # 2026-07-21 14:30:00
parsed = datetime.strptime("2026-07-21", "%Y-%m-%d")
print(parsed) # 2026-07-21 00:00:00

tomorrow = now + timedelta(days=1)
last_week = now – timedelta(weeks=1)
print(tomorrow)
print(last_week)

# — json: JSON 处理 —
import json

data = {"name": "Alice", "age": 25, "skills": ["Python", "JavaScript"]}
json_str = json.dumps(data, indent=2, ensure_ascii=False)
print(json_str)
parsed = json.loads(json_str)
print(parsed["name"]) # Alice

# — re: 正则表达式 —
import re

text = "联系方式: alice@example.com, bob_123@gmail.com"
emails = re.findall(r'[\\w.+-]+@[\\w-]+\\.[\\w.-]+', text)
print(emails) # ['alice@example.com', 'bob_123@gmail.com']

# — collections: 更多集合类型 —
from collections import Counter, defaultdict, OrderedDict, deque
# Counter / defaultdict 已在前面介绍

# deque: 双端队列（高效的两端操作）
dq = deque([1, 2, 3])
dq.append(4) # 右边添加 → deque([1, 2, 3, 4])
dq.appendleft(0) # 左边添加 → deque([0, 1, 2, 3, 4])
dq.pop() # 右边弹出 → 4
dq.popleft() # 左边弹出 → 0

# — itertools: 迭代器工具 —
import itertools

# 无限迭代器
print(list(itertools.islice(itertools.count(10, 2), 5))) # [10, 12, 14, 16, 18]
print(list(itertools.islice(itertools.cycle("ABC"), 6))) # ['A', 'B', 'C', 'A', 'B', 'C']

# 组合迭代器
print(list(itertools.product("AB", "12"))) # [('A', '1'), ('A', '2'), ('B', '1'), ('B', '2')]
print(list(itertools.permutations("ABC", 2))) # 排列: 6种
print(list(itertools.combinations("ABC", 2))) # 组合: 3种
print(list(itertools.combinations_with_replacement("ABC", 2))) # 有放回组合