Python 编程的常见陷阱与奇巧淫技

def append_to_list(item, target=[]):
    target.append(item)
    return target

print(append_to_list(1))  # [1]
print(append_to_list(2))  # [1, 2]  ???
print(append_to_list(3))  # [1, 2, 3]  ??????

def append_to_list(item, target=None):
    if target is None:
        target = []
    target.append(item)
    return target

funcs = []
for i in range(3):
    funcs.append(lambda: i)

print([f() for f in funcs])  # [2, 2, 2]  不是 [0, 1, 2]

funcs = []
for i in range(3):
    funcs.append(lambda i=i: i)  # 注意 i=i

print([f() for f in funcs])  # [0, 1, 2]

from functools import partial

funcs = [partial(lambda x: x, i) for i in range(3)]
print([f() for f in funcs])  # [0, 1, 2]

a = 256
b = 256
print(a is b)  # True

a = 257
b = 257
print(a is b)  # False  ???

# 正确
if x is None:
    pass

# 错误（虽然通常也能用，但不规范）
if x == None:
    pass

import copy

original = [[1, 2], [3, 4]]
shallow = original.copy()  # 或 list(original) 或 original[:]
deep = copy.deepcopy(original)

original[0][0] = 999

print(shallow)  # [[999, 2], [3, 4]]  被改了！
print(deep)     # [[1, 2], [3, 4]]    没被改

# 想创建一个 3x3 的二维数组
matrix = [[0] * 3] * 3
print(matrix)  # [[0, 0, 0], [0, 0, 0], [0, 0, 0]]  看起来没问题？

matrix[0][0] = 1
print(matrix)  # [[1, 0, 0], [1, 0, 0], [1, 0, 0]]  三行都被改了！

# 用列表推导式，每次都创建新列表
matrix = [[0] * 3 for _ in range(3)]

matrix[0][0] = 1
print(matrix)  # [[1, 0, 0], [0, 0, 0], [0, 0, 0]]  正确！

d = {'a': 1, 'b': 2, 'c': 3}

for key in d:
    if d[key] == 2:
        del d[key]  # RuntimeError: dictionary changed size during iteration

# 方法一：收集后删除
to_delete = [k for k, v in d.items() if v == 2]
for k in to_delete:
    del d[k]

# 方法二：构造新字典
d = {k: v for k, v in d.items() if v != 2}

# 错误：每次 += 都会创建新字符串，O(n²)
result = ""
for s in many_strings:
    result += s

# 正确：用 join，O(n)
result = "".join(many_strings)

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

# 方法一：用 decimal（金融计算必用）
from decimal import Decimal
print(Decimal('0.1') + Decimal('0.2'))  # 0.3

# 方法二：用 math.isclose 比较（Python 3.5+）
import math
print(math.isclose(0.1 + 0.2, 0.3))  # True

# 方法三：用整数运算（以分为单位存储金额）
price_in_cents = 100 + 200  # 3 块钱

# 错误：什么异常都吞了，包括 KeyboardInterrupt、SystemExit
try:
    do_something()
except:
    pass

# 也不好：Exception 太宽
try:
    do_something()
except Exception:
    pass

# 正确：只捕获你能处理的
try:
    do_something()
except (ValueError, KeyError) as e:
    handle_error(e)

import threading

counter = 0

def increment():
    global counter
    for _ in range(1000000):
        counter += 1

threads = [threading.Thread(target=increment) for _ in range(2)]
for t in threads:
    t.start()
for t in threads:
    t.join()

print(counter)  # 不是 2000000，而是一个随机的小于 2000000 的数

# CPU 密集型：用多进程
from multiprocessing import Process, Value

# 或者用 threading.Lock 保护共享变量
import threading

counter = 0
lock = threading.Lock()

def increment():
    global counter
    for _ in range(1000000):
        with lock:
            counter += 1

# IO 密集型：多线程或 asyncio 仍然有效
import asyncio

# 之前
line = file.readline()
while line:
    process(line)
    line = file.readline()

# 之后
while (line := file.readline()):
    process(line)

# 在条件表达式中避免重复计算
if (n := len(some_list)) > 10:
    print(f"List is too long ({n} elements)")

# 旧写法
merged = {**dict1, **dict2}

# 新写法（更清晰）
merged = dict1 | dict2

# 就地更新
dict1 |= dict2

from collections import defaultdict, Counter, namedtuple, deque

# defaultdict：自动初始化
word_count = defaultdict(int)
for word in words:
    word_count[word] += 1  # 不用先 if word not in word_count

# Counter：计数神器
counter = Counter(words)
print(counter.most_common(3))  # 前 3 个高频词

# namedtuple：轻量级数据类
Point = namedtuple('Point', ['x', 'y'])
p = Point(1, 2)
print(p.x, p.y)  # 比用 dict 或 tuple 更清晰

# deque：高效的双端队列
q = deque(maxlen=3)  # 固定长度，自动弹出旧元素
q.append(1)
q.append(2)
q.append(3)
q.append(4)  # 1 被自动弹出
print(q)  # deque([2, 3, 4], maxlen=3)

