Python实用技巧-性能优化基础

2018-08-26 | 阅读：次

Python性能优化的重要性

性能优化是Python开发中的重要技能。虽然Python以简洁易读著称，但在处理大量数据或对性能要求较高的场景中，合理的优化可以带来显著的性能提升。

时间复杂度基础

1. 常见算法复杂度

import time
import random

def measure_time(func, *args, **kwargs):
    """测量函数执行时间"""
    start = time.perf_counter()
    result = func(*args, **kwargs)
    end = time.perf_counter()
    return result, end - start

# O(1) - 常数时间复杂度
def constant_time(n):
    """常数时间操作"""
    return n * 2

# O(n) - 线性时间复杂度
def linear_time(n):
    """线性时间操作"""
    total = 0
    for i in range(n):
        total += i
    return total

# O(n²) - 平方时间复杂度
def quadratic_time(n):
    """平方时间操作"""
    result = []
    for i in range(n):
        for j in range(n):
            result.append(i * j)
    return result

# 性能测试
n = 1000
_, time1 = measure_time(constant_time, n)
_, time2 = measure_time(linear_time, n)
_, time3 = measure_time(quadratic_time, n)

print(f"常数时间: {time1:.6f}秒")
print(f"线性时间: {time2:.6f}秒")
print(f"平方时间: {time3:.6f}秒")

2. 数据结构选择对性能的影响

# 列表 vs 集合的查找性能
def test_lookup_performance():
    """测试不同数据结构的查找性能"""
    n = 10000
    
    # 列表查找 - O(n)
    my_list = list(range(n))
    start = time.perf_counter()
    for i in range(1000):
        i * 2 in my_list  # 线性查找
    list_time = time.perf_counter() - start
    
    # 集合查找 - O(1)
    my_set = set(range(n))
    start = time.perf_counter()
    for i in range(1000):
        i * 2 in my_set  # 常数查找
    set_time = time.perf_counter() - start
    
    print(f"列表查找时间: {list_time:.6f}秒")
    print(f"集合查找时间: {set_time:.6f}秒")
    print(f"性能提升: {list_time/set_time:.2f}倍")

test_lookup_performance()

内置函数优化

1. 使用内置函数替代循环

# 慢：手动循环
def slow_sum(numbers):
    total = 0
    for num in numbers:
        total += num
    return total

# 快：使用内置sum
def fast_sum(numbers):
    return sum(numbers)

# 性能对比
numbers = list(range(1000000))

_, slow_time = measure_time(slow_sum, numbers)
_, fast_time = measure_time(fast_sum, numbers)

print(f"手动循环: {slow_time:.6f}秒")
print(f"内置函数: {fast_time:.6f}秒")
print(f"性能提升: {slow_time/fast_time:.2f}倍")

2. 向量化操作

import numpy as np

def vectorized_operations():
    """向量化操作示例"""
    # 传统Python循环
    def python_loop(data):
        result = []
        for x in data:
            result.append(x * 2 + 1)
        return result
    
    # NumPy向量化操作
    def numpy_vectorized(data):
        return data * 2 + 1
    
    # 性能测试
    data = list(range(100000))
    np_data = np.array(data)
    
    _, python_time = measure_time(python_loop, data)
    _, numpy_time = measure_time(numpy_vectorized, np_data)
    
    print(f"Python循环: {python_time:.6f}秒")
    print(f"NumPy向量化: {numpy_time:.6f}秒")
    print(f"性能提升: {python_time/numpy_time:.2f}倍")

vectorized_operations()

内存优化技巧

1. 生成器 vs 列表

def memory_efficient_processing():
    """内存高效的数据处理"""
    # 列表方式 - 占用大量内存
    def list_approach(n):
        squares = [x*x for x in range(n)]
        return sum(squares)
    
    # 生成器方式 - 内存友好
    def generator_approach(n):
        squares = (x*x for x in range(n))
        return sum(squares)
    
    # 性能测试
    n = 1000000
    
    _, list_time = measure_time(list_approach, n)
    _, gen_time = measure_time(generator_approach, n)
    
    print(f"列表方式: {list_time:.6f}秒")
    print(f"生成器方式: {gen_time:.6f}秒")
    print(f"性能差异: {abs(list_time - gen_time):.6f}秒")

memory_efficient_processing()

2. 避免不必要的对象创建

def string_concatenation_performance():
    """字符串拼接性能对比"""
    # 慢：字符串拼接
    def slow_concat(strings):
        result = ""
        for s in strings:
            result += s
        return result
    
    # 快：使用join
    def fast_concat(strings):
        return "".join(strings)
    
    # 性能测试
    strings = ["hello"] * 10000
    
    _, slow_time = measure_time(slow_concat, strings)
    _, fast_time = measure_time(fast_concat, strings)
    
    print(f"字符串拼接: {slow_time:.6f}秒")
    print(f"join方法: {fast_time:.6f}秒")
    print(f"性能提升: {slow_time/fast_time:.2f}倍")

