Python性能优化之让你的代码运行速度提升10倍的技巧分享

# 慢速版本
def find_in_list(items, targets):
    result = []
    for target in targets:
        if target in items:  # O(n) 查找
            result.append(target)
    return result

# 快速版本
def find_in_set(items, targets):
    items_set = set(items)  # 一次性转换
    result = []
    for target in targets:
        if target in items_set:  # O(1) 查找
            result.append(target)
    return result

# 慢速版本
def get_discount(level):
    if level == 'bronze':
        return 0.05
    elif level == 'silver':
        return 0.10
    elif level == 'gold':
        return 0.15
    elif level == 'platinum':
        return 0.20
    else:
        return 0

# 快速版本
def get_discount(level):
    discounts = {
        'bronze': 0.05,
        'silver': 0.10,
        'gold': 0.15,
        'platinum': 0.20
    }
    return discounts.get(level, 0)

# 慢速版本
numbers = range(1000000)
result = []
for num in numbers:
    result.append(num * 2)

# 快速版本
numbers = range(1000000)
result = list(map(lambda x: x * 2, numbers))

# 更快：列表推导式
result = [num * 2 for num in numbers]

from collections import Counter, defaultdict, deque

# 统计元素出现次数
words = ['apple', 'banana', 'apple', 'orange', 'banana', 'apple']
# 快速统计
count = Counter(words)

# 使用defaultdict避免键检查
word_positions = defaultdict(list)
for i, word in enumerate(words):
    word_positions[word].append(i)

# 使用deque实现高效的队列操作
queue = deque()
queue.append(1)  # O(1)
queue.popleft()  # O(1)，list.pop(0)是O(n)

from functools import lru_cache

# 慢速版本：重复计算
def fibonacci(n):
    if n < 2:
        return n
    return fibonacci(n-1) + fibonacci(n-2)

# 快速版本：使用缓存
@lru_cache(maxsize=None)
def fibonacci_cached(n):
    if n < 2:
        return n
    return fibonacci_cached(n-1) + fibonacci_cached(n-2)

# fibonacci(35) 可能需要几秒
# fibonacci_cached(35) 几乎瞬间完成

# 慢速版本：一次性创建所有数据
def process_large_file(filename):
    with open(filename) as f:
        lines = f.readlines()  # 一次性读入内存
        return [line.strip().upper() for line in lines]

# 快速版本：使用生成器
def process_large_file_lazy(filename):
    with open(filename) as f:
        for line in f:  # 逐行处理
            yield line.strip().upper()

# 使用
for processed_line in process_large_file_lazy('huge_file.txt'):
    # 处理每一行，内存占用小
    pass

# 慢速版本：使用+拼接
def join_strings_slow(strings):
    result = ""
    for s in strings:
        result += s  # 每次创建新字符串对象
    return result

# 快速版本：使用join
def join_strings_fast(strings):
    return "".join(strings)

# 性能对比：处理10000个字符串
# 慢速版本：约0.5秒
# 快速版本：约0.001秒（快500倍）

import math

# 慢速版本
def calculate_slow(numbers):
    result = []
    for num in numbers:
        result.append(math.sqrt(num))  # 每次都要查找math.sqrt
    return result

# 快速版本
def calculate_fast(numbers):
    sqrt = math.sqrt  # 局部变量查找更快
    result = []
    for num in numbers:
        result.append(sqrt(num))
    return result

# 更快：列表推导式
def calculate_fastest(numbers):
    sqrt = math.sqrt
    return [sqrt(num) for num in numbers]

items = ['a', 'b', 'c', 'd']

# 慢速版本
for i in range(len(items)):
    print(i, items[i])

# 快速版本
for i, item in enumerate(items):
    print(i, item)

from concurrent.futures import ProcessPoolExecutor, ThreadPoolExecutor
import time

# CPU密集型任务示例
def cpu_bound_task(n):
    return sum(i * i for i in range(n))

# 使用多进程
def process_with_multiprocessing(numbers):
    with ProcessPoolExecutor() as executor:
        results = list(executor.map(cpu_bound_task, numbers))
    return results

# IO密集型任务使用多线程
import requests

def download_url(url):
    response = requests.get(url)
    return len(response.content)

def download_parallel(urls):
    with ThreadPoolExecutor(max_workers=10) as executor:
        results = list(executor.map(download_url, urls))
    return results

import numpy as np

# 慢速版本：纯Python
def sum_of_squares_python(n):
    return sum(i**2 for i in range(n))

# 快速版本：NumPy
def sum_of_squares_numpy(n):
    arr = np.arange(n)
    return np.sum(arr**2)

# 性能对比（n=1000000）
# Python版本：约0.5秒
# NumPy版本：约0.01秒（快50倍）

import cProfile
import pstats

# 使用cProfile分析
def my_function():
    # 你的代码
    pass

profiler = cProfile.Profile()
profiler.enable()
my_function()
profiler.disable()

stats = pstats.Stats(profiler)
stats.sort_stats('cumulative')
stats.print_stats(10)  # 显示最慢的10个函数

# 使用line_profiler进行行级分析
# pip install line_profiler
# 在函数前添加@profile装饰器
# 运行：kernprof -l -v script.py

GLOBAL_LIST = list(range(10000))

# 慢速版本
def process_global():
    result = 0
    for item in GLOBAL_LIST:
        result += item
    return result

# 快速版本
def process_local():
    local_list = GLOBAL_LIST  # 创建局部引用
    result = 0
    for item in local_list:
        result += item
    return result

# 普通类
class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

# 优化类
class PointOptimized:
    __slots__ = ['x', 'y']
    
    def __init__(self, x, y):
        self.x = x
        self.y = y

# 创建100万个实例
# 普通类：约300MB内存
# 优化类：约150MB内存（节省50%）