Exemple détaillé de destruction et de libération d'objets de classe Python

Cet article vous apporte des connaissances pertinentes sur Python, qui présente principalement la démonstration de code pour la destruction et la libération des objets de classe Python. L'article présente le sujet en détail. Examinons-le ensemble, j'espère que cela vous sera utile. tout le monde aide.

【Recommandation associée : Tutoriel vidéo Python3】

1. Constructeur et destructeur de classe

• La fonction _init__ est le constructeur de la classe Python, lors de la création d'une classe lorsqu'un objet est créé, cette fonction sera automatiquement appelée ; elle peut être utilisée pour définir certaines informations d'initialisation et paramètres de l'objet lors de la création de l'objet.
_init__ 函数是python 类的构造函数，在创建一个类对象的时候，就会自动调用该函数；可以用来在创建对象的时候，设置该对象的一些初始化信息和设置。
• __del__ 函数是python 类的析构函数，在一个类对象生命周期结束、被销毁的时候，就会自动调用该函数；主要用来释放对象占用的一些资源等。

二、代码演示

1. 引用的更迭

如下，编写了一个 demo 类的实现代码。

>>> class demo():
...     def __init__(self):
...             print("init class")
...             print(self)
...     def __del__(self):
...             print("del class")
...             print(self)
... 
>>>

该类对象在创建的时候，会调用 __init__函数，打印出 “init class”；
该类对象在销毁的时候，会调用 __del__函数，打印出 “del class”。

>>> a1 = demo()
init class
<__main__.demo instance at 0x7f328f7c6cb0>
>>> 
>>> a2 = demo()  
init class
<__main__.demo instance at 0x7f328f7c6d40>
>>> 
>>> 
>>> 
>>> a1 = demo()
init class
<__main__.demo instance at 0x7f328f7c6d88>
del class
<__main__.demo instance at 0x7f328f7c6cb0>
>>>

首先使用变量 a1 引用一个 demo 类对象，此时打印出"init class"，以及a1 变量所引用的对象地址 0x7f328f7c6cb0；

使用变量 a2 引用另外的一个 demo 类对象，此时打印出"init class"，以及a2 变量所引用的对象地址 0x7f328f7c6d40；

a1 和 a2 变量所引用的类对象是不同的两个对象 0x7f328f7c6cb0 和 0x7f328f7c6d40。

最后创建一个 demo 类对象，再次使用 a1 变量来指向，此时 a1 引用了新的类对象，引用地址为 0x7f328f7c6d88；同时，由于之前 a1 引用的对象0x7f328f7c6cb0 不再有人引用它，因此旧的 demo 类对象的空间被释放，打印出了 “del class 0x7f328f7c6cb0”。

2. 只在函数内部的类对象

>>> def create_demo():
...     inst = demo()
... 
>>> create_demo()
init class
<__main__.demo instance at 0x7f328f7c6cb0>
del class
<__main__.demo instance at 0x7f328f7c6cb0>
>>> 
>>> 
>>> 
>>> create_demo()
init class
<__main__.demo instance at 0x7f328f7c6cb0>
del class
<__main__.demo instance at 0x7f328f7c6cb0>
>>> 
>>> 
>>> 
>>> create_demo()
init class
<__main__.demo instance at 0x7f328f7c6cb0>
del class
<__main__.demo instance at 0x7f328f7c6cb0>
>>>

定义一个函数 create_demo，该函数的作用是创建一个 demo 类对象，并且使用 inst 变量来引用创建的类对象。

调用一次 create_demo() 函数，可以看到，demo 对象被创建，地址为 0x7f328f7c6cb0；接着该 demo 对象立即被释放；因为该对象只在 create_demo 函数范围内有效，函数结束，demo 对象就被回收释放。

再调用一次 create_demo() 函数，现象相同：demo 对象被创建，地址为 0x7f328f7c6cb0；接着该 demo 对象立即被释放。

三、函数内部返回的类对象

>>> def return_demo():
...     return demo()
...

定义函数 return_demo，该函数内部创建类对象，并且返回创建出的类对象。

>>> True
True
>>> return_demo()
init class
<__main__.demo instance at 0x7fc511eb8cb0>
<__main__.demo instance at 0x7fc511eb8cb0>
>>> 
>>> True
del class
<__main__.demo instance at 0x7fc511eb8cb0>
True
>>> 
>>> return_demo()
init class
<__main__.demo instance at 0x7fc511eb8cb0>
<__main__.demo instance at 0x7fc511eb8cb0>
>>> 
>>> 
>>> 
>>> True
del class
<__main__.demo instance at 0x7fc511eb8cb0>
True
>>> 
>>>

可以看到，第一次调用函数 return_demo()，打印的内容显示，此时创建了一个对象，对象地址为 0x7fc511eb8cb0；函数 return_demo 内部使用 return 语句返回创建的类对象，因此函数返回时，不会释放对象 0x7fc511eb8cb0。

接着，执行一条 Python 语句：True，同时看到对象 0x7fc511eb8cb0 被释放。因为程序执行完 return_demo() 函数之后，发现后面的程序并没有引用 return_demo() 返回的对象，因此 Python 便会释放对象空间 0x7fc511eb8cb0。

第二次执行相同的操作，可以看到现象相同。

