在Python中，高效的调试和性能优化是提升代码质量的关键。以下是经过实战验证的 调试技巧 和 性能优化策略，帮助你快速定位问题并提升代码运行效率。

一、高效调试技巧

1. 使用print调试（快速定位问题）

• 技巧：在关键位置插入 print，输出变量状态或执行流程。
• 改进：使用 f-string 或 pprint 格式化输出。

def calculate(a, b):
    print(f"[DEBUG] a={a}, b={b}")  # 调试输出
    return a * b + 10

2. 断言assert（快速验证条件）

• 适用场景：检查输入、中间状态或返回值是否符合预期。

def divide(a, b):
    assert b != 0, "除数不能为0"  # 如果b=0，抛出AssertionError
    return a / b

3. 日志记录logging（替代print）

• 优势：可控制日志级别（DEBUG/INFO/WARNING/ERROR），写入文件。

import logging
logging.basicConfig(level=logging.DEBUG)

def process_data(data):
    logging.debug(f"Processing data: {data}")

4. 使用pdb交互式调试

• 命令：
• break / b：设置断点
• next / n：单步执行
• continue / c：继续执行
• print / p：查看变量

import pdb

def buggy_function(x):
    pdb.set_trace()  # 进入调试模式
    return x * 2 + unknown_var  # 假设这里出错

5. IDE 调试（PyCharm / VSCode）

• 推荐：
• PyCharm：右键 Debug，支持条件断点、变量监控。
• VSCode：F5 启动调试，F10 单步执行。

二、性能优化技巧

1. 使用timeit测量代码执行时间

import timeit

code_to_test = """
result = [x ** 2 for x in range(1000)]
"""
execution_time = timeit.timeit(code_to_test, number=1000)
print(f"执行时间: {execution_time:.4f} 秒")

2. 避免全局变量（局部变量更快）

• 原因：局部变量访问速度比全局变量快 ~30%。

#  慢（全局变量）
global_var = 10
def slow_func():
    return global_var * 2

#  快（局部变量）
def fast_func():
    local_var = 10
    return local_var * 2

3. 使用list推导式替代for循环

• 优势：速度快 2~3 倍，代码更简洁。

#  慢
squares = []
for x in range(1000):
    squares.append(x ** 2)

#  快
squares = [x ** 2 for x in range(1000)]

4. 使用set/dict加速查找

• 适用场景：检查元素是否存在时，set 比 list 快 100 倍。

#  慢（列表查找 O(n)）
items = [1, 2, 3, 4, 5]
if 3 in items:  # 线性扫描
    pass

#  快（集合查找 O(1)）
items = {1, 2, 3, 4, 5}
if 3 in items:  # 哈希查找
    pass

5. 使用f-string替代%或.format()

• 优势：f-string 是 Python 3.6+ 最快的字符串格式化方式。

name = "Alice"
age = 30

#  慢
msg = "Name: %s, Age: %d" % (name, age)
msg = "Name: {}, Age: {}".format(name, age)

#  快
msg = f"Name: {name}, Age: {age}"

6. 使用numba加速数值计算

• 适用场景：数学计算密集型任务（比纯 Python 快 100 倍）。

from numba import jit

@jit(nopython=True)  # 启用JIT编译
def fast_sum(arr):
    total = 0
    for x in arr:
        total += x
    return total

7. 使用multiprocessing并行计算

• 适用场景：CPU 密集型任务（如数据处理、机器学习）。

from multiprocessing import Pool

def process_data(data):
    return data * 2

if __name__ == "__main__":
    data = [1, 2, 3, 4, 5]
    with Pool(4) as p:  # 4个进程并行
        results = p.map(process_data, data)

三、性能优化工具

四、总结

调试技巧

1. print / logging → 快速定位问题
2. assert → 验证条件
3. pdb / IDE 调试 → 交互式排查
4. timeit → 测量执行时间

性能优化

1. 避免全局变量 → 改用局部变量
2. list 推导式 → 替代 for 循环
3. set / dict → 加速查找
4. f-string → 最快字符串格式化
5. numba → 加速数值计算
6. multiprocessing → 并行计算

掌握这些技巧后，你的 Python 代码将 更快、更健壮、更易维护！