MemoryError 是 Python 解释器在尝试分配内存，但操作系统无法满足其请求时抛出的内置异常，就是你的程序需要使用的内存超出了计算机物理内存（RAM）和虚拟内存（交换空间）的总和。

MemoryError 的常见原因

MemoryError 通常由以下几种情况引起：

a) 处理大型数据集

这是最常见的原因。

• 一次性将一个几GB甚至几十GB的巨大文件（如CSV、JSON、日志文件）读入内存。
• 创建一个包含数百万或数十亿个元素的列表、NumPy 数组或 Pandas DataFrame。
• 在内存中进行大规模的数据计算或转换,而没有分批处理。

示例代码：

# 尝试创建一个包含 10 亿个整数的列表
# 每个整数在Python中大约占24-28字节
# 10亿 * 28字节 = 28 GB 内存
try:
    huge_list = [0] * 1000000000  # 10亿
except MemoryError:
    print("内存不足！无法创建这么大的列表。")

b) 无限或错误的递归

递归函数如果缺少正确的终止条件,或者递归深度过大，会导致调用栈不断增长，直到耗尽栈内存，从而引发 RecursionError（在某些情况下也可能表现为 MemoryError，因为它们都与内存管理有关）。

示例代码：

def recursive_function():
    recursive_function()  # 没有终止条件
try:
    recursive_function()
except RecursionError as e:
    print(f"递归深度超限: {e}")

c) 内存泄漏

内存泄漏是指程序在运行过程中,已经不再需要使用的内存没有被垃圾回收器正确回收，导致可用内存越来越少，最终耗尽，在 Python 中，这通常由以下原因引起：

• 循环引用：两个或多个对象相互引用，导致没有其他引用指向它们，垃圾回收器无法回收它们。
• 全局变量：在函数内部将大型数据结构绑定到全局变量，即使函数执行完毕，数据也不会被释放。
• 缓存未清理：缓存了过多且不再需要的数据。

示例代码（循环引用）：

import gc
class Node:
    def __init__(self, value):
        self.value = value
        self.parent = None
# 创建循环引用
a = Node('A')
b = Node('B')
a.parent = b
b.parent = a
# 手动触发垃圾回收，但循环引用的对象默认不会被回收
# 需要启用特定的垃圾回收算法
del a, b
gc.collect() # 在默认情况下，这个循环引用可能不会被回收
print("a 和 b 的引用已被删除，但由于循环引用，内存可能未被释放。")

d) C 扩展或第三方库的问题

有些第三方库（尤其是用 C/C++ 编写的）可能存在内存管理问题，导致内存泄漏或分配失败，从而在 Python 层面引发 MemoryError。

如何诊断和解决 MemoryError

解决 MemoryError 的核心思想是：减少内存占用 或 更有效地管理内存。

解决方案 1：分块处理数据（Chunking）

不要一次性加载整个文件,而是逐行或分块读取、处理和丢弃。

示例：处理大文件

# 错误方式：一次性读取整个大文件
# with open('huge_file.txt', 'r') as f:
#     content = f.read() # MemoryError!
# 正确方式：逐行读取
line_count = 0
with open('huge_file.txt', 'r') as f:
    for line in f:
        # 在这里处理每一行
        line_count += 1
        # 处理完 line 后，它会被垃圾回收
print(f"文件处理完毕，共 {line_count} 行。")
# 对于CSV等结构化文件，可以使用 Pandas 的 chunksize
import pandas as pd
chunk_size = 10000  # 每次读取 1 万行
for chunk in pd.read_csv('huge_data.csv', chunksize=chunk_size):
    # 对每个数据块进行操作
    print(chunk.shape)
    # 操作完成后，chunk 变量会被丢弃，内存被释放

解决方案 2：使用生成器

生成器（yield）是一种惰性求值的数据结构，它只在需要时才生成数据，从而极大地节省内存。

示例：斐波那契数列

# 列表方式：会一次性生成所有结果并存储在内存中
def fibonacci_list(n):
    result = []
    a, b = 0, 1
    for _ in range(n):
        result.append(a)
        a, b = b, a + b
    return result
