Orion K Blog
Python内存管理：深入理解Python的内存机制
Orion K Lv6
  2021-11-30 13:50:00  

Python内存管理：深入理解Python的内存机制

Python作为一种高级编程语言，为开发者处理了大部分内存管理工作，使我们可以专注于解决问题而不是内存分配和释放。然而，了解Python的内存管理机制对于编写高效、无内存泄漏的代码至关重要。在这篇文章中，我将深入探讨Python的内存管理机制，包括对象的生命周期、垃圾回收、内存池等概念。

Python内存管理的基础

Python中的一切都是对象

在Python中，一切都是对象，包括数字、字符串、函数、类等。每个对象都有三个基本属性：

  1. 标识（Identity）：对象在内存中的地址，可以通过id()函数获取
  2. 类型（Type）：对象的类型，决定了对象可以进行的操作和占用的内存，可以通过type()函数获取
  3. 值（Value）：对象的数据内容
1
2
3
4
x = 42
print(f"标识: {id(x)}")
print(f"类型: {type(x)}")
print(f"值: {x}")

可变对象与不可变对象

Python中的对象分为可变对象和不可变对象：

  • 不可变对象：一旦创建，其值就不能改变，如数字、字符串、元组
  • 可变对象：创建后可以修改其值，如列表、字典、集合

这种区别对内存管理有重要影响：

1
2
3
4
5
6
7
8
9
10
11
# 不可变对象
a = "hello"
print(id(a))  # 打印内存地址
a = a + " world"  # 创建新对象，而不是修改原对象
print(id(a))  # 打印新对象的内存地址，与之前不同

# 可变对象
b = [1, 2, 3]
print(id(b))  # 打印内存地址
b.append(4)  # 修改原对象
print(id(b))  # 打印内存地址，与之前相同

引用计数机制

Python的内存管理主要基于引用计数机制。每个对象都有一个引用计数，表示指向该对象的引用数量。

引用计数的工作原理

  • 当对象被创建或被引用时，引用计数加1
  • 当对象的引用被删除或超出作用域时，引用计数减1
  • 当引用计数为0时，对象被销毁，内存被回收
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import sys

# 创建对象，引用计数为1
a = [1, 2, 3]
print(sys.getrefcount(a) - 1)  # getrefcount本身会创建一个临时引用，所以减1

# 创建另一个引用，引用计数为2
b = a
print(sys.getrefcount(a) - 1)

# 删除一个引用，引用计数为1
del b
print(sys.getrefcount(a) - 1)

# 函数结束后，a超出作用域，引用计数为0，对象被回收

循环引用问题

引用计数机制的一个主要缺点是无法处理循环引用。当两个或多个对象相互引用时，即使它们不再被程序使用，它们的引用计数也不会变为0，导致内存泄漏：

1
2
3
4
5
6
7
8
9
10
11
12
def create_cycle():
    # 创建两个相互引用的列表
    a = []
    b = []
    a.append(b)  # a引用b
    b.append(a)  # b引用a
    
    # 函数结束后，a和b的引用计数都为1（相互引用）
    # 尽管它们不再被程序使用，但不会被回收

# 调用函数
create_cycle()

为了解决这个问题，Python引入了循环垃圾收集器。

垃圾回收机制

Python的垃圾回收机制包括三个部分：

  1. 引用计数：主要的垃圾回收机制
  2. 循环垃圾收集器：处理循环引用
  3. 内存池：优化小对象的内存分配和释放

循环垃圾收集器

Python的循环垃圾收集器使用”标记-清除”算法来检测和回收循环引用的对象：

  1. 收集所有容器对象（可能产生循环引用的对象）
  2. 检测这些对象之间的循环引用
  3. 回收没有外部引用的循环引用对象
1
2
3
4
5
6
7
8
9
10
11
12
13
import gc

# 查看垃圾回收阈值
print(gc.get_threshold())  # 默认为(700, 10, 10)

# 手动触发垃圾回收
gc.collect()

# 禁用自动垃圾回收
gc.disable()

# 启用自动垃圾回收
gc.enable()

分代垃圾回收

Python的垃圾回收器使用分代回收策略，将对象分为三代：

  • 第0代：新创建的对象
  • 第1代：经过一次垃圾回收后仍然存活的对象
  • 第2代：经过两次垃圾回收后仍然存活的对象

每一代都有自己的阈值，当达到阈值时触发垃圾回收。这种策略基于”新对象容易死，老对象往往长寿”的经验法则，提高了垃圾回收的效率。

1
2
3
4
5
6
7
# 查看当前各代对象数量
print(gc.get_count())

# 手动触发特定代的垃圾回收
gc.collect(0)  # 只回收第0代
gc.collect(1)  # 只回收第1代
gc.collect(2)  # 只回收第2代

内存池机制

为了提高小对象的分配和释放效率，Python实现了内存池机制。

小整数对象池

Python预先分配了[-5, 256]范围内的整数对象，这些对象是单例的，多次创建相同的小整数实际上会返回同一个对象：

1
2
3
4
5
6
7
a = 42
b = 42
print(a is b)  # True，a和b引用同一个对象