from itertools import chain, groupby, islice, cycle, combinations

# chain：扁平化多个可迭代对象
for item in chain([1, 2], [3, 4], [5]):
    print(item)  # 1, 2, 3, 4, 5

# groupby：分组（注意要先排序！）
data = [('a', 1), ('a', 2), ('b', 3), ('b', 4)]
for key, group in groupby(data, key=lambda x: x[0]):
    print(key, list(group))
# a [('a', 1), ('a', 2)]
# b [('b', 3), ('b', 4)]

# islice：切片迭代器（不用全部加载到内存）
first_10 = islice(huge_iterator, 10)

# combinations：组合
list(combinations([1, 2, 3], 2))  # [(1, 2), (1, 3), (2, 3)]

# 自定义上下文管理器（类方式）
class Timer:
    def __enter__(self):
        self.start = time.time()
        return self

    def __exit__(self, *args):
        self.elapsed = time.time() - self.start
        print(f"耗时: {self.elapsed:.2f}s")

with Timer():
    do_something_slow()

# 更简洁：用 contextlib
from contextlib import contextmanager

@contextmanager
def timer():
    start = time.time()
    yield
    print(f"耗时: {time.time() - start:.2f}s")

with timer():
    do_something_slow()

# 普通类：每个实例都有一个 __dict__
class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

# 使用 __slots__：省掉 __dict__，内存占用大幅下降
class Point:
    __slots__ = ['x', 'y']

    def __init__(self, x, y):
        self.x = x
        self.y = y

from functools import lru_cache, partial, reduce

# lru_cache：自动缓存（适合纯函数）
@lru_cache(maxsize=128)
def fibonacci(n):
    if n < 2:
        return n
    return fibonacci(n-1) + fibonacci(n-2)

# partial：固定部分参数
def power(base, exponent):
    return base ** exponent

square = partial(power, exponent=2)
print(square(5))  # 25

# reduce：累积操作
from functools import reduce
product = reduce(lambda x, y: x * y, [1, 2, 3, 4])  # 24

# 交换变量
a, b = b, a

# 条件表达式
result = "yes" if condition else "no"

# 链式比较
if 0 < x < 10:
    pass

# 多重赋值
a = b = c = 0

# 解包
first, *middle, last = [1, 2, 3, 4, 5]
# first=1, middle=[2,3,4], last=5

# 字典推导式反转 key-value
inverted = {v: k for k, v in original.items()}

# any / all
if any(x > 10 for x in numbers):
    print("有大于10的")

if all(x > 0 for x in numbers):
    print("全是正数")

from dataclasses import dataclass, field

@dataclass
class User:
    name: str
    age: int
    tags: list = field(default_factory=list)  # 可变默认值要用 field

    def is_adult(self) -> bool:
        return self.age >= 18

user = User("Alice", 25)
print(user)  # User(name='Alice', age=25, tags=[])

name = "Alice"
score = 95.5678

# 基本用法
print(f"Hello, {name}!")

# 格式化数字
print(f"Score: {score:.2f}")  # 95.57

# 对齐
print(f"{name:>10}")  # 右对齐，宽度10
print(f"{name:<10}")  # 左对齐
print(f"{name:^10}")  # 居中

# 调试神器（Python 3.8+）
x = 10
y = 20
print(f"{x=}, {y=}")  # x=10, y=20

# 表达式
print(f"{2 + 2 = }")  # 2 + 2 = 4

# 推荐的工具链
pip install black isort flake8 mypy

# 格式化
black your_code.py
isort your_code.py

# 静态检查
flake8 your_code.py
mypy your_code.py

# 不推荐
def process(data):
    return data.get('name')

# 推荐
from typing import Optional

def process(data: dict[str, str]) -> Optional[str]:
    return data.get('name')

# 用 pytest，简单直接
def test_append_to_list():
    result = append_to_list(1)
    assert result == [1]

    # 验证不会有"可变默认参数"的问题
    result2 = append_to_list(2)
    assert result2 == [2]  # 应该是新列表，不是 [1, 2]

import logging

logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
)
logger = logging.getLogger(__name__)

def do_something(data):
    logger.info(f"开始处理，数据量: {len(data)}")
    try:
        result = process(data)
        logger.info(f"处理完成，结果: {result}")
        return result
    except Exception as e:
        logger.exception(f"处理失败: {e}")
        raise

# 推荐用 poetry 或 pip-tools
pip install poetry
poetry init
poetry add requests

# 或者用 pip-tools
pip install pip-tools
pip-compile requirements.in
pip-sync requirements.txt

@startmindmap
* Python 陷阱与技巧
** 常见陷阱
*** 可变默认参数
*** 闭包变量绑定
*** is 与 == 区别
*** 浅拷贝深拷贝
*** 列表乘法引用
** 实用技巧
*** 海象运算符
*** 字典合并操作
*** collections 模块
*** itertools 模块
*** 上下文管理器
** 性能优化
*** join 拼接字符串
*** set 检查成员
*** lru cache 缓存
** 工程实践
*** 代码格式化工具
*** 类型提示
*** pytest 测试
@endmindmap