# fib_list = fibonacci_list(1000000) # 可能导致 MemoryError
# 生成器方式：每次只生成一个数字
def fibonacci_generator(n):
    a, b = 0, 1
    for _ in range(n):
        yield a
        a, b = b, a + b
# 使用生成器
for number in fibonacci_generator(1000000):
    pass # 逐个处理数字，内存占用极小

解决方案 3：优化数据结构

选择更节省内存的数据类型。

• 使用 NumPy 和 Pandas：它们是用 C 实现的，比原生 Python 列表和字典更节省内存，并且提供了高效的向量化操作。
  • 使用 NumPy 的 dtype 参数指定数据类型（如 np.int32 代替默认的 int）。
  • 使用 Pandas 的 category 类型存储低基数字符串（如性别、国家）。

示例：Pandas 优化

import pandas as pd
import numpy as np
# 原始 DataFrame
df = pd.DataFrame({'id': range(1000000), 'value': np.random.rand(1000000)})
# 优化内存
df['id'] = df['id'].astype('int32') # 使用更小的整数类型
df['value'] = df['value'].astype('float32') # 使用更小的浮点类型
# 对于字符串列，如果唯一值很少，可以使用 'category'
df['category_col'] = np.random.choice(['A', 'B', 'C'], size=1000000)
df['category_col'] = df['category_col'].astype('category')
print(df.memory_usage(deep=True))

解决方案 4：手动释放内存

虽然 Python 有自动垃圾回收，但有时显式地删除不再需要的对象可以帮助更快地释放内存。

• 使用 del 关键字删除变量。
• 在删除大型对象后,可以调用 gc.collect() 强制进行垃圾回收。

import gc
# 创建一个大型对象
large_data = [i for i in range(10000000)]
# ... 使用 large_data ...
# 使用完毕后，手动删除
del large_data
# 强制垃圾回收，立即释放内存
gc.collect()
print("large_data 已被删除并回收。")

解决方案 5：使用更专业的工具

对于超大规模的数据分析,可以考虑使用专门为大数据设计的工具，它们可以处理超出单机内存的数据集。

• Dask：可以模拟 Pandas 和 NumPy 的 API，但在分布式集群或单机上处理大于内存的数据集。
• PySpark：Apache Spark 的 Python API，是业界标准的分布式计算框架。
• 数据库：将数据存储在 PostgreSQL, MySQL, SQLite 等数据库中，按需查询。

解决方案 6：增加物理内存

如果以上方法都无法解决问题,并且你的任务确实需要海量内存，那么最直接的解决方案就是为你的计算机增加更多的 RAM。

如何监控内存使用情况

在开发过程中,了解程序的内存使用情况至关重要。

使用 memory_profiler 库

这是一个非常方便的第三方库,可以逐行分析代码的内存使用情况。

安装：

pip install memory_profiler

使用：

# your_script.py
from memory_profiler import profile
@profile
def my_function():
    a = [1] * (10 ** 6)
    b = [2] * (2 * 10 ** 6)
    del b
    return a
if __name__ == '__main__':
    my_function()

运行分析：

python -m memory_profiler your_script.py

输出会显示每一行代码的内存增量。

使用 tracemalloc 模块

Python 内置的 tracemalloc 模块可以跟踪内存分配，非常适合查找内存泄漏。

示例：

import tracemalloc
# 开始跟踪
tracemalloc.start()
# 创建一些对象
a = [i for i in range(100000)]
b = [i for i in range(500000)]
# 获取当前快照
snapshot1 = tracemalloc.take_snapshot()
# 删除一些对象，看看内存是否真的被释放
del b
# 获取另一个快照
snapshot2 = tracemalloc.take_snapshot()
# 比较两个快照
top_stats = snapshot2.compare_to(snapshot1, 'lineno')
print("[ Top 10 differences ]")
for stat in top_stats[:10]:
    print(stat)

面对 MemoryError，首先要冷静分析是哪个环节出了问题，然后根据具体原因选择最合适的优化策略。