Python高效编程的20个"魔鬼细节"，你可能从未注意过！

a = 1
b = 2
temp = a
a = b
b = temp

a, b = b, a

# 内存杀手（慎用！）
sum([x**2 for x in range(10**6)]) 

# 正确姿势✅
sum(x**2 for x in range(10**6)) 

d1 = {'a':1}
d2 = {'b':2}

# 方法1（Python3.9+）
merged = d1 | d2 

# 方法2（经典）
merged = {**d1, **d2}

# 方法3（保留原始字典）
d1.update(d2)

# 错误示范（产生N个中间对象）
s = ""
for i in range(10000):
    s += str(i)

# 正确姿势✅
parts = []
for i in range(10000):
    parts.append(str(i))
s = "".join(parts)

for item in iterable:
    if condition(item):
        break
else:
    # 当循环完整执行且未触发break时执行
    print("No item found!")

# 传统写法
with open('file.txt') as f:
    data = f.read()

# 自定义上下文管理器✅
class DatabaseConnection:
    def __enter__(self):
        self.conn = create_connection()
        return self.conn
    
    def __exit__(self, exc_type, exc_val, exc_tb):
        self.conn.close()

# 错误写法（列表会保留上次调用结果！）
def append_to(element, target=[]):
    target.append(element)
    return target

# 正确姿势✅
def append_to(element, target=None):
    if target is None:
        target = []
    target.append(element)
    return target

# 低效写法：嵌套装饰器
@log_time
@validate_args
def process_data(data):
    ...

# 高效方案：合并装饰逻辑 ✅
def combined_decorator(func):
    def wrapper(*args):
        validate(args)
        start = time.time()
        result = func(*args)
        log_time(start)
        return result
    return wrapper

# 危险操作（内存爆炸）
data = [open(file).read() for file in huge_file_list]

# 正确姿势 ✅
def file_stream():
    for file in huge_file_list:
        with open(file) as f:
            yield f.read()

# 使用生成器处理
process(file_stream())

class User:
    __slots__ = ['name', 'age']  # 限制动态属性
    
    def __init__(self, name, age):
        self.name = name
        self.age = age

# 错误用法（异常捕获比if判断慢10倍）
try:
    value = my_dict[key]
except KeyError:
    value = default

# 高效替代 ✅
value = my_dict.get(key, default)

class SingletonMeta(type):
    _instances = {}
    
    def __call__(cls, *args, **kwargs):
        if cls not in cls._instances:
            cls._instances[cls] = super().__call__(*args, **kwargs)
        return cls._instances[cls]

class Database(metaclass=SingletonMeta):
    def __init__(self):
        self.connection = create_connection()

# 多线程受GIL限制（CPU密集型任务）
from threading import Thread
threads = [Thread(target=ocr_process) for _ in range(8)]

# 多进程突破GIL ✅
from multiprocessing import Pool
with Pool(8) as p:
    p.map(ocr_process, tasks)

from collections import defaultdict, deque

# 自动初始化字典 ✅
word_count = defaultdict(int)
for word in words:
    word_count[word] += 1  # 无需判断key是否存在

# 高效队列（比list快6倍）
cache = deque(maxlen=1000)  # 自动淘汰旧数据

# 传统异步写法（回调地狱）
def fetch_data(url, callback):
    result = requests.get(url)
    callback(result)

# 现代协程方案 ✅
async def fetch_data(url):
    async with aiohttp.ClientSession() as session:
        async with session.get(url) as response:
            return await response.json()

# 启动10K并发请求
async def main():
    tasks = [fetch_data(url) for url in url_list]
    await asyncio.gather(*tasks)

# 原始Python代码
def calc_pi(n_terms):
    pi = 0.0
    for k in range(n_terms):
        pi += (-1)**k / (2*k + 1)
    return 4 * pi

# Cython优化版 ✅
cdef double calc_pi_cy(int n_terms):
    cdef double pi = 0.0
    cdef int k
    for k in range(n_terms):
        pi += (-1)**k / (2*k + 1)
    return 4 * pi

# 安装内存分析工具
pip install memory-profiler

# 在代码中添加探查点
from memory_profiler import profile

@profile
def process_data():
    data = [np.random.rand(1000,1000) for _ in range(100)]  # 可疑代码
    return sum([d.mean() for d in data])

if __name__ == "__main__":
    process_data()

# 运行结果
Line #    Mem usage    Increment  Occurrences  Line Contents
=============================================================
 3     38.1 MiB     38.1 MiB           1   @profile
 4                                         def process_data():
 5    785.4 MiB    747.3 MiB         101       data = [np.random.rand(...)] 
 6    785.4 MiB      0.0 MiB           1       return sum(...)

class User:
    def __init__(self, uid, name):
        self.uid = uid
        self.name = name

# 优化方案 ✅
class OptimizedUser:
    __slots__ = ['uid', 'name']
    
    def __init__(self, uid, name):
        self.uid = uid
        self.name = name

# 普通迭代器
class RangeIterator:
    def __init__(self, n):
        self.n = n
        self.i = 0
        
    def __next__(self):
        if self.i < self.n:
            result = self.i
            self.i += 1
            return result
        else:
            raise StopIteration

# 生成器表达式 ✅
range_gen = (x for x in range(n))

from concurrent.futures import ProcessPoolExecutor
import numpy as np

def process_chunk(arr_chunk):
    return np.sqrt(arr_chunk) * 2

def parallel_compute():
    data = np.random.rand(1000000)
    chunk_size = len(data) // 8
    
    with ProcessPoolExecutor() as executor:
        chunks = [data[i*chunk_size:(i+1)*chunk_size] for i in range(8)]
        results = list(executor.map(process_chunk, chunks))
    
    return np.concatenate(results)

graph TD
    A[Python性能优化] --> B[语言特性]
    A --> C[并发模型]
    A --> D[内存管理]
    
    B --> B1[生成器表达式]
    B --> B2[slots魔法]
    B --> B3[字典合并]
    
    C --> C1[协程]
    C --> C2[多进程]
    C --> C3[线程池]
    
    D --> D1[内存分析]
    D --> D2[对象复用]
    D --> D3[泄露检测]