c = 1000
d = 1000
print(c is d)  # False，超出小整数池范围，是不同对象

字符串驻留

Python也对字符串进行了优化，相同的字符串字面量会被驻留（interned）为同一个对象：

1
2
3
4
5
6
7
a = "hello"
b = "hello"
print(a is b)  # True，a和b引用同一个对象

# 但动态创建的字符串不一定会被驻留
c = "".join(["h", "e", "l", "l", "o"])
print(a is c)  # 可能是False，取决于Python实现

PyMalloc分配器

Python使用自己的内存分配器（PyMalloc）来管理小对象（小于512字节）的内存分配。PyMalloc维护了不同大小的内存池，减少了系统调用的开销，提高了内存分配的效率。

内存泄漏的常见原因

尽管Python有自动垃圾回收机制，但仍然可能发生内存泄漏：

1. 循环引用中包含__del__方法

如果循环引用中的对象定义了__del__方法，垃圾回收器无法安全地决定销毁顺序，会将这些对象放入gc.garbage列表而不是回收它们：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
class A:
    def __init__(self):
        self.b = None
    
    def __del__(self):
        print("A被销毁")

class B:
    def __init__(self):
        self.a = None
    
    def __del__(self):
        print("B被销毁")

# 创建循环引用
a = A()
b = B()
a.b = b
b.a = a

# 删除外部引用
del a
del b

# 手动触发垃圾回收
import gc
gc.collect()

# 查看未回收的对象
print(len(gc.garbage))

2. 全局变量和单例

全局变量和单例在程序运行期间一直存在，如果它们持有大量数据，会占用内存直到程序结束：

1
2
3
4
5
6
7
8
9
10
# 全局缓存
_cache = {}

def get_data(key):
    if key not in _cache:
        # 获取数据（可能很大）
        _cache[key] = load_data(key)
    return _cache[key]

# 如果不清理缓存，它会一直增长

3. 闭包和函数属性

闭包会保留外部函数的变量，如果这些变量引用了大对象，可能导致内存泄漏：

1
2
3
4
5
6
7
8
9
10
11
12
def create_multipliers():
    # 一个大列表
    big_list = [i for i in range(100000)]
    
    def multiply(n):
        # 闭包引用了big_list，即使不使用它
        return n * 2
    
    return multiply

# 即使我们只需要multiply函数，big_list也会被保留在内存中
multiplier = create_multipliers()

4. 未关闭的文件和网络连接

未正确关闭的文件、网络连接等资源可能导致内存泄漏：

1
2
3
4
5
6
7
8
9
10
11
def read_file(filename):
    f = open(filename, 'r')
    content = f.read()
    # 忘记关闭文件
    return content

# 正确的做法是使用with语句
def read_file_correctly(filename):
    with open(filename, 'r') as f:
        content = f.read()
    return content

内存优化技巧

了解Python的内存管理机制后，我们可以使用一些技巧来优化内存使用：

1. 使用生成器和迭代器

对于大数据集，使用生成器和迭代器可以避免一次性加载所有数据到内存：

1
2
3
4
5
6
7
8
9
10
11
12
13
# 不好的做法：一次性加载所有数据
def process_large_file(filename):
    with open(filename, 'r') as f:
        lines = f.readlines()  # 加载所有行到内存
    
    for line in lines:
        process_line(line)

# 好的做法：使用生成器逐行处理
def process_large_file_efficiently(filename):
    with open(filename, 'r') as f:
        for line in f:  # 文件对象是一个迭代器，逐行读取
            process_line(line)

2. 使用__slots__

对于创建大量实例的类，使用__slots__可以显著减少内存使用：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
# 普通类
class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

# 使用__slots__的类
class PersonWithSlots:
    __slots__ = ['name', 'age']
    
    def __init__(self, name, age):
        self.name = name
        self.age = age

# 比较内存使用
import sys
p1 = Person("Alice", 30)
p2 = PersonWithSlots("Alice", 30)
print(sys.getsizeof(p1.__dict__))  # 普通类实例的字典
print(sys.getsizeof(p2))  # __slots__类实例没有__dict__

3. 使用弱引用

当需要缓存对象但不想阻止它们被垃圾回收时，可以使用弱引用：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
import weakref

class Cache:
    def __init__(self):
        # 使用WeakValueDictionary而不是普通字典
        self._cache = weakref.WeakValueDictionary()
    
    def get(self, key):
        return self._cache.get(key)
    
    def set(self, key, value):
        self._cache[key] = value

# 当对象不再被其他地方引用时，它会自动从缓存中移除

4. 及时释放不再需要的引用

显式删除不再需要的大对象引用，可以帮助垃圾回收器更快地回收内存：

1
2
3
4
5
6
7
8
9
def process_data(data):
    # 处理数据
    result = do_something_with(data)
    
    # 显式删除不再需要的大对象
    del data
    
    # 继续处理
    return post_process(result)

5. 使用NumPy和Pandas等专业库

对于数值计算和数据处理，使用NumPy和Pandas等专业库可以显著减少内存使用：

1
2
3
4
5
6
7
8
9
10
11
import numpy as np