string_concatenation_performance()

性能分析工具

1. 使用timeit模块

import timeit

def performance_comparison():
    """性能对比示例"""
    # 测试不同的实现方式
    setup = """
import random
data = [random.randint(1, 100) for _ in range(1000)]
"""
    
    # 方法1：列表推导式
    method1 = """
result = [x*2 for x in data if x > 50]
"""
    
    # 方法2：传统循环
    method2 = """
result = []
for x in data:
    if x > 50:
        result.append(x*2)
"""
    
    # 方法3：生成器表达式
    method3 = """
result = list(x*2 for x in data if x > 50)
"""
    
    # 性能测试
    time1 = timeit.timeit(method1, setup, number=1000)
    time2 = timeit.timeit(method2, setup, number=1000)
    time3 = timeit.timeit(method3, setup, number=1000)
    
    print(f"列表推导式: {time1:.6f}秒")
    print(f"传统循环: {time2:.6f}秒")
    print(f"生成器表达式: {time3:.6f}秒")

performance_comparison()

2. 使用cProfile进行性能分析

import cProfile
import pstats

def fibonacci(n):
    """计算斐波那契数列"""
    if n <= 1:
        return n
    return fibonacci(n-1) + fibonacci(n-2)

def fibonacci_optimized(n, memo={}):
    """优化的斐波那契数列（使用记忆化）"""
    if n in memo:
        return memo[n]
    if n <= 1:
        return n
    memo[n] = fibonacci_optimized(n-1, memo) + fibonacci_optimized(n-2, memo)
    return memo[n]

def profile_fibonacci():
    """分析斐波那契函数的性能"""
    print("分析普通斐波那契函数:")
    cProfile.run('fibonacci(20)', 'fib_profile.prof')
    
    print("\n分析优化的斐波那契函数:")
    cProfile.run('fibonacci_optimized(20)', 'fib_opt_profile.prof')
    
    # 查看性能统计
    stats = pstats.Stats('fib_profile.prof')
    stats.sort_stats('cumulative')
    stats.print_stats(10)

profile_fibonacci()

优化策略与最佳实践

1. 算法优化

def algorithm_optimization():
    """算法优化示例"""
    # 慢：O(n²)算法
    def slow_find_duplicates(arr):
        duplicates = []
        for i in range(len(arr)):
            for j in range(i+1, len(arr)):
                if arr[i] == arr[j]:
                    duplicates.append(arr[i])
        return duplicates
    
    # 快：O(n)算法
    def fast_find_duplicates(arr):
        seen = set()
        duplicates = []
        for item in arr:
            if item in seen:
                duplicates.append(item)
            else:
                seen.add(item)
        return duplicates
    
    # 性能测试
    test_data = [1, 2, 3, 2, 4, 5, 3, 6, 7, 8, 9, 1] * 100
    _, slow_time = measure_time(slow_find_duplicates, test_data)
    _, fast_time = measure_time(fast_find_duplicates, test_data)
    
    print(f"O(n²)算法: {slow_time:.6f}秒")
    print(f"O(n)算法: {fast_time:.6f}秒")
    print(f"性能提升: {slow_time/fast_time:.2f}倍")

algorithm_optimization()

2. 缓存优化

from functools import lru_cache

def caching_optimization():
    """缓存优化示例"""
    # 无缓存的递归函数
    def fibonacci_no_cache(n):
        if n <= 1:
            return n
        return fibonacci_no_cache(n-1) + fibonacci_no_cache(n-2)
    
    # 使用缓存的递归函数
    @lru_cache(maxsize=None)
    def fibonacci_with_cache(n):
        if n <= 1:
            return n
        return fibonacci_with_cache(n-1) + fibonacci_with_cache(n-2)
    
    # 性能测试
    n = 30
    _, no_cache_time = measure_time(fibonacci_no_cache, n)
    _, cache_time = measure_time(fibonacci_with_cache, n)
    
    print(f"无缓存: {no_cache_time:.6f}秒")
    print(f"有缓存: {cache_time:.6f}秒")
    print(f"性能提升: {no_cache_time/cache_time:.2f}倍")

caching_optimization()

3. 内存使用优化

import sys

def memory_usage_optimization():
    """内存使用优化示例"""
    # 列表推导式 - 占用大量内存
    def list_comprehension(n):
        return [x*x for x in range(n)]
    
    # 生成器表达式 - 内存友好
    def generator_expression(n):
        return (x*x for x in range(n))
    
    # 内存使用测试
    n = 1000000
    # 列表推导式内存使用
    lst = list_comprehension(n)
    list_memory = sys.getsizeof(lst)
    
    # 生成器表达式内存使用
    gen = generator_expression(n)
    gen_memory = sys.getsizeof(gen)
    
    print(f"列表推导式内存: {list_memory} 字节")
    print(f"生成器表达式内存: {gen_memory} 字节")
    print(f"内存节省: {list_memory/gen_memory:.2f}倍")

memory_usage_optimization()