>>> v1_demo = None
>>> v2_demo = None 
>>> print(v1_demo)
None
>>> print(v2_demo)
None
>>> True
True
>>> 
>>> v1_demo = return_demo() 
init class
<__main__.demo instance at 0x7fc511eb8d88>
>>> 
>>> print(v1_demo)
<__main__.demo instance at 0x7fc511eb8d88>
>>> 
>>> True
True
>>> 
>>> 
>>> v2_demo = return_demo()  
init class
<__main__.demo instance at 0x7fc511eb8dd0>
>>> 
>>> print(v2_demo)
<__main__.demo instance at 0x7fc511eb8dd0>
>>> True
True
>>> 
>>> 
>>> 
>>> 
>>> v1_demo = None
del class
<__main__.demo instance at 0x7fc511eb8d88>
>>> 
>>> print(v1_demo)
None
>>>

该代码段的现象和上个代码段的现象基本相同。

可以看到，v1_demo 和 v2_demo 引用了类对象，所以 v1_demo 和 v2_demo 的值不再是 None。

最后，我们让 v1_demo 重新为 None。此时，v1_demo 引用的对象 0x7fc511eb8d88__del__ La fonction est le destructeur de la classe Python Lorsque le cycle de vie d'un objet de classe se termine et est détruit, cette fonction sera automatiquement appelée, elle est principalement utilisée pour en libérer ; de l'espace occupé par l'objet, etc.

2. Démonstration de code

1. Les changements de référence

sont les suivants, et le code d'implémentation d'une classe de démonstration est écrit.

>>> g_demo = None
>>> print(g_demo)
None
>>> 
>>> def return_gdemo():    
...     global g_demo
...     g_demo = demo()
... 
>>> 
>>> print(g_demo)
None
>>> return_gdemo()
init class
<__main__.demo instance at 0x7fc511eb8d88>
>>> 
>>> print(g_demo)
<__main__.demo instance at 0x7fc511eb8d88>
>>> 
>>> True
True
>>>

Lorsque cet objet de classe sera créé, il appellera la fonction __init__ et affichera "init class" ;
Lorsque cet objet de classe sera détruit, il appellera __del__ fonction, imprimez "del class". 🎜rrreee🎜Utilisez d'abord la variable a1 pour faire référence à un objet de classe de démonstration. À ce moment, imprimez la "classe init" et l'adresse de l'objet référencée par la variable a1 <code>0x7f328f7c6cb0 ; vers un autre objet de classe de démonstration, imprimez à ce moment "init class", et l'adresse de l'objet référencée par la variable a2 0x7f328f7c6d40 ; 🎜🎜Les objets de classe référencés par les variables a1 et a2 sont deux objets différents. 0x7f328f7c6cb0 et <code>0x7f328f7c6d40. 🎜🎜Enfin, créez un objet de classe de démonstration et utilisez la variable a1 pour pointer à nouveau vers lui. À ce stade, a1 fait référence au nouvel objet de classe et l'adresse de référence est 0x7f328f7c6d88 ; car l'objet référencé par a1 auparavant est 0x7f328f7c6cb0 Personne n'y fait plus référence, donc l'espace de l'ancien objet de classe démo est libéré, en imprimant "del class 0x7f328f7c6cb0". 🎜🎜2. L'objet de classe uniquement à l'intérieur de la fonction🎜rrreee🎜Définissez une fonction create_demo. La fonction de cette fonction est de créer un objet de classe de démonstration et d'utiliser la variable inst pour faire référence à l'objet de classe créé. 🎜🎜Appelez la fonction create_demo() une fois. Vous pouvez voir que l'objet de démonstration est créé avec l'adresse 0x7f328f7c6cb0 ; fonction create_demo, la fonction se termine, l'objet de démonstration est recyclé et libéré. 🎜🎜Appelez à nouveau la fonction create_demo(), le phénomène est le même : l'objet démo est créé, l'adresse est 0x7f328f7c6cb0 puis l'objet démo est libéré immédiatement. 🎜🎜3. L'objet de classe renvoyé à l'intérieur de la fonction 🎜rrreee🎜 Définissez la fonction return_demo, qui crée un objet de classe en interne et renvoie l'objet de classe créé. 🎜rrreee🎜Vous pouvez voir que lorsque la fonction return_demo() est appelée pour la première fois, le contenu imprimé montre qu'un objet est créé à ce moment-là, et l'adresse de l'objet est 0x7fc511eb8cb0 ; utilise return en interne. L'instruction code> renvoie l'objet de classe créé, donc l'objet 0x7fc511eb8cb0 ne sera pas libéré au retour de la fonction. 🎜🎜Ensuite, exécutez une instruction Python : True, et voyez que l'objet 0x7fc511eb8cb0 est libéré. Parce qu'après que le programme a exécuté la fonction return_demo(), il s'avère que le programme suivant ne fait pas référence à l'objet renvoyé par return_demo(), donc Python libérera l'espace objet 0x7fc511eb8cb0. 🎜🎜Effectuez la même opération une deuxième fois et vous pourrez constater le même phénomène. 🎜rrreee🎜Le phénomène de cet extrait de code est fondamentalement le même que celui de l'extrait de code précédent. 🎜🎜Vous pouvez voir que v1_demo et v2_demo font référence à l'objet de classe, donc les valeurs de v1_demo et v2_demo ne sont plus Aucun. 🎜🎜Enfin, nous réinitialisons v1_demo sur Aucun. A ce moment, l'objet 0x7fc511eb8d88 référencé par v1_demo est publié. 🎜🎜1. Utilisez des variables globales pour référencer des objets de classe à l'intérieur de fonctions🎜rrreee🎜[Recommandations associées : 🎜Tutoriel vidéo Python3🎜]🎜

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!