别再说Python费内存了:这5个内置技巧让你省下80%资源

上周，一位读者给我发来私信，语气里透着无奈：

“哥，我写了个爬虫，用来分析电商平台的历史价格数据。逻辑跑起来没问题，但就是内存蹭蹭往上涨，跑不到一半，程序就‘out of memory’崩溃了。我是不是选错语言了？难道这种活儿真得用C++？”

这个问题你是不是也遇到过？当你满怀信心地用Python处理“百万级”数据时，程序却像吃豆人一样，一口一口吞掉你所有的内存，最后卡死在那里。

很多人觉得Python天生“费内存”，不如C语言那样精打细算。但真相是，Python本身藏着一整套“内存管家”工具，只是90%的开发者都不知道怎么用。今天，我就带你把这套工具翻出来，让你的Python程序也能在内存里“精打细算”。

我们先从最基本的开始：怎么给你的内存“把把脉”？

第一步：给内存做个“CT”，看清谁在吃资源

优化前，我们必须先定位问题。Python有几个非常好用的“内窥镜”：

import numpy as np
import sys
import psutil

# 创建一个“大胖子”对象
ob = np.ones((1024, 1024, 1024, 3), dtype=np.uint8)  # 一个 1G 左右的数组

# 1. 查看单个对象的确切大小（单位：字节）
print(f"对象 ob 占用内存: {sys.getsizeof(ob) / (1024 * 1024):.2f} MB")
# 输出示例：对象 ob 占用内存: 3072.00 MB

# 2. 查看当前Python进程总共占了多少内存（包括库和其他对象）
process = psutil.Process()
print(f"整个进程占用内存: {process.memory_info().rss / (1024 * 1024):.2f} MB")
# 输出示例：整个进程占用内存: 3234.19 MB

# 3. 对于Pandas用户，info()是最好的快速诊断工具
import pandas as pd
# data = pd.read_csv('large_file.csv')
# print(data.info(verbose=False, memory_usage='deep')) # 会显示深度内存分析

⚠️ 注意：sys.getsizeof() 是个“近视眼”，它只计算对象本身占用的内存，对于列表或字典，它不会计算其内部元素占用的内存。要算总账，需要手动累加或使用 tracemalloc 这类高级工具。

现在，我们手里有了“诊断报告”，就可以开始对症下药了。

技巧一：用 __slots__ 给类对象“瘦身”

Python的类之所以灵活，允许我们随时给实例添加新属性（比如 me.job = 'Engineer'），是因为每个实例内部都维护着一个字典——__dict__。

你可以把 __dict__ 想象成每个人身上都背着一个巨大的、可随时贴标签的空箱子。虽然方便，但这个箱子本身就很重。

生活化类比：

• 普通类：就像公司给每个员工发了一个巨大的空文件柜（__dict__），你可以在里面随便塞东西，但文件柜本身占地方。
• 用了 __slots__ 的类：公司直接给员工发了一个固定的工位（固定属性），工位上有几个固定的抽屉（name、age），抽屉只能放指定物品。空间利用率瞬间提高。

当我们需要创建成千上万个对象时（比如电商订单、用户会话），去掉这个“大箱子”能省下巨量内存。

import sys

classArticle:# 普通类
def__init__(self, title, word_count):
        self.title = title
        self.word_count = word_count

classArticleWithSlots:# 带 __slots__ 的类
    __slots__ = ['title', 'word_count']
def__init__(self, title, word_count):
        self.title = title
        self.word_count = word_count

# 分别创建实例
a1 = Article('Memory Issue', 1500)
a2 = ArticleWithSlots('Memory Solved', 1500)

# 计算内存占用
memory_normal = sys.getsizeof(a1) + sys.getsizeof(a1.__dict__)
memory_slots = sys.getsizeof(a2)  # 注意：slots类没有__dict__属性

print(f"普通实例总大小: {memory_normal} 字节") # 输出: 普通实例总大小: 152 字节
print(f"Slots实例总大小: {memory_slots} 字节")  # 输出: Slots实例总大小: 48 字节

# 验证
print(a1.__dict__)  # {'title': 'Memory Issue', 'word_count': 1500}
# print(a2.__dict__)  # 直接报错：AttributeError，因为没有__dict__

国内实践： 如果你在用Python 3.10+，写数据类（Data Class）时可以更优雅地结合 __slots__：