# 普通Python列表
python_list = [[i for i in range(1000)] for _ in range(1000)]

# NumPy数组
numpy_array = np.arange(1000000).reshape(1000, 1000)

import sys
print(f"Python列表内存: {sys.getsizeof(python_list) + sum(sys.getsizeof(row) for row in python_list)}")
print(f"NumPy数组内存: {sys.getsizeof(numpy_array) + numpy_array.nbytes}")

内存分析工具

当遇到内存问题时，以下工具可以帮助分析和解决：

1. memory_profiler

memory_profiler可以逐行分析Python代码的内存使用：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
# 安装：pip install memory_profiler

# 使用装饰器分析函数
from memory_profiler import profile

@profile
def my_function():
    a = [1] * (10 ** 6)
    b = [2] * (2 * 10 ** 7)
    del b
    return a

if __name__ == '__main__':
    my_function()

2. objgraph

objgraph可以帮助可视化对象引用关系，特别适合分析循环引用：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
# 安装：pip install objgraph

import objgraph

# 创建一些对象
a = [1, 2, 3]
b = [4, 5, 6]
a.append(b)
b.append(a)

# 查找循环引用
objgraph.show_backrefs([a], filename='cycle.png')

# 查看最常见的对象类型
objgraph.show_most_common_types()

# 查看特定类型对象的增长
objgraph.show_growth()

3. tracemalloc

Python 3.4引入的tracemalloc模块可以跟踪Python对象的内存分配：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
import tracemalloc

# 启动跟踪
tracemalloc.start()

# 运行代码
a = [1] * (10 ** 6)
b = [2] * (2 * 10 ** 7)

# 获取当前快照
snapshot = tracemalloc.take_snapshot()
top_stats = snapshot.statistics('lineno')

# 打印前10个内存块
for stat in top_stats[:10]:
    print(stat)

4. pympler

pympler提供了更多内存分析功能：

1
2
3
4
5
6
7
8
9
10
11
12
13
# 安装：pip install pympler

from pympler import asizeof, tracker

# 精确计算对象大小
a = [1, 2, [3, 4, [5, 6]]]
print(asizeof.asizeof(a))

# 跟踪内存变化
tr = tracker.SummaryTracker()
a = [1] * 1000
b = {i: i for i in range(1000)}
tr.print_diff()

结论

Python的内存管理机制是一个复杂而精妙的系统，它通过引用计数、垃圾回收和内存池等机制，为开发者提供了高效、自动的内存管理。了解这些机制不仅有助于编写更高效的代码，还能帮助我们诊断和解决内存相关的问题。

虽然Python的自动内存管理让我们不必像C/C++那样手动分配和释放内存，但这并不意味着我们可以完全忽视内存管理。通过合理使用数据结构、避免循环引用、及时释放大对象等技巧，我们可以让Python程序更加高效地使用内存。

你有什么关于Python内存管理的问题或经验分享吗？欢迎在评论中讨论！

  1. Python内存管理：深入理解Python的内存机制
    1. Python内存管理的基础
      1. Python中的一切都是对象
      2. 可变对象与不可变对象
    2. 引用计数机制
      1. 引用计数的工作原理
      2. 循环引用问题
    3. 垃圾回收机制
      1. 循环垃圾收集器
      2. 分代垃圾回收
    4. 内存池机制
      1. 小整数对象池
      2. 字符串驻留
      3. PyMalloc分配器
    5. 内存泄漏的常见原因
      1. 1. 循环引用中包含__del__方法
      2. 2. 全局变量和单例
      3. 3. 闭包和函数属性
      4. 4. 未关闭的文件和网络连接
    6. 内存优化技巧
      1. 1. 使用生成器和迭代器
      2. 2. 使用__slots__
      3. 3. 使用弱引用
      4. 4. 及时释放不再需要的引用
      5. 5. 使用NumPy和Pandas等专业库
    7. 内存分析工具
      1. 1. memory_profiler
      2. 2. objgraph
      3. 3. tracemalloc
      4. 4. pympler
    8. 结论
© 2025    Orion K
本站由 提供部署服务
  1. Python内存管理：深入理解Python的内存机制
    1. Python内存管理的基础
      1. Python中的一切都是对象
      2. 可变对象与不可变对象
    2. 引用计数机制
      1. 引用计数的工作原理
      2. 循环引用问题
    3. 垃圾回收机制
      1. 循环垃圾收集器
      2. 分代垃圾回收
    4. 内存池机制
      1. 小整数对象池
      2. 字符串驻留
      3. PyMalloc分配器
    5. 内存泄漏的常见原因
      1. 1. 循环引用中包含__del__方法
      2. 2. 全局变量和单例
      3. 3. 闭包和函数属性
      4. 4. 未关闭的文件和网络连接
    6. 内存优化技巧
      1. 1. 使用生成器和迭代器
      2. 2. 使用__slots__
      3. 3. 使用弱引用
      4. 4. 及时释放不再需要的引用
      5. 5. 使用NumPy和Pandas等专业库
    7. 内存分析工具
      1. 1. memory_profiler
      2. 2. objgraph
      3. 3. tracemalloc
      4. 4. pympler
    8. 结论