1. 使用内置函数和库

Python内置函数使用C语言实现，比纯Python代码执行更快

# 慢速实现
result = []
for i in range(10000):
    result.append(i * 2)
                
# 快速实现 - 使用map
result = list(map(lambda x: x * 2, range(10000)))
                
# 更快实现 - 使用列表推导式
result = [x * 2 for x in range(10000)]

2. 减少全局变量使用

局部变量访问比全局变量更快，尽量减少全局变量使用

# 慢速实现
global_var = 10

def calculate():
    total = 0
    for i in range(1000000):
        total += global_var  # 访问全局变量
    return total
                
# 快速实现 - 使用局部变量
def calculate_fast():
    local_var = 10
    total = 0
    for i in range(1000000):
        total += local_var  # 访问局部变量
    return total

3. 使用适当的数据结构

选择合适的数据结构可大幅提升性能

# 慢速查找 - 使用列表
my_list = [i for i in range(10000)]
if 9999 in my_list:  # O(n)时间复杂度
    pass
                
# 快速查找 - 使用集合
my_set = set(range(10000))
if 9999 in my_set:  # O(1)时间复杂度
    pass

4. 利用生成器和迭代器

避免创建大型临时列表，节省内存和时间

# 慢速实现 - 创建完整列表
def get_numbers(n):
    result = []
    for i in range(n):
        result.append(i * i)
    return result
                
# 快速实现 - 使用生成器
def get_numbers_fast(n):
    for i in range(n):
        yield i * i  # 按需生成值

5. 使用JIT编译器

使用PyPy或Numba等JIT编译器加速代码执行

# 使用Numba加速数值计算
from numba import jit
import numpy as np

@jit(nopython=True)
def monte_carlo_pi(nsamples):
    acc = 0
    for i in range(nsamples):
        x = np.random.random()
        y = np.random.random()
        if (x**2 + y**2) < 1.0:
            acc += 1
    return 4.0 * acc / nsamples

6. 向量化操作

使用NumPy/Pandas进行向量化计算

import numpy as np

# 慢速实现 - Python循环
def slow_dot_product(a, b):
    result = 0
    for i in range(len(a)):
        result += a[i] * b[i]
    return result
                
# 快速实现 - NumPy向量化
def fast_dot_product(a, b):
    return np.dot(a, b)  # 使用C实现的快速向量运算

7. 使用多进程/多线程

利用多核CPU并行处理任务

from concurrent.futures import ProcessPoolExecutor

def process_data(data):
    # 数据处理逻辑
    return result

def parallel_processing(data_list):
    with ProcessPoolExecutor() as executor:
        results = list(executor.map(process_data, data_list))
    return results

8. 使用C扩展

将性能关键部分用C/C++实现

# 使用Cython加速Python代码
# 文件: fast_module.pyx
cimport cython

@cython.boundscheck(False)
@cython.wraparound(False)
def compute(int n):
    cdef int i, result = 0
    for i in range(n):
        result += i * i
    return result

9. 缓存计算结果

避免重复计算相同结果

from functools import lru_cache

@lru_cache(maxsize=128)
def fibonacci(n):
    if n < 2:
        return n
    return fibonacci(n-1) + fibonacci(n-2)

10. 算法优化

选择合适算法大幅降低时间复杂度

# 慢速实现 - O(n²)
def bubble_sort(arr):
    n = len(arr)
    for i in range(n):
        for j in range(0, n-i-1):
            if arr[j] > arr[j+1]:
                arr[j], arr[j+1] = arr[j+1], arr[j]
                
# 快速实现 - O(n log n)
def quick_sort(arr):
    if len(arr) <= 1:
        return arr
    pivot = arr[len(arr) // 2]
    left = [x for x in arr if x < pivot]
    middle = [x for x in arr if x == pivot]
    right = [x for x in arr if x > pivot]
    return quick_sort(left) + middle + quick_sort(right)

性能优化最佳实践

• 优先使用内置函数和库
• 避免不必要的对象创建
• 使用局部变量而非全局变量
• 选择时间复杂度更低的算法
• 使用性能分析工具(cProfile)定位瓶颈
• 针对IO密集型任务使用异步编程
• 考虑使用PyPy替代CPython

总结

Python代码优化需要结合多种策略：

1. 选择高效算法和数据结构
2. 利用Python内置高效函数
3. 针对计算密集型任务使用JIT或C扩展
4. 合理使用并发和并行编程
5. 避免常见性能陷阱

实际应用中应使用性能分析工具确定瓶颈，再针对性地优化热点代码。