Python核心语法与常用代码自测清单

Python 以简洁、易读和强大的生态著称，但“会用”和“用得好”之间往往隔着大量细节。很多开发者能写出可运行的代码，却在边界条件、类型行为、作用域规则、并发模型等地方反复踩坑。本文整理了一套覆盖核心语法与常用实践的代码自测清单，每个知识点都配有示例与要点解析。你可以把它当作一次系统性的“语法体检”，也可以作为面试前的快速复习材料。

一、数据类型与运算：别在小地方翻车

1. 可变类型与不可变类型

Python 中一切皆对象，但对象分可变与不可变。不可变类型包括 int、float、str、tuple、frozenset；可变类型包括 list、dict、set、自定义对象。

a = [1, 2, 3]
b = a
b.append(4)
print(a)  # [1, 2, 3, 4]
x = "hello"
y = x
y += " world"
print(x)  # hello

要点：赋值传递的是对象引用。对可变对象的“修改”会影响所有引用方；对不可变对象的“修改”实际是创建新对象。函数默认参数使用可变对象是经典陷阱：

def add_item(item, bucket=[]):
    bucket.append(item)
    return bucket
print(add_item(1))  # [1]
print(add_item(2))  # [1, 2]，而非 [2]

正确做法是使用 None 作为默认值，在函数体内初始化。

2. 深浅拷贝

import copy
origin = [[1, 2], [3, 4]]
shallow = copy.copy(origin)
deep = copy.deepcopy(origin)
shallow[0].append(99)
print(origin)  # [[1, 2, 99], [3, 4]]
print(deep)    # [[1, 2], [3, 4]]

要点：浅拷贝只复制最外层容器，内部嵌套对象仍共享引用；深拷贝递归复制所有层级。处理嵌套结构时优先考虑深拷贝，但要注意循环引用与性能开销。

3. 数值与精度

print(0.1 + 0.2 == 0.3)  # False
from decimal import Decimal
print(Decimal("0.1") + Decimal("0.2") == Decimal("0.3"))  # True

要点：浮点数遵循二进制浮点表示，涉及金额、精确比较时应使用 decimal 模块或整数运算。

二、流程控制与推导式

1. for-else 与 while-else

for i in range(5):
    if i == 10:
        break
else:
    print("未触发 break")  # 会执行

要点：else 块在循环正常结束（未 break）时执行，常用于“查找失败”的兜底逻辑。

2. 推导式的可读性边界

matrix = [[1, 2], [3, 4]]
flat = [n for row in matrix for n in row]
squares = {x: x * x for x in range(5)}
evens = {x for x in range(10) if x % 2 == 0}

要点：推导式适合简单映射与过滤。嵌套超过两层或条件复杂时，应改回普通循环，避免可读性下降。

三、函数与作用域

1. 位置参数、关键字参数与仅关键字参数

def func(a, b, /, c, *, d):
    return a + b + c + d
func(1, 2, 3, d=4)      # 正确
func(1, 2, c=3, d=4)    # 正确
func(a=1, b=2, c=3, d=4)  # 错误，a、b 为仅位置参数

要点：/ 之前的参数只能按位置传递，* 之后的参数只能按关键字传递。合理使用可以提升接口的清晰度与兼容性。

2. 闭包与 nonlocal

def counter():
    count = 0
    def inner():
        nonlocal count
        count += 1
        return count
    return inner
c = counter()
print(c(), c(), c())  # 1 2 3

要点：闭包捕获的是变量本身而非值，nonlocal 用于在内部函数中修改外层函数变量。若只需读取，可省略声明。

3. 装饰器

import functools
def log(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        print(f"调用 {func.__name__}")
        return func(*args, **kwargs)
    return wrapper
@log
def greet(name):
    return f"Hello, {name}"

要点：装饰器本质是高阶函数，用于横切关注点（日志、缓存、鉴权、重试）。务必使用 functools.wraps 保留原函数元信息。

四、面向对象：从语法到设计

1. 类属性与实例属性

class User:
    category = "person"
    def __init__(self, name):
        self.name = name
u1 = User("A")
u2 = User("B")
u1.category = "vip"
print(User.category, u2.category)  # person person

要点：类属性被所有实例共享；通过实例赋值会在实例上创建同名属性，遮蔽类属性。修改共享状态时应通过类名操作。

2. 魔术方法

class Vector:
    def __init__(self, x, y):
        self.x, self.y = x, y
    def __add__(self, other):
        return Vector(self.x + other.x, self.y + other.y)
    def __repr__(self):
        return f"Vector({self.x}, {self.y})"
    def __eq__(self, other):
        return (self.x, self.y) == (other.x, other.y)

要点：__repr__ 面向开发者，__str__ 面向用户；实现 __eq__ 时通常也要考虑 __hash__ 的一致性。

3. 继承与 MRO

class A:
    def hello(self):
        print("A")
class B(A):
    def hello(self):
        print("B")
        super().hello()
B().hello()  # B A

要点：super() 按 MRO 顺序调用下一个类的方法，而非简单调用父类。多重继承时应理解 C3 线性化规则，避免菱形继承带来的意外行为。

五、文件、异常与上下文管理

1. 上下文管理器

with open("data.txt", "w", encoding="utf-8") as f:
    f.write("hello")

要点：with 保证资源在异常情况下也能正确释放。自定义上下文管理器可实现 __enter__ 与 __exit__，或使用 contextlib.contextmanager 装饰生成器。

2. 异常处理原则

try:
    value = int("abc")
except ValueError as e:
    print(f"转换失败: {e}")
else:
    print("成功")
finally:
    print("清理")

要点：捕获具体异常而非裸 except；避免用异常控制正常流程；else 在无异常时执行，finally 始终执行。

六、常用标准库与并发模型

1. 常用标准库速览

• collections：defaultdict、Counter、deque、namedtuple
• itertools：chain、groupby、product、islice
• functools：lru_cache、partial、reduce
• pathlib：面向对象的路径操作
• json / csv / sqlite3：常见数据交换与本地存储

from collections import Counter
print(Counter("abracadabra").most_common(2))

2. 并发与并行

from concurrent.futures import ThreadPoolExecutor, ProcessPoolExecutor
def task(n):
    return n * n
with ThreadPoolExecutor(max_workers=4) as ex:
    print(list(ex.map(task, range(5))))

要点：I/O 密集型任务适合多线程或异步 I/O；CPU 密集型任务应使用多进程以绕过全局解释器锁。异步编程使用 async / await，适合高并发网络场景。

七、自测建议与学习路径

1. 按模块自测：逐个模块写出示例并运行，观察输出是否符合预期。
2. 制造边界：空列表、None、超大数值、循环引用、异常路径都要覆盖。
3. 阅读源码：标准库实现是极佳的学习材料，理解其设计取舍。
4. 工程化实践：类型注解、单元测试、日志、代码格式化与静态检查应尽早纳入日常。

Python 的深度不在于语法复杂度，而在于对对象模型、作用域、并发与生态的准确理解。把上述清单逐条跑通、改错、再解释清楚，你对 Python 的掌握就会从“能写”进阶到“写得对、写得稳”。