from dataclasses import dataclass

@dataclass(slots=True)  # 只需加上 slots=True
classWeChatUser:
    openid: str
    nickname: str
    follow_time: int

这种方式既保留了数据类的简洁，又享受了 __slots__ 的内存优势，在微信小程序的后端开发中，用来存储海量用户会话非常实用。

技巧二：生成器——把“大清单”变成“流水线”

处理数据时，我们习惯用列表推导式：[i for i in range(1000000)]。这在内存里瞬间创建了一个包含100万个元素的列表。如果你的数据有上亿条，内存瞬间爆炸。

生活化类比：

• 列表：像是一家餐厅，一次性把未来一年要用的所有食材全部采购回来，堆满整个仓库（内存）。
• 生成器：像是一家精益餐厅，每天早晨只采购当天要用的食材，用一点买一点。

生成器就是这样一个“按需生产”的流水线，它不存储所有数据，只存储生产数据的“配方”。

import sys

# 列表：一次性生成所有数字
list_numbers = [i for i in range(10000)]
print(f"列表占用内存: {sys.getsizeof(list_numbers)} 字节")  # 输出较大，如 87616 字节

# 生成器表达式：就是一个配方，不生成具体数字
generator_numbers = (i for i in range(10000))  # 注意是小括号
print(f"生成器占用内存: {sys.getsizeof(generator_numbers)} 字节")  # 输出很小，固定值，如 112 字节

# 需要数据时，一个一个取
for num in generator_numbers:
if num > 5:
break# 用多少，取多少

最佳实践： 在处理日志文件分析时，这种优势尤其明显。比如你要从一个10GB的日志文件中找出所有报错的行：

# 🚫 Bad Practice: 会一次性把10GB文件全部读入内存
with open('access.log', 'r') as f:
    error_lines = [line for line in f if'ERROR'in line]  # 内存直接爆掉

# ✅ Good Practice: 生成器配合 any()，逐行判断，找到即止
with open('access.log', 'r') as f:
    has_error = any('ERROR'in line for line in f)  # 内存占用几乎为0
print(has_error)

⚠️ 注意：生成器是一次性的。遍历完后，它就“空”了，不能重复使用。如果需要反复读取，要么重新创建生成器，要么转为列表存储。

技巧三：内存映射（mmap）——让大文件“看起来”在内存里

有时候，我们的数据太大了，大到内存根本装不下（比如几十GB的卫星影像、基因测序数据）。传统的 f.read() 会把整个文件塞进内存，这无异于自杀式袭击。

内存映射文件（mmap）是一种操作系统级别的黑科技。它像变魔术一样，在进程的虚拟内存地址空间里“画”出一块区域，然后说：“这块区域就代表这个大文件。”

程序访问这块内存时，操作系统才去磁盘上读取对应的那一小块数据。感觉像是在操作内存，实际上内存里只存放了最近访问过的极小一部分文件内容。

import mmap

# 假设有一个巨大的文件 'massive_dataset.bin'
with open('massive_dataset.bin', 'r+b') as f:
# 创建内存映射，length=0 表示映射整个文件
with mmap.mmap(f.fileno(), length=0, access=mmap.ACCESS_READ) as mm:
# 现在可以像操作字节串一样操作 mm
        print(f"文件的前10个字节: {mm[:10]}")

# 查找特定模式的位置
        pos = mm.find(b'ERROR')
if pos != -1:
# 从该位置读取1024字节
            mm.seek(pos)
            data_chunk = mm.read(1024)
# 处理这一小块数据...

应用场景：

• 高并发配置读取：在游戏服务器或金融交易系统中，配置文件可能很大且需要频繁读取。用 mmap 载入一次，所有进程共享这块内存映射，既快又省内存。
• 大数据预处理：在训练AI模型前，需要快速扫描和筛选TB级别的数据集，mmap 是目前最优雅的方案。

技巧四：选择“会过日子”的数据类型

Python的数据类型选择，就像装修选家具，选对了能省下一半空间。

1. 元组（Tuple） vs 列表（List）元组是不可变的，一旦创建就不能修改。Python 知道它不会变，就给它分配一个固定大小的、紧凑的内存空间。而列表为了支持未来的 append 和 insert，会预先申请一大块额外空间。

