Python案例怎么优化内存占用？

wen python案例 2026-06-06 367

本文目录导读：

Python案例怎么优化内存占用？

使用生成器（Generator）替代列表
减少对象创建与引用
使用slots减少类实例内存
使用数组（array模块）替代列表
使用NumPy处理数值数据
及时释放大对象
使用弱引用（WeakReference）
优化数据结构选择
实践案例：CSV大文件处理
监控工具与建议

针对Python案例的内存优化，需要根据具体场景（数据处理、Web服务、机器学习等）采用不同策略，以下是经过验证的优化方案,按效果从高到低排列：

使用生成器（Generator）替代列表

❌ 内存浪费版本

# 生成100万个数字，占用约8MB内存
def process_large_list():
    data = [i for i in range(1_000_000)]
    return sum(data)

✅ 优化版本

# 使用生成器，几乎不占用内存
def process_large_generator():
    data = (i for i in range(1_000_000))
    return sum(data)  # 边生成边计算
# 或者使用yield
def number_generator(n):
    for i in range(n):
        yield i * 2
for num in number_generator(1_000_000):
    pass  # 处理每个数字

减少对象创建与引用

❌ 频繁创建对象

def process_strings(items):
    result = []
    for item in items:
        temp = item.strip()
        temp = temp.upper()
        temp = temp.replace(" ", "_")
        result.append(temp)
    return result

✅ 链式调用减少中间变量

def process_strings_optimized(items):
    return [item.strip().upper().replace(" ", "_") for item in items]

使用slots减少类实例内存

❌ 默认类实例

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y
points = [Point(i, i+1) for i in range(1_000_000)]  # 约72MB

✅ 使用slots

class Point:
    __slots__ = ('x', 'y')  # 禁止动态添加属性
    def __init__(self, x, y):
        self.x = x
        self.y = y
points = [Point(i, i+1) for i in range(1_000_000)]  # 约32MB，减少55%

使用数组（array模块）替代列表

❌ 使用Python列表

import sys
numbers = list(range(1_000_000))
print(sys.getsizeof(numbers))  # 约8MB（仅对象本身，还不含元素）

✅ 使用array

from array import array
numbers_arr = array('i', range(1_000_000))  # 'i'表示整型
print(sys.getsizeof(numbers_arr))  # 约4MB，节省50%

使用NumPy处理数值数据

❌ Python列表计算

import time
data = [i * 0.5 for i in range(10_000_000)]
total = sum(data)  # 慢且占内存

✅ NumPy向量化计算

import numpy as np
data = np.arange(0, 10_000_000, dtype=np.float32) * 0.5  # 直接操作底层内存
total = np.sum(data)  # 更快，内存更省

及时释放大对象

❌ 依赖垃圾回收

def load_and_process():
    huge_data = load_huge_file()  # 占用1GB
    result = process(huge_data)
    # huge_data仍然存在直到函数结束
    return result
def load_large_file():
    with open('large_file.bin', 'rb') as f:
        data = f.read()  # 全部加载到内存
        return data

✅ 显式释放和分块处理

def load_and_process_optimized():
    huge_data = load_huge_file()
    result = process(huge_data)
    del huge_data  # 显式删除，立即释放内存
    # 后续操作
    return result
def load_large_file_chunked():
    with open('large_file.bin', 'rb') as f:
        while chunk := f.read(1024 * 1024):  # 每次读取1MB
            yield chunk  # 使用生成器分块处理

使用弱引用（WeakReference）

当需要缓存但不希望阻止对象被回收时：

import weakref
class CacheManager:
    def __init__(self):
        self._cache = weakref.WeakValueDictionary()
    def get_or_create(self, key, creator_func):
        if key in self._cache:
            return self._cache[key]
        obj = creator_func()
        self._cache[key] = obj
        return obj

优化数据结构选择

集合 vs 列表去重

# ❌ 列表去重
unique_items = []
for item in items:
    if item not in unique_items:  # O(n²)
        unique_items.append(item)
# ✅ 集合去重
unique_items = list(set(items))  # O(n)，内存更少

使用bytes而非str（对于二进制数据）

# ❌ 字符串操作
data = "ABC" * 1_000_000  # 每个字符2字节
# ✅ 字节串操作
data = b"ABC" * 1_000_000  # 每个字符1字节

实践案例：CSV大文件处理

❌ 全量加载

import csv
def process_csv_bad(filename):
    with open(filename, 'r') as f:
        reader = csv.reader(f)
        all_data = list(reader)  # 全部加载到内存
        # 对所有数据进行处理
        return [row[0] for row in all_data if float(row[2]) > 100]

✅ 流式处理

import csv
def process_csv_good(filename):
    result = []
    with open(filename, 'r') as f:
        reader = csv.reader(f)
        for row in reader:  # 逐行读取，不加载全部
            if float(row[2]) > 100:
                result.append(row[0])
    return result

监控工具与建议

使用memory_profiler：

pip install memory_profiler
python -m memory_profiler your_script.py

使用tracemalloc（Python 3.4+）：

import tracemalloc
tracemalloc.start()
# 你的代码
snapshot = tracemalloc.take_snapshot()
top_stats = snapshot.statistics('lineno')
for stat in top_stats[:10]:
 print(stat)