Python高级技术之：描述`Python`的对象模型，解释`PyObject`、引用计数和垃圾回收机制的关系。 - 智猿学院-前后端，数据库，人工智能，云计算等领域前沿技术讲座

各位观众老爷们，大家好！今天咱们不聊风花雪月，就来扒一扒Python的底裤——哦不，是对象模型！别害怕，不是那种少儿不宜的东西，而是理解Python运行机制的关键所在。准备好了吗？咱们这就开始这场深入Python腹地的探险！

一、一切皆对象：Python的对象模型

在Python的世界里，有个至高无上的真理：一切皆对象！整数是对象，字符串是对象，函数是对象，甚至连类本身也是对象。听起来有点抽象？没关系，咱们举个例子。

a = 10
b = "Hello"
def my_function():
    pass

print(type(a))  # 输出: <class 'int'>
print(type(b))  # 输出: <class 'str'>
print(type(my_function)) # 输出: <class 'function'>
print(type(int)) # 输出: <class 'type'>

看到没？ a 是一个整数，它的类型是 int，b 是一个字符串，它的类型是 str，my_function 是一个函数，它的类型是 function。更厉害的是，连 int 本身也是一个对象，它的类型是 type！

那这个“对象”到底是个啥玩意儿呢？简单来说，对象就是内存中的一块区域，这块区域存储了数据和操作这些数据的方法。更具体点，一个Python对象包含三个主要部分：

身份（Identity）： 每个对象都有一个唯一的身份标识，相当于对象的身份证号。你可以用 id() 函数来获取对象的身份。这个身份一旦创建就不能更改，可以理解为对象的内存地址。
```
a = 10
print(id(a))  # 输出一个表示对象身份的整数
```
类型（Type）： 类型决定了对象可以进行哪些操作，以及对象包含哪些数据。你可以用 type() 函数来获取对象的类型。
```
a = 10
print(type(a))  # 输出: <class 'int'>
```
值（Value）： 对象存储的实际数据。

这三者之间的关系，就像一个人（对象）有身份证号（身份）、职业（类型）和名字（值）一样。

二、PyObject：对象的幕后英雄

Python是用C语言实现的，所以Python的对象在C语言层面实际上是一个结构体，这个结构体就是 PyObject。 PyObject 是所有Python对象的基类，也就是说，所有的Python对象都继承自 PyObject。

PyObject 的定义（简化版）大概是这样的：

typedef struct _object {
    Py_ssize_t ob_refcnt;
    struct _typeobject *ob_type;
} PyObject;

ob_refcnt：这是一个整数，表示对象的引用计数。后面我们会详细讲解引用计数。
ob_type：这是一个指针，指向对象的类型对象（PyTypeObject）。类型对象定义了对象的类型信息，包括对象的名称、大小、以及可以对对象执行的操作。

所以，从C语言的角度看，Python的对象其实就是一堆 PyObject 结构体，这些结构体通过指针相互关联，构成了Python的对象体系。

三、引用计数：对象的生死簿

现在，让我们来聊聊 ob_refcnt，也就是引用计数。引用计数是Python进行内存管理的一种重要机制。简单来说，每个对象都有一个引用计数，表示有多少个指针指向这个对象。

当创建一个新对象时，引用计数会被初始化为1。
当有一个新的指针指向对象时，引用计数会增加。
当有一个指针不再指向对象时，引用计数会减少。
当引用计数变为0时，对象就会被销毁，其占用的内存会被释放。

举个例子：

a = 10  # 创建一个整数对象，引用计数为1
b = a   # b也指向这个整数对象，引用计数增加到2
del a   # a不再指向这个整数对象，引用计数减少到1
del b   # b也不再指向这个整数对象，引用计数减少到0，对象被销毁

可以使用 sys.getrefcount() 函数来查看对象的引用计数（注意：sys.getrefcount() 本身也会增加引用计数）。

import sys

a = 10
print(sys.getrefcount(a))  # 输出一个大于1的数 (具体值取决于你的环境)

b = a
print(sys.getrefcount(a))  # 输出比上次输出的数大1

del a
print(sys.getrefcount(b))  # 输出比上次输出的数小1

del b
#  对象可能会被立即回收，也可能不会，取决于Python的垃圾回收机制

引用计数机制简单高效，可以及时回收不再使用的对象。但是，它也有一个致命的缺点：无法解决循环引用问题。

四、循环引用：引用计数的阿喀琉斯之踵

循环引用是指两个或多个对象相互引用，形成一个环状结构。在这种情况下，即使这些对象已经不再被程序使用，它们的引用计数也永远不会变为0，导致内存泄漏。

看个例子：

class MyClass:
    pass

obj1 = MyClass()
obj2 = MyClass()

obj1.reference = obj2  # obj1 引用 obj2
obj2.reference = obj1  # obj2 引用 obj1

del obj1
del obj2

# 此时 obj1 和 obj2 已经不再被外部引用，但是它们之间仍然相互引用，导致引用计数不为0，无法被回收。

在这个例子中，obj1 和 obj2 相互引用，形成了一个循环。即使我们删除了 obj1 和 obj2 的外部引用，它们的引用计数仍然为1，永远不会被回收。这就像两个人在拔河，谁也不松手，结果两个人就一直僵持在那里，浪费体力。

五、垃圾回收：拯救世界的英雄

为了解决循环引用问题，Python引入了垃圾回收机制。垃圾回收机制是一种更高级的内存管理方式，它可以检测并回收循环引用的对象。

