Python基础语法教程
·
🐍 Python 基础语法这一篇就够了
适用版本: Python 3.8+
目标读者: 初学者及有一定基础想要系统复习的开发者
最后更新: 2026-07-21
目录
- Python 简介
- 环境搭建与第一个程序
- 变量与数据类型
- 运算符
- 字符串详解
- 列表（List）
- 元组（Tuple）
- 字典（Dictionary）
- 集合（Set）
- 条件判断
- 循环语句
- 函数
- Lambda 表达式
- 列表推导式与生成器表达式
- 迭代器与生成器
- 装饰器
- 模块与包
- 文件操作
- 异常处理
- 面向对象编程
- 常用内置函数
- 类型注解
- 虚拟环境与包管理
- 编码规范（PEP 8）
- 综合练习
1. Python 简介
1.1 什么是 Python？
Python 是一种高级、解释型、面向对象的编程语言，由 Guido van Rossum 于 1991 年发布。它以简洁易读的语法和强大的标准库而闻名。
1.2 Python 的特点
| 特点 | 说明 |
|---|---|
| 简洁易读 | 使用缩进表示代码块，语法接近自然语言 |
| 解释型语言 | 无需编译，逐行解释执行 |
| 动态类型 | 变量无需声明类型，运行时自动推断 |
| 跨平台 | 支持 Windows、macOS、Linux 等 |
| 丰富的库 | 拥有庞大的标准库和第三方生态 |
| 多范式 | 支持面向对象、过程式、函数式编程 |
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 推荐
| IDE | 特点 |
|---|---|
| VS Code | 免费、轻量、插件丰富（推荐） |
| PyCharm | 专业的 Python IDE，功能强大 |
| Jupyter Notebook | 适合数据分析和科学计算 |
| IDLE | Python 自带，入门够用 |
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 # 看起来是3x3矩阵
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 为什么使用元组？
- 不可变性保证数据不会被意外修改
- 作为字典的键（列表不能）
- 性能略优于列表
- 语义表达：暗示这是一组不应修改的数据（如坐标、RGB值）
💡 代码说明：元组不只是「不可变的列表」——它还可以作为字典键、利用 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))) # 有放回组合
# 过滤迭代器
print(list(itertools.compress("ABCD", [1, 0, 1, 0]))) # ['A', 'C']
print(list(itertools.dropwhile(lambda x: x < 3, [1, 2, 3, 4, 1, 2]))) # [3, 4, 1, 2]
print(list(itertools.takewhile(lambda x: x < 3, [1, 2, 3, 4, 1, 2]))) # [1, 2]
# 分组
data = [("a", 1), ("a", 2), ("b", 3), ("b", 4)]
for key, group in itertools.groupby(data, lambda x: x[0]):
print(key, "->", list(group))
# a -> [('a', 1), ('a', 2)]
# b -> [('b', 3), ('b', 4)]
# --- functools: 高阶函数 ---
from functools import reduce, partial, lru_cache
# partial: 固定部分参数
def power(base, exp):
return base ** exp
square = partial(power, exp=2) # 固定 exp=2
cube = partial(power, exp=3) # 固定 exp=3
print(square(5)) # 25
print(cube(5)) # 125
# lru_cache: 缓存函数结果（记忆化）
@lru_cache(maxsize=128)
def fibonacci(n):
"""计算斐波那契数（带缓存）"""
if n < 2:
return n
return fibonacci(n - 1) + fibonacci(n - 2)
print(fibonacci(100)) # 354224848179261915075（瞬间计算）
print(fibonacci.cache_info()) # CacheInfo(hits=98, misses=101, maxsize=128, currsize=101)
🔑 要点总结：标准库是 Python 的一大优势——自带电池。itertools 和 collections 是提高代码效率的两大利器，pathlib 是处理文件路径的现代化选择，建议优先使用。
18. 文件操作
18.1 基本读写
💡 代码说明：使用 open() 打开文件，配合 with 语句确保自动关闭。支持多种读取方式（全部、分块、单行、所有行、逐行迭代）和文件模式：
# --- 写入文件 ---
# 模式: 'w' (写), 'a' (追加), 'x' (排他创建)
with open("example.txt", "w", encoding="utf-8") as f:
f.write("Hello, World!\n")
f.write("这是第二行。\n")
f.writelines(["第三行\n", "第四行\n"])
# --- 读取文件 ---
# 模式: 'r' (读，默认)
with open("example.txt", "r", encoding="utf-8") as f:
# 方式1: 读取全部
content = f.read()
print(content)
with open("example.txt", "r", encoding="utf-8") as f:
# 方式2: 读取指定字符数
chunk = f.read(10)
print(chunk) # Hello, Wor
with open("example.txt", "r", encoding="utf-8") as f:
# 方式3: 读取单行
line = f.readline()
print(line) # Hello, World!
with open("example.txt", "r", encoding="utf-8") as f:
# 方式4: 读取所有行到列表
lines = f.readlines()
print(lines) # ['Hello, World!\n', '这是第二行。\n', ...]
with open("example.txt", "r", encoding="utf-8") as f:
# 方式5: 逐行迭代（推荐，内存友好）
for line in f:
print(line.strip())
# --- 文件模式 ---
# 'r' - 只读（文件必须存在）
# 'w' - 只写（文件存在则清空，不存在则创建）
# 'a' - 追加（文件存在则在末尾添加）
# 'x' - 排他创建（文件已存在则失败）
# 'r+' - 读写
# 'b' - 二进制模式（如 'rb', 'wb'）
# 't' - 文本模式（默认，如 'rt', 'wt'）
🔑 要点总结：逐行迭代（for line in f）是最推荐的大文件读取方式——不会一次性将整个文件加载到内存。始终使用 encoding=‘utf-8’ 避免编码问题。
18.2 上下文管理器（with 语句）
💡 代码说明：with 语句确保资源（如文件）在使用后自动释放，即使发生异常也不会泄漏。它等价于 try/finally 的语法糖：
# with 语句确保文件正确关闭，即使发生异常
# 等价于:
# f = open("file.txt")
# try:
# data = f.read()
# finally:
# f.close()
with open("example.txt", "r", encoding="utf-8") as f:
data = f.read()
# 文件在这里自动关闭（离开 with 块时）
# 同时操作多个文件
with open("source.txt", "r", encoding="utf-8") as src, \
open("dest.txt", "w", encoding="utf-8") as dst:
dst.write(src.read())
🔑 要点总结：任何需要获取-使用-释放模式的资源（文件、锁、连接）都应使用 with 语句，这是 Python 资源管理的最佳实践。
18.3 文件与目录操作
💡 代码说明：os 和 shutil 模块提供了文件和目录的增删改查操作。Python 3.4+ 的 pathlib.Path 提供了更面向对象的路径操作方式：
import os
import shutil
# --- 文件操作 ---
# 检查是否存在
print(os.path.exists("example.txt")) # True/False
print(os.path.isfile("example.txt")) # 是文件？
print(os.path.isdir("some_dir")) # 是目录？
# 获取文件信息
print(os.path.getsize("example.txt")) # 文件大小（字节）
print(os.path.getmtime("example.txt")) # 最后修改时间戳
# 重命名/移动
os.rename("old_name.txt", "new_name.txt")
# shutil.move("source.txt", "destination/")
# 复制文件
# shutil.copy("source.txt", "destination/")
# 删除文件
os.remove("example.txt")
# --- 目录操作 ---
# 创建目录
os.mkdir("single_dir") # 创建单层目录（父目录必须存在）
os.makedirs("parent/child/grandchild") # 递归创建多层目录
# 列出目录内容
entries = os.listdir(".")
for entry in entries:
print(entry)
# 递归遍历
for root, dirs, files in os.walk("."):
for file in files:
print(os.path.join(root, file))
# 删除目录
# os.rmdir("empty_dir") # 只能删除空目录
# shutil.rmtree("dir_path") # 递归删除整个目录树
# --- pathlib（Python 3.4+，面向对象的路径操作，推荐！）---
from pathlib import Path
p = Path("data") / "subdir" / "file.txt"
print(p) # data\subdir\file.txt (Windows)
print(p.name) # file.txt
print(p.stem) # file
print(p.suffix) # .txt
print(p.parent) # data\subdir
# 创建目录
Path("my_folder").mkdir(exist_ok=True)
Path("nested/deep/folder").mkdir(parents=True, exist_ok=True)
# 读写（Python 3.5+）
# text = Path("file.txt").read_text(encoding="utf-8")
# Path("output.txt").write_text("Hello", encoding="utf-8")
# 遍历目录
# for file in Path(".").glob("*.py"):
# print(file)
# for file in Path(".").rglob("*.py"): # 递归
# print(file)
🔑 要点总结：pathlib 比传统的 os.path 更直观——用 / 拼接路径、.read_text() 一行读取文件。建议在新项目中使用 pathlib 替代字符串路径操作。
18.4 CSV 与 JSON 文件
💡 代码说明：Python 内置的 csv 和 json 模块让结构化数据的读写变得简单。csv.DictReader 用列名访问数据，json.dump/load 处理 JSON：
import csv
import json
# --- CSV 读取 ---
with open("data.csv", "r", encoding="utf-8", newline="") as f:
reader = csv.reader(f)
for row in reader:
print(row)
# CSV 写入
with open("output.csv", "w", encoding="utf-8", newline="") as f:
writer = csv.writer(f)
writer.writerow(["姓名", "年龄", "城市"]) # 标题行
writer.writerows([ # 多行数据
["Alice", 25, "北京"],
["Bob", 30, "上海"],
])
# DictReader / DictWriter（使用列名）
# with open("data.csv", "r", encoding="utf-8") as f:
# reader = csv.DictReader(f)
# for row in reader:
# print(row["姓名"])
# --- JSON 读写 ---
data = {"users": [{"name": "Alice", "age": 25}, {"name": "Bob", "age": 30}]}
# 写入
with open("data.json", "w", encoding="utf-8") as f:
json.dump(data, f, indent=2, ensure_ascii=False)
# 读取
with open("data.json", "r", encoding="utf-8") as f:
loaded = json.load(f)
print(loaded["users"][0]["name"]) # Alice
🔑 要点总结：处理 CSV 时建议使用 DictReader/DictWriter，代码更易读。JSON 的 ensure_ascii=False 能正确显示中文，indent 参数让输出格式化。
19. 异常处理
19.1 try / except / else / finally
💡 代码说明：异常处理的核心结构：try 块放可能出错的代码，except 捕获特定异常，else 在无异常时运行，finally 无论如何都执行：
# --- 基本结构 ---
try:
num = int(input("请输入一个整数: "))
result = 100 / num
except ValueError as e: # 捕获特定异常
print(f"格式错误: {e}")
except ZeroDivisionError:
print("不能除以零！")
except (TypeError, OverflowError) as e: # 捕获多种异常
print(f"类型或溢出错误: {e}")
except Exception as e: # 捕获所有异常（基类）
print(f"未知错误: {e}")
else: # 无异常时执行
print(f"结果是: {result}")
finally: # 无论如何都执行
print("清理资源…")
# --- 常见异常类型 ---
# ValueError 值错误
# TypeError 类型错误
# KeyError 字典键不存在
# IndexError 索引越界
# AttributeError 对象没有该属性
# NameError 变量名不存在
# FileNotFoundError 文件未找到
# IOError I/O 错误
# ZeroDivisionError 除以零
# ImportError 导入失败
# RuntimeError 运行时错误
# StopIteration 迭代结束
# AssertionError 断言失败
🔑 要点总结：永远捕获最具体的异常类型，不要使用裸露的 except:（它会捕获 SystemExit 和 KeyboardInterrupt）。常见的异常类型有十多种，IDE 会帮你补全。
19.2 自定义异常
💡 代码说明：通过继承 Exception 创建自定义异常，可以携带更多上下文信息。raise … from … 建立异常链，保留原始错误信息：
# 自定义异常类
class ValidationError(Exception):
"""数据验证异常"""
def __init__(self, field, message="验证失败"):
self.field = field
self.message = message
super().__init__(f"{field}: {message}")
class InsufficientFundsError(Exception):
"""余额不足异常"""
def __init__(self, balance, amount):
self.balance = balance
self.amount = amount
super().__init__(
f"余额不足：当前余额 {balance}，需要 {amount}，"
f"差额 {amount - balance}"
)
# 使用自定义异常
def withdraw(balance, amount):
if amount > balance:
raise InsufficientFundsError(balance, amount)
return balance - amount
try:
withdraw(100, 200)
except InsufficientFundsError as e:
print(e)
# 异常链（raise ... from ...）
def process_file(filepath):
try:
with open(filepath, "r") as f:
return f.read()
except FileNotFoundError as e:
raise RuntimeError(f"处理文件 {filepath} 失败") from e
🔑 要点总结：自定义异常让错误信息更具体、更容易调试。异常链 from e 保留了原始错误的完整堆栈，是调试复杂系统的重要工具。
19.3 最佳实践
💡 代码说明：Python 社区推崇 EAFP（请求原谅比请求许可更容易）风格——先尝试，失败再处理——而不是 LBYL（三思而后行）的预检查风格：
# ❌ 不要这样做：泛泛捕获所有异常
# try:
# risky_operation()
# except: # 捕获包括 SystemExit、KeyboardInterrupt 等
# pass # 静默吞掉异常
# ✅ 正确做法
# try:
# risky_operation()
# except Exception as e: # 明确捕获 Exception
# logger.error(f"操作失败: {e}", exc_info=True)
# raise # 重新抛出或适当处理
# ✅ EAFP: Easier to Ask for Forgiveness than Permission
# 请求原谅比请求许可更容易（Python 风格）
# 先尝试，失败再处理
# def get_item(lst, index):
# try:
# return lst[index]
# except IndexError:
# return None
# ✅ LBYL: Look Before You Leap（其他语言风格）
# def get_item(lst, index):
# if 0 <= index < len(lst):
# return lst[index]
# return None
🔑 要点总结：EAFP 利用异常处理替代条件检查，代码更简洁，且在并发环境下更安全。但要注意：只捕获预期的异常，不要让 except 掩盖 bug。
20. 面向对象编程
20.1 类与对象
💡 代码说明：Python 使用 class 定义类，init 初始化实例，self 指向实例本身。类属性被所有实例共享，双下划线前缀触发名称改写实现私有：
class Person:
"""人类"""
# 类属性（所有实例共享）
species = "Homo sapiens"
# 实例初始化方法
def __init__(self, name, age):
# 实例属性
self.name = name # 公有属性
self.age = age
self._secret = None # 约定：受保护属性（单下划线）
self.__private = 0 # 名称改写：_Person__private
# 实例方法
def introduce(self):
return f"我叫{self.name}，今年{self.age}岁。"
# 字符串表示（给开发者看的）
def __repr__(self):
return f"Person(name='{self.name}', age={self.age})"
# 字符串表示（给用户看的，print 调用）
def __str__(self):
return f"{self.name} ({self.age}岁)"
# 创建实例
alice = Person("Alice", 25)
bob = Person("Bob", 30)
print(alice.introduce()) # 我叫Alice，今年25岁。
print(alice) # Alice (25岁) 调用 __str__
print(repr(alice)) # Person(name='Alice', age=25) 调用 __repr__
# 访问类属性
print(Person.species) # Homo sapiens
print(alice.species) # Homo sapiens（实例也可访问）
# 名称改写
# print(alice.__private) # ❌ AttributeError
print(alice._Person__private) # 0（可以绕过但不推荐）
🔑 要点总结：Python 没有真正的私有属性——双下划线前缀只是名称改写为 _ClassName__attr，这是一种约定而非强制。单下划线前缀 _attr 表示受保护，更多是给开发者看的提示。
20.2 继承
💡 代码说明：Python 支持单继承和多继承。子类可以重写父类方法，使用 isinstance() 和 issubclass() 检查继承关系：
class Animal:
def __init__(self, name):
self.name = name
def speak(self):
return "..."
class Dog(Animal):
def speak(self):
return "汪汪！"
def wag_tail(self):
return f"{self.name} 摇尾巴"
class Cat(Animal):
def speak(self):
return "喵喵！"
dog = Dog("旺财")
cat = Cat("咪咪")
print(dog.name, "说:", dog.speak()) # 旺财 说: 汪汪！
print(cat.name, "说:", cat.speak()) # 咪咪 说: 喵喵！
print(dog.wag_tail()) # 旺财 摇尾巴
# 检查继承关系
print(isinstance(dog, Dog)) # True
print(isinstance(dog, Animal)) # True
print(isinstance(dog, Cat)) # False
print(issubclass(Dog, Animal)) # True
# 多重继承
class Flyable:
def fly(self):
return "飞行中…"
class Swimmable:
def swim(self):
return "游泳中…"
class Duck(Animal, Flyable, Swimmable):
def speak(self):
return "嘎嘎！"
duck = Duck("唐老鸭")
print(duck.speak()) # 嘎嘎！
print(duck.fly()) # 飞行中…
print(duck.swim()) # 游泳中…
# MRO（方法解析顺序）
print(Duck.__mro__) # 查看方法搜索顺序
🔑 要点总结：多重继承在需要混入多个功能时很方便（如 Duck 同时继承 Animal、Flyable、Swimmable），但不要过度使用。MRO（方法解析顺序）决定了多继承时方法的查找路径。
20.3 super() 与父类调用
💡 代码说明：super() 用于调用父类的方法，在 init 和方法重写中特别常用。它遵循 MRO 顺序，在多重继承下也能正确工作：
class Employee:
def __init__(self, name, salary):
self.name = name
self.salary = salary
def work(self):
return f"{self.name} 正在工作"
def get_details(self):
return f"Name: {self.name}, Salary: {self.salary}"
class Manager(Employee):
def __init__(self, name, salary, department):
# 调用父类的 __init__
super().__init__(name, salary)
self.department = department
def work(self):
# 调用父类方法并扩展
base_result = super().work()
return f"{base_result}，管理 {self.department} 部门"
def get_details(self):
return f"{super().get_details()}, Dept: {self.department}"
mgr = Manager("Alice", 15000, "技术部")
print(mgr.work()) # Alice 正在工作，管理 技术部 部门
print(mgr.get_details()) # Name: Alice, Salary: 15000, Dept: 技术部
🔑 要点总结：重写父类方法时，通常应先调用 super().method()，然后再添加子类的特定逻辑——这样可以确保父类的初始化或预处理不被遗漏。
20.4 魔术方法（Magic / Dunder Methods）
💡 代码说明：魔术方法（双下划线包围的方法）让自定义类支持运算符重载、迭代、比较、上下文管理等语言特性。以下 Vector 类展示了常用的魔术方法：
class Vector:
def __init__(self, x, y):
self.x = x
self.y = y
# 字符串表示
def __repr__(self):
return f"Vector({self.x}, {self.y})"
# 算术运算
def __add__(self, other):
return Vector(self.x + other.x, self.y + other.y)
def __sub__(self, other):
return Vector(self.x - other.x, self.y - other.y)
def __mul__(self, scalar):
"""标量乘法"""
return Vector(self.x * scalar, self.y * scalar)
def __rmul__(self, scalar):
"""右侧乘法（scalar * vector）"""
return self.__mul__(scalar)
def __neg__(self):
return Vector(-self.x, -self.y)
def __abs__(self):
"""向量的模"""
return (self.x ** 2 + self.y ** 2) ** 0.5
# 比较运算
def __eq__(self, other):
return self.x == other.x and self.y == other.y
def __lt__(self, other):
"""按模长比较"""
return abs(self) < abs(other)
# 使对象可迭代
def __iter__(self):
return iter([self.x, self.y])
# 使对象可用 in 检查
def __contains__(self, value):
return value in (self.x, self.y)
# 使对象可调用
def __call__(self):
"""返回向量的模"""
return abs(self)
# 属性访问
def __getitem__(self, index):
if index == 0: return self.x
if index == 1: return self.y
raise IndexError("索引只能是 0 或 1")
def __len__(self):
return 2 # 总是返回 2
# 上下文管理器
def __enter__(self):
print(f"进入 Vector 上下文: {self}")
return self
def __exit__(self, exc_type, exc_val, exc_tb):
print(f"退出 Vector 上下文: {self}")
# --- 使用 ---
v1 = Vector(3, 4)
v2 = Vector(1, 2)
print(v1 + v2) # Vector(4, 6)
print(v1 - v2) # Vector(2, 2)
print(v1 * 3) # Vector(9, 12)
print(3 * v1) # Vector(9, 12)（__rmul__）
print(-v1) # Vector(-3, -4)
print(abs(v1)) # 5.0
print(v1 == Vector(3, 4)) # True
print(v1 < Vector(1, 1)) # False (5.0 > 1.414)
# 迭代
for coord in v1:
print(coord) # 3 4
print(3 in v1) # True
print(v1()) # 5.0（可调用）
print(v1[0], v1[1]) # 3 4
print(len(v1)) # 2
# 上下文管理器
with Vector(5, 12) as v:
print(f"处理中: {v}")
# 进入 Vector 上下文: Vector(5, 12)
# 处理中: Vector(5, 12)
# 退出 Vector 上下文: Vector(5, 12)
🔑 要点总结：魔术方法是 Python 数据模型的精髓——掌握了它们，你的类就能像内置类型一样自然地被使用。repr（给开发者）和 str（给用户）的区别是面试常考题。
20.5 @dataclass 数据类
💡 代码说明：Python 3.7+ 的 @dataclass 装饰器自动生成 init、repr、eq 等方法，大幅减少样板代码：
from dataclasses import dataclass, field
from typing import List
# Python 3.7+ 的 dataclass 自动生成 __init__、__repr__、__eq__ 等方法
@dataclass
class Point:
x: float
y: float
# 不需要手写 __init__ 和 __repr__！
# __eq__ 也自动生成
def distance_to_origin(self):
return (self.x ** 2 + self.y ** 2) ** 0.5
p1 = Point(3.0, 4.0)
p2 = Point(3.0, 4.0)
print(p1) # Point(x=3.0, y=4.0)
print(p1 == p2) # True（自动比较字段值）
print(p1.distance_to_origin()) # 5.0
# 更复杂的配置
@dataclass
class Student:
name: str
age: int
grades: List[float] = field(default_factory=list) # 默认值使用 factory
active: bool = True
def average_grade(self):
if not self.grades:
return 0.0
return sum(self.grades) / len(self.grades)
student = Student(name="Alice", age=20, grades=[85.0, 92.0, 78.0])
print(student) # Student(name='Alice', age=20, grades=[85.0, 92.0, 78.0], active=True)
print(student.average_grade()) # 85.0
🔑 要点总结：对于主要存储数据的类，@dataclass 是极佳选择。field(default_factory=list) 正确处理了可变默认值的问题，比手写 init 更安全。
21. 常用内置函数
21.1 类型相关
💡 代码说明：这些内置函数帮助检查类型（type/isinstance）、获取对象信息（id/dir/help）：
# type() - 获取类型
print(type(42)) # <class 'int'>
# isinstance() - 类型检查
print(isinstance(42, int)) # True
# id() - 获取对象内存地址
x = [1, 2, 3]
print(id(x)) # 某个整数地址
# dir() - 列出属性和方法
print(dir([])) # 列表的所有方法
# help() - 查看帮助
# help(str) # 在 REPL 中
🔑 要点总结：dir() 在探索陌生模块或对象时极其有用；id() 帮助理解对象标识（配合 is 使用）。
21.2 数学运算
💡 代码说明：Python 内置了常用数学函数：abs（绝对值）、round（四舍五入）、max/min（最值，支持 key 参数）、sum（求和）、pow（幂运算）、divmod（商和余数）：
# abs() - 绝对值
print(abs(-5)) # 5
# round() - 四舍五入
print(round(3.14159, 2)) # 3.14
# max() / min()
print(max(1, 5, 3)) # 5
print(min([3, 1, 4, 1, 5])) # 1
# max 的 key 参数
words = ["apple", "kiwi", "banana", "pear"]
print(max(words, key=len)) # banana
# sum()
print(sum([1, 2, 3, 4, 5])) # 15
print(sum([1, 2, 3], 10)) # 16（初始值 10）
# pow()
print(pow(2, 8)) # 256
print(pow(2, 8, 1000)) # 256（取模）
# divmod()
print(divmod(10, 3)) # (3, 1)
🔑 要点总结：max/min 的 key 参数非常强大——按长度找最长单词、按价格找最贵商品，一行搞定。sum 的第二个参数是初始值，默认为 0。
21.3 序列操作
💡 代码说明：序列操作内置函数：len（长度）、sorted（排序返回新列表）、reversed（反向）、enumerate（枚举）、zip（打包）、filter（过滤）、map（映射）、any/all（逻辑判断）：
# len() - 长度
print(len("hello")) # 5
print(len([1, 2, 3])) # 3
# sorted() - 排序（返回新列表）
nums = [3, 1, 4, 1, 5]
print(sorted(nums)) # [1, 1, 3, 4, 5]
print(sorted(nums, reverse=True)) # [5, 4, 3, 1, 1]
print(nums) # [3, 1, 4, 1, 5]（原列表不变）
# reversed() - 反向迭代器
for i in reversed([1, 2, 3]):
print(i) # 3, 2, 1
# range() - 范围
print(list(range(5))) # [0, 1, 2, 3, 4]
# enumerate() - 枚举
for i, v in enumerate(['a', 'b', 'c'], start=1):
print(f"{i}: {v}") # 1: a, 2: b, 3: c
# zip() - 打包
a = [1, 2, 3]
b = ['a', 'b', 'c']
print(list(zip(a, b))) # [(1, 'a'), (2, 'b'), (3, 'c')]
# filter() - 过滤
nums = [1, 2, 3, 4, 5, 6]
evens = list(filter(lambda x: x % 2 == 0, nums))
print(evens) # [2, 4, 6]
# map() - 映射
squared = list(map(lambda x: x**2, nums))
print(squared) # [1, 4, 9, 16, 25, 36]
# any() / all()
print(any([False, False, True])) # True（至少一个为真）
print(all([True, True, False])) # False（必须全部为真）
🔑 要点总结：sorted() 不改变原序列，any() 和 all() 在条件检查中非常实用。filter 和 map 返回迭代器（不是列表），需要用 list() 转换或直接遍历。
21.4 输入输出
💡 代码说明：print() 的 sep 和 end 参数可以定制输出格式，file 参数可以将输出重定向到文件：
# print() - 打印
print("Hello", "World", sep=" | ", end="!!!\n")
# Hello | World!!!
# 写入文件
# with open("log.txt", "w") as f:
# print("错误信息", file=f)
# input() - 用户输入
# name = input("请输入姓名: ")
# print(f"你好，{name}")
# open() - 打开文件
# f = open("file.txt", "r", encoding="utf-8")
🔑 要点总结：print() 的可定制性远超想象——sep 控制分隔符、end 控制结尾字符、file 可重定向输出。input() 读取用户输入，总是返回字符串。
21.5 其他常用函数
💡 代码说明：其他高频函数包括：hasattr/getattr/setattr/delattr（动态操作属性）、callable（判断可调用）、ord/chr（字符编码转换）、bin/oct/hex（进制转换）、eval/exec（动态执行）：
# --- 对象相关 ---
# hasattr() / getattr() / setattr() / delattr()
class Person:
def __init__(self, name):
self.name = name
p = Person("Alice")
print(hasattr(p, "name")) # True
print(getattr(p, "name")) # "Alice"
print(getattr(p, "age", "未知")) # "未知"（默认值）
setattr(p, "age", 25) # 等价于 p.age = 25
delattr(p, "age") # 等价于 del p.age
# callable() - 判断是否可调用
print(callable(print)) # True
print(callable("hello")) # False
# --- 字符串转换 ---
# repr() / ascii()
print(repr("Hello\nWorld")) # "Hello\nWorld"（开发者表示）
print(ascii("你好")) # '你好'
# ord() / chr() - 字符与 Unicode 码点
print(ord('A')) # 65
print(ord('中')) # 20013
print(chr(65)) # 'A'
print(chr(20013)) # '中'
# bin() / oct() / hex() - 进制转换
print(bin(10)) # '0b1010'
print(oct(10)) # '0o12'
print(hex(255)) # '0xff'
# --- 迭代工具 ---
# iter() / next()
it = iter([1, 2, 3])
print(next(it)) # 1
# --- 编译/执行 ---
# compile() / exec() / eval() - 动态执行代码（注意安全风险）
result = eval("1 + 2 * 3") # 7（计算表达式）
# exec("print('Hello from exec')") # 执行代码块
# --- 全局/局部命名空间 ---
# globals() / locals() - 返回命名空间字典
x = 42
print(globals()['x']) # 42
🔑 要点总结：getattr(obj, attr, default) 在不确定属性是否存在时非常安全。eval() 执行表达式、exec() 执行代码块，但需谨慎使用——执行不可信的输入有安全风险。
22. 类型注解
Python 是动态类型语言，但从 3.5+ 开始支持类型注解（Type Hints），帮助 IDE 和工具做静态检查。
22.1 基本类型注解
💡 代码说明：Python 类型注解使用 变量: 类型 语法，函数注解使用 def func(arg: Type) -> ReturnType。注解不强制类型，但能帮助 IDE 和 mypy 做静态检查：
# 变量注解
name: str = "Alice"
age: int = 25
price: float = 3.99
is_active: bool = True
# 函数注解
def greet(name: str) -> str:
return f"Hello, {name}"
def divide(a: float, b: float) -> float:
if b == 0:
raise ValueError("除数不能为零")
return a / b
# 参数默认值
def repeat(text: str, times: int = 1) -> str:
return text * times
🔑 要点总结：类型注解是可选的，但越来越多的项目开始使用它们。结合 VS Code / PyCharm，类型注解能提供更好的代码补全和错误提示。
22.2 复杂类型注解
💡 代码说明：使用 typing 模块（或 Python 3.10+ 新语法）可以注解容器类型、可选类型、联合类型、回调函数、字面量类型和结构化字典等复杂场景：
from typing import (
List, Dict, Set, Tuple, Optional, Union,
Callable, Any, Sequence, Iterable, Literal, TypedDict
)
# 容器类型
def process_numbers(nums: List[int]) -> Dict[int, int]:
return {n: n ** 2 for n in nums}
def matrix_multiply(a: List[List[float]], b: List[List[float]]) -> List[List[float]]:
# ...
pass
# 元组（固定长度）
point: Tuple[float, float] = (3.0, 4.0)
record: Tuple[str, int, bool] = ("Alice", 25, True)
# Optional: 可以是某类型或 None
def find_user(user_id: int) -> Optional[Dict[str, Any]]:
# 可能返回 None
pass
# Union: 多种类型中之一（Python 3.10+ 可用 X | Y）
def parse_value(value: str) -> Union[int, float, str]:
try:
return int(value)
except ValueError:
try:
return float(value)
except ValueError:
return value
# Python 3.10+ 新语法（推荐）
def parse_value_v2(value: str) -> int | float | str:
pass
# Optional 的新写法（Python 3.10+）
def maybe_get_name() -> str | None:
pass
# Callable: 函数类型
def apply(func: Callable[[int, int], int], a: int, b: int) -> int:
return func(a, b)
# Any: 任意类型（禁用类型检查）
def flexible(data: Any) -> Any:
return data
# Literal: 字面量类型
def set_mode(mode: Literal["read", "write", "append"]) -> None:
pass
set_mode("read") # ✅
# set_mode("delete") # ❌ 类型检查器会报错
# TypedDict: 带类型的字典
class User(TypedDict):
name: str
age: int
email: str | None
def create_user(data: User) -> None:
print(data["name"])
🔑 要点总结：Python 3.10+ 推荐使用 int | None 替代 Optional[int]，int | str 替代 Union[int, str]——更简洁直观。Literal 限定参数的合法值，让类型检查更精确。
22.3 自定义泛型
💡 代码说明：使用 TypeVar 创建类型变量，实现泛型函数和泛型类——让类型检查器能根据输入推断输出的具体类型：
from typing import TypeVar, Generic
T = TypeVar('T') # 类型变量
def first(items: List[T]) -> T | None:
"""返回列表第一个元素，保持类型"""
return items[0] if items else None
a: int = first([1, 2, 3]) # 类型检查器知道返回 int
b: str = first(["a", "b", "c"]) # 类型检查器知道返回 str
# 泛型类
K = TypeVar('K')
V = TypeVar('V')
class Stack(Generic[T]):
def __init__(self) -> None:
self._items: List[T] = []
def push(self, item: T) -> None:
self._items.append(item)
def pop(self) -> T | None:
return self._items.pop() if self._items else None
int_stack = Stack[int]()
int_stack.push(1)
int_stack.push(2)
# int_stack.push("hello") # ❌ 类型检查器会报错
🔑 要点总结：泛型在编写可复用的容器类（如 Stack、Queue）和工具函数时特别有用——既保持类型安全，又不失灵活性。
23. 虚拟环境与包管理
23.1 venv 虚拟环境
# 创建虚拟环境
python -m venv myenv
# 激活虚拟环境
# Windows:
myenv\Scripts\activate
# macOS/Linux:
# source myenv/bin/activate
# 退出虚拟环境
deactivate
23.2 pip 包管理
# 安装包
pip install requests
pip install pandas==2.0.3 # 安装特定版本
pip install "django>=4.0,<5.0" # 版本范围
# 升级包
pip install --upgrade requests
# 卸载包
pip uninstall requests
# 列出已安装的包
pip list
pip list --outdated # 列出可升级的包
# 显示包详情
pip show requests
# 依赖管理
pip freeze > requirements.txt # 导出依赖
pip install -r requirements.txt # 安装依赖
# 搜索包
# pip search <keyword> # 已在 PyPI 网站搜索
23.3 requirements.txt 示例
# requirements.txt
requests>=2.28,<3.0
numpy==1.24.3
pandas>=2.0
flask>=2.3
python-dotenv>=1.0
black>=23.0 # 代码格式化
pylint>=2.17 # 代码检查
pytest>=7.4 # 测试框架
24. 编码规范（PEP 8）
24.1 缩进与空白
💡 代码说明：PEP 8 规定使用 4 空格缩进、每行最多 79 字符、运算符两侧加空格、函数和类之间空两行：
# ✅ 使用 4 个空格缩进（不要用 Tab）
def my_function():
if condition:
do_something()
# ❌ 不要混用 Tab 和空格
# ❌ 不要用 2 个或 8 个空格
# 每行最多 79 个字符（文档/注释 72）
# 操作符两边各加一个空格
x = 1 + 2
y = x * 3
# 函数和类之间空两行
# 方法之间空一行
🔑 要点总结：遵循 PEP 8 让你和团队其他成员的代码风格一致。可以用 black 工具自动格式化，省去手动调整的麻烦。
24.2 命名约定
💡 代码说明：Python 社区遵循一致的命名约定：函数/变量用 snake_case，类用 PascalCase，常量全大写，私有属性前缀单下划线：
# 包/模块: 简短小写，可用下划线
# my_package, utils
# 函数/方法/变量: 小写 + 下划线
def calculate_average(numbers):
total_sum = 0
return total_sum / len(numbers)
# 类: 大驼峰
class ShoppingCart:
pass
# 异常: 类名 + Error
class ValidationError(Exception):
pass
# 常量: 全大写 + 下划线
MAX_CONNECTIONS = 100
DEFAULT_TIMEOUT = 30
# 私有属性/方法: 前缀单下划线
class MyClass:
def __init__(self):
self._internal_data = {}
def _private_method(self):
pass
# 避免名称改写: 后缀单下划线
# class_（class 是关键字）
# list_（list 是内置函数）
🔑 要点总结：一致的命名让代码意图一目了然——MAX_SIZE 一眼就是常量，_internal 表示内部使用，ValidationError 一看就是异常类。
24.3 导入顺序
💡 代码说明：import 语句应按标准库 -> 第三方库 -> 本地模块的顺序排列，每组之间空一行：
# 1. 标准库
import os
import sys
# 2. 第三方库
import numpy as np
import requests
# 3. 本地模块
from .utils import helper
from mypackage.core import core_func
🔑 要点总结：isort 工具可以自动按此规则排序 import 语句，一劳永逸。
24.4 注释与文档字符串
💡 代码说明：好的注释说明为什么而不是做了什么。文档字符串用三引号，推荐 Google 风格或 NumPy 风格的格式：
# 单行注释：说明代码意图（不说明做了什么，而是为什么这么做）
# 复杂正则表达式: 匹配 Email 地址 (RFC 5322)
email_pattern = r'...'
# 文档字符串: 三引号
def fetch_data(url: str, timeout: int = 10) -> dict | None:
"""
从指定 URL 获取 JSON 数据。
Args:
url: API 地址
timeout: 超时时间（秒）
Returns:
成功时返回解析后的字典，失败返回 None
Raises:
ValueError: URL 格式不正确
requests.RequestException: 网络请求失败
"""
pass
🔑 要点总结：Args:、Returns:、Raises: 是文档字符串的标准字段，IDE 和文档生成工具（如 Sphinx）能识别并自动生成漂亮的 API 文档。
24.5 代码格式化工具
# Black: 自动代码格式化
pip install black
black my_script.py
# isort: 自动排序 import 语句
pip install isort
isort my_script.py
# Flake8 / Pylint: 代码质量检查
pip install flake8 pylint
flake8 my_script.py
pylint my_script.py
# mypy: 静态类型检查
pip install mypy
mypy my_script.py
25. 综合练习
练习 1：学生成绩管理系统
💡 代码说明：综合运用类与对象、字典操作、列表推导式、排序等知识，实现一个完整的学生成绩管理系统。包含添加学生、记录成绩、计算平均分、排名和生成报告等功能：
"""
学生成绩管理系统
功能:
1. 添加学生及其成绩
2. 计算平均分
3. 查找最高分学生
4. 按成绩排序
"""
class StudentGradeManager:
def __init__(self):
self.students: dict[str, list[float]] = {}
def add_student(self, name: str) -> None:
"""添加学生"""
if name not in self.students:
self.students[name] = []
print(f"已添加学生: {name}")
else:
print(f"学生 {name} 已存在")
def add_grade(self, name: str, grade: float) -> None:
"""添加成绩"""
if 0 <= grade <= 100:
self.students.setdefault(name, [])
self.students[name].append(grade)
print(f"{name} 的成绩 {grade} 已记录")
else:
raise ValueError("成绩必须在 0-100 之间")
def get_average(self, name: str) -> float | None:
"""获取学生平均分"""
grades = self.students.get(name)
return sum(grades) / len(grades) if grades else None
def get_overall_average(self) -> float:
"""获取全班平均分"""
all_grades = [
grade
for grades in self.students.values()
for grade in grades
]
return sum(all_grades) / len(all_grades) if all_grades else 0.0
def top_student(self) -> tuple[str, float] | None:
"""获取平均分最高的学生"""
if not self.students:
return None
return max(
((name, self.get_average(name)) for name in self.students),
key=lambda x: x[1]
)
def rank_students(self) -> list[tuple[str, float]]:
"""按平均分从高到低排名"""
ranked = [
(name, self.get_average(name))
for name in self.students
]
return sorted(ranked, key=lambda x: x[1], reverse=True)
def report(self) -> str:
"""生成成绩报告"""
lines = ["=" * 40, "学生成绩报告", "=" * 40]
for name in self.students:
avg = self.get_average(name)
grades = self.students[name]
lines.append(
f"{name}: 成绩 {grades}, 平均分 {avg:.1f}"
)
lines.append("-" * 40)
lines.append(f"全班平均分: {self.get_overall_average():.1f}")
top = self.top_student()
if top:
lines.append(f"最高分学生: {top[0]} ({top[1]:.1f})")
return "\n".join(lines)
# --- 使用示例 ---
if __name__ == "__main__":
mgr = StudentGradeManager()
# 添加学生和成绩
mgr.add_student("Alice")
mgr.add_student("Bob")
mgr.add_student("Charlie")
mgr.add_grade("Alice", 85)
mgr.add_grade("Alice", 92)
mgr.add_grade("Bob", 78)
mgr.add_grade("Bob", 83)
mgr.add_grade("Charlie", 95)
mgr.add_grade("Charlie", 88)
# 打印报告
print(mgr.report())
print(f"\n排名: {mgr.rank_students()}")
🔑 要点总结：这个练习涵盖了 Python 基础语法的方方面面——面向对象设计、数据结构选择、异常处理、列表推导式、条件判断等。建议先理解代码结构，再动手自己实现一遍。
练习 2：装饰器练习 — 实现 API 限流
💡 代码说明：这是一个实战级别的装饰器练习——实现 API 调用频率限制（Rate Limiting）。利用闭包保存调用历史，在超限时抛出异常：
import time
from functools import wraps
from collections import defaultdict
def rate_limit(max_calls: int, period: float):
"""
限流装饰器：在指定时间周期内限制函数调用次数
Args:
max_calls: 最大调用次数
period: 时间周期（秒）
"""
calls = defaultdict(list) # {函数名: [调用时间列表]}
def decorator(func):
@wraps(func)
def wrapper(*args, **kwargs):
now = time.time()
func_name = func.__name__
# 清理过期的调用记录
calls[func_name] = [
t for t in calls[func_name]
if now - t < period
]
# 检查是否超出限制
if len(calls[func_name]) >= max_calls:
wait_time = period - (now - calls[func_name][0])
raise RuntimeError(
f"API 限流：在 {period} 秒内最多调用 {max_calls} 次。"
f"请等待 {wait_time:.1f} 秒。"
)
# 记录调用时间
calls[func_name].append(now)
return func(*args, **kwargs)
return wrapper
return decorator
# --- 使用 ---
@rate_limit(max_calls=3, period=5)
def api_call(endpoint: str) -> str:
"""模拟 API 调用"""
return f"API 响应: {endpoint}"
# 测试
if __name__ == "__main__":
for i in range(5):
try:
result = api_call(f"/users/{i}")
print(result)
except RuntimeError as e:
print(f"错误: {e}")
time.sleep(0.5)
🔑 要点总结：这个限流装饰器展示了装饰器的实际应用价值——将横切关注点（限流）从业务逻辑（API 调用）中干净地分离出来。理解了这个例子，装饰器的核心思想就掌握了。
练习 3：生成器练习 — 文件解析
💡 代码说明：使用生成器和正则表达式，实现一个日志文件解析器。通过 yield 逐行产出解析结果，再用管道式生成器进行过滤和统计：
"""
解析日志文件并提取特定模式的数据
"""
def parse_log_file(filepath: str):
"""
逐行读取日志文件，解析为结构化数据
日志格式: [2026-07-21 14:30:00] [INFO] User Alice logged in
"""
import re
# 日志行正则
pattern = re.compile(
r'\[(?P<timestamp>[^\]]+)\]\s+'
r'\[(?P<level>[A-Z]+)\]\s+'
r'(?P<message>.+)'
)
with open(filepath, 'r', encoding='utf-8') as f:
for line_num, line in enumerate(f, start=1):
line = line.strip()
if not line:
continue
match = pattern.match(line)
if match:
yield {
'line': line_num,
'timestamp': match.group('timestamp'),
'level': match.group('level'),
'message': match.group('message'),
}
else:
yield {
'line': line_num,
'raw': line,
'error': '解析失败',
}
def filter_errors(records):
"""过滤出 ERROR 级别的记录"""
for record in records:
if record.get('level') == 'ERROR':
yield record
def count_by_level(records):
"""按日志级别统计"""
from collections import Counter
return Counter(record.get('level', 'PARSE_ERROR') for record in records)
# 创建测试日志文件
def create_test_log():
log_content = """[2026-07-21 10:00:00] [INFO] Application started
[2026-07-21 10:00:05] [DEBUG] Loading config file
[2026-07-21 10:00:10] [INFO] Server listening on port 8080
[2026-07-21 10:01:00] [WARNING] Memory usage exceeds 80%
[2026-07-21 10:02:00] [ERROR] Connection timeout: database
[2026-07-21 10:02:30] [ERROR] Failed to send email notification
[2026-07-21 10:03:00] [INFO] Retry successful
[2026-07-21 10:05:00] [INFO] Application shutdown
malformed line without proper format
"""
with open("test_log.txt", "w", encoding="utf-8") as f:
f.write(log_content)
if __name__ == "__main__":
create_test_log()
# 解析日志
records = list(parse_log_file("test_log.txt"))
# 统计
print("=== 日志统计 ===")
counter = count_by_level(records)
for level, count in counter.items():
print(f" {level}: {count} 条")
# 显示错误
print("\n=== 错误日志 ===")
for error in filter_errors(records):
print(f" 行 {error['line']}: {error['message']}")
🔑 要点总结：生成器管道模式（parse -> filter -> analyze）在处理大文件时特别有价值——每一行只被处理一次，数据流式经过各个处理环节，几乎不占内存。建议将此模式用于实际的日志分析任务中。
附录 A：Python 内置异常层级
BaseException
├── SystemExit
├── KeyboardInterrupt
├── GeneratorExit
└── Exception
├── StopIteration
├── StopAsyncIteration
├── ArithmeticError
│ ├── FloatingPointError
│ ├── OverflowError
│ └── ZeroDivisionError
├── AssertionError
├── AttributeError
├── BufferError
├── EOFError
├── ImportError
│ └── ModuleNotFoundError
├── LookupError
│ ├── IndexError
│ └── KeyError
├── MemoryError
├── NameError
│ └── UnboundLocalError
├── OSError
│ ├── BlockingIOError
│ ├── ChildProcessError
│ ├── ConnectionError
│ ├── FileExistsError
│ ├── FileNotFoundError
│ ├── InterruptedError
│ ├── IsADirectoryError
│ ├── NotADirectoryError
│ ├── PermissionError
│ ├── ProcessLookupError
│ └── TimeoutError
├── ReferenceError
├── RuntimeError
│ ├── NotImplementedError
│ └── RecursionError
├── SyntaxError
│ └── IndentationError
│ └── TabError
├── SystemError
├── TypeError
├── ValueError
│ └── UnicodeError
└── Warning
附录 B：推荐学习资源
在线资源
| 资源 | 说明 | 链接 |
|---|---|---|
| Python 官方文档 | 权威参考，中文版 | docs.python.org/zh-cn |
| 菜鸟教程 | 中文入门教程 | runoob.com/python3 |
| Real Python | 英文高质量教程 | realpython.com |
| LeetCode | 编程练习 | leetcode.cn |
| PyPI | Python 包索引 | pypi.org |
推荐书籍
- 《Python 编程：从入门到实践》 - Eric Matthes（入门首选）
- 《流畅的 Python》 - Luciano Ramalho（深入理解 Python）
- 《Python Cookbook》 - David Beazley（实战技巧）
- 《Effective Python》 - Brett Slatkin（最佳实践）
📝 学习建议
- 动手实践：每学一个概念，立即写代码验证
- 阅读错误信息：Python 的错误信息很友好，仔细阅读
- 善用 REPL：交互式解释器是测试小段代码的最佳工具
- 阅读优秀代码：在 GitHub 上找高质量的 Python 项目学习
- 做项目驱动：找一个感兴趣的小项目，边做边学
本教程由 AI 辅助生成，内容覆盖 Python 3.8+ 核心语法。如有疏漏，欢迎指正！
更多推荐
36
0- 0
已为社区贡献1条内容
所有评论(0)