import sys
a_tuple = (1, 2, 3, 4, 5)
a_list = [1, 2, 3, 4, 5]
print(f"元组大小: {sys.getsizeof(a_tuple)} 字节")  # 输出: 80
print(f"列表大小: {sys.getsizeof(a_list)} 字节")   # 输出: 120

如果你的数据是只读的，请毫不犹豫地使用元组。

2. 数组（Array） vs 列表（List）列表可以装不同类型的对象（int, str, float...），每个元素都是一个独立的Python对象，内存开销巨大。而 array 模块要求所有元素是同一类型（如全部整型），它在内存里像C语言数组一样紧凑存储。

import sys
import array

# 列表：每个整数都是一个完整的Python对象
py_list = [i for i in range(1000)]
# 数组：只存储原始的二进制数值
arr = array.array('i', [i for i in range(1000)])  # 'i' 表示有符号整型

print(f"列表大小: {sys.getsizeof(py_list)} 字节")  # 输出约 8856
print(f"数组大小: {sys.getsizeof(arr)} 字节")     # 输出约 4064，节省一半以上

当然，在数据科学领域，NumPy的 ndarray 和 Pandas的 DataFrame 在内存布局上做了更极致的优化，是处理多维数组的首选。

技巧五：字符串驻留（String Interning）——让相同的字符串“合体”

这是一个非常隐蔽但又惊艳的特性。

我们写代码时，经常用到相同的字符串常量，比如字典的键、对象的属性名。Python会偷偷地把一些短小的字符串（只包含字母、数字、下划线）缓存起来。当你在另一个地方定义完全相同的字符串时，Python直接让新变量指向缓存里的那个对象，而不是再创建一个新的。

>>> a = "hello_world"
>>> b = "hello_world"
>>> a is b  # 检查是否指向同一个对象
True# 说明Python没有创建新对象，复用了

>>> c = "hello world!"# 包含空格和标点，不符合隐式驻留规则
>>> d = "hello world!"
>>> c is d
False# 创建了两个不同的对象

这个神奇的阈值在CPython中默认是4096个字符。超过这个长度的字符串，即便内容一样，也不会自动复用。

如果需要强制复用，可以用 sys.intern()：

import sys
e = sys.intern("这是一个非常非常长的句子，超过了4096个字符，但我们希望它在内存里只有一份...")
f = sys.intern("这是一个非常非常长的句子，超过了4096个字符，但我们希望它在内存里只有一份...")
print(e is f)  # True

在处理大量重复的文本数据（如NLP任务中的词表、数据库查询出的重复状态字段）时，主动使用 sys.intern() 能极大减少内存占用。

避坑指南 & 核心回顾

⚠️ 避坑：__slots__ 不是银弹

• 滥用：如果类属性动态变化很强，或者你本来就只创建少量实例，用 __slots__ 带来的收益微乎其微，反而会让代码失去灵活性。
• 继承陷阱：子类如果没定义 __slots__，它依然会有 __dict__。多继承时，__slots__ 的行为会更复杂，需查阅文档。

核心记忆点（方便你转发给同事）：

1. 看医生：优化前先用 sys.getsizeof 和 psutil 做内存诊断，别瞎猜。
2. 当管家：对大量实例用 __slots__ 封存属性；对大数据集用生成器（Generator）代替列表；对超大文件用 mmap 做内存映射。
3. 会算计：不可变数据用元组（Tuple），同质数据用数组（Array），重复字符串用驻留（Intern）。

写在最后

Python 并不是天生就“浪费内存”，只是它的动态性和易用性，让我们在不知不觉中大手大脚。今天介绍的这几个技巧，都是 Python 内置的、无需安装第三方库就能使用的“省钱利器”。

作为开发者，我们既要享受 Python 带来的开发效率，也要学会为它的“奢侈”买单——通过理解原理、精打细算，让每一寸内存都物尽其用。

你在实际项目里，还遇到过哪些奇葩的内存暴涨问题？或者你有自己独门的内存优化“偏方”？欢迎在评论区分享，我们一起看看谁的办法最硬核。

参考资料：

[^1]: Python 官方文档 - tracemalloc
[^2]: Python 3.10+ dataclass 新特性
[^3]: Real Python - Generator Expressions Best Practices
[^4]: 华为云社区 - 使用 Python 的 mmap 模块高效处理大文件
[^5]: Real Python - mmap: Memory-Mapped File Support
[^6]: 深入理解 Python 字符串驻留机制