Python的垃圾回收机制主要包含两个部分：

引用计数： 这是基础，前面已经讲过了。
分代回收： 这是核心，用来解决循环引用问题。

分代回收

分代回收的思想是：根据对象存活时间的长短，将对象划分为不同的代。新创建的对象属于第0代，经过一次垃圾回收仍然存活的对象会被移动到下一代。 Python的垃圾回收器会更频繁地回收第0代的对象，而较少回收第1代和第2代的对象。这是因为，一般来说，存活时间越长的对象，越有可能继续存活下去，所以不需要频繁地回收。

Python将所有对象分为三代。刚创建的对象是0代。如果该对象在一次垃圾回收后仍然存在，则将其放入1代。如果在后续的垃圾回收中它仍然存活，则将其移动到2代。垃圾回收器会更频繁地清理第0代，不太频繁地清理第1代，清理第2代的频率最低。

那么，垃圾回收器是如何检测循环引用的呢？它使用一种叫做可达性分析的算法。简单来说，垃圾回收器会从根对象（例如，全局变量、栈上的变量）开始，沿着引用链找到所有可达的对象。那些无法从根对象到达的对象，就被认为是垃圾，可以被回收。

垃圾回收器会定期运行，或者在内存不足时运行。你可以使用 gc 模块来控制垃圾回收的行为。

import gc

# 获取垃圾回收的阈值
print(gc.get_threshold())  # 输出: (700, 10, 10)

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

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

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

gc.get_threshold() 函数返回一个元组 (threshold0, threshold1, threshold2)，表示垃圾回收的阈值。

threshold0：表示第0代对象达到多少个时，触发第0代垃圾回收。
threshold1：表示第0代垃圾回收进行了多少次后，会触发第1代垃圾回收。
threshold2：表示第1代垃圾回收进行了多少次后，会触发第2代垃圾回收。

六、深入理解：代码示例和解释

为了更好地理解引用计数和垃圾回收，我们来看一个更复杂的例子：

import gc
import sys

class Node:
    def __init__(self, data):
        self.data = data
        self.next = None

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

a = Node(1)
b = Node(2)
a.next = b
b.next = a  # 循环引用

print("Initial reference counts:")
print("a:", sys.getrefcount(a))
print("b:", sys.getrefcount(b))

del a
del b

print("nAfter deleting a and b:")
# 由于循环引用，a和b仍然存在，并且引用计数大于1
# 注意 sys.getrefcount() 会增加引用计数，所以看到的计数比实际循环引用计数大
# sys.getrefcount() 会创建一个临时的引用，所以实际值会比你期望的高

# 重新启用垃圾回收
gc.enable()
gc.collect() # 执行垃圾回收

print("nAfter garbage collection:")
# 理论上，此时 a 和 b 应该已经被回收，但是由于已经del a, del b,所以没法直接判断是否回收成功
# 但可以通过查看对象的 __del__ 方法是否被调用来判断 (需要实现 __del__ 方法)
# 或者通过 weakref 来监控对象的生命周期

# 为了更准确地展示垃圾回收的效果，最好在对象中添加 __del__ 方法，并在其中打印信息
# 这样可以在垃圾回收发生时看到输出，确认对象已被回收

class NodeWithDel:
    def __init__(self, data):
        self.data = data
        self.next = None
    def __del__(self):
        print(f"Node with data {self.data} is being deleted") # 当对象被回收时，会打印这个消息

# 重新运行一次，并使用 NodeWithDel
gc.disable() # 再次禁用

a = NodeWithDel(1)
b = NodeWithDel(2)
a.next = b
b.next = a

print("nInitial reference counts (with __del__):")
print("a:", sys.getrefcount(a))
print("b:", sys.getrefcount(b))

del a
del b

print("nAfter deleting a and b (with __del__):")
gc.enable()
gc.collect() # 再次执行垃圾回收，此时会打印 __del__ 的消息

print("nDone.")

在这个例子中，我们创建了两个 Node 对象，并将它们相互引用，形成了一个循环引用。然后，我们删除了 a 和 b 的外部引用。由于循环引用的存在，a 和 b 的引用计数仍然不为0，无法被自动回收。

为了验证垃圾回收的效果，我们使用了 NodeWithDel 类，该类定义了 __del__ 方法。 __del__ 方法会在对象被销毁时自动调用。当我们执行 gc.collect() 时，垃圾回收器会检测到 a 和 b 之间的循环引用，并将它们回收，从而触发 __del__ 方法的调用，打印出相应的消息。

七、总结：Python对象模型的精髓

好了，经过一番折腾，我们终于扒完了Python对象模型的底裤。现在，让我们来总结一下：

一切皆对象： 在Python的世界里，所有东西都是对象。
PyObject： PyObject 是所有Python对象的基类，定义了对象的身份、类型和值。
引用计数： 引用计数是一种简单的内存管理机制，可以及时回收不再使用的对象。
循环引用： 循环引用是引用计数机制的缺陷，会导致内存泄漏。
垃圾回收： 垃圾回收机制可以检测并回收循环引用的对象，保证内存的有效利用。
分代回收： 分代回收是垃圾回收的核心，根据对象存活时间的长短，将对象划分为不同的代，并采用不同的回收策略。

希望通过今天的讲座，大家对Python的对象模型有了更深入的理解。掌握了这些知识，你就能更好地理解Python的运行机制，编写更高效、更健壮的代码。下次再有人问你Python的内存管理，你就再也不用怕啦！咱们下期再见！

发表回复 取消回复

发表回复取消回复