Python offre de nombreuses commodités aux développeurs, l'une des plus importantes étant sa gestion de la mémoire pratiquement sans souci. Les développeurs n'ont plus besoin d'allouer, de suivre et de libérer manuellement de la mémoire pour les objets et les structures de données en Python. Le moteur d'exécution fait tout ce travail pour vous, afin que vous puissiez vous concentrer sur la résolution des problèmes réels plutôt que sur les détails au niveau de la machine.
Néanmoins, même pour les utilisateurs de Python les moins expérimentés, il est avantageux de comprendre comment fonctionnent le garbage collection et la gestion de la mémoire de Python. Comprendre ces mécanismes vous aidera à éviter les problèmes de performances qui peuvent survenir avec des projets plus complexes. Vous pouvez également utiliser les outils intégrés de Python pour surveiller le comportement de gestion de la mémoire de votre programme.
Chaque objet Python a un décompte de références, également appelé décompte de références. refcount est le nombre total d'autres objets contenant des références à un objet donné. À mesure que vous ajoutez ou supprimez des références à l'objet, le nombre augmente ou diminue. Lorsque le nombre de références d'un objet atteint zéro, l'objet est libéré et sa mémoire est libérée.
Qu'est-ce qu'une référence ? Permet d'accéder à n'importe quel contenu d'un objet par son nom ou via un accesseur dans un autre objet.
Voici un exemple simple :
x = "Hello there"
Lorsque nous envoyons cette commande à Python, deux choses se produisent sous le capot :
Si nous disons y = x, alors le nombre de références passera à nouveau à 2.
Chaque fois que xandy sort de la portée ou est supprimé de son espace de noms, le nombre de références de la chaîne est réduit de 1 pour chaque nom. Une fois que x et y sont hors plage ou sont supprimés, le nombre de références de la chaîne devient 0 et est supprimé.
Maintenant, supposons que nous créions une liste contenant une chaîne comme indiqué ci-dessous :
x = ["Hello there", 2, False]
La chaîne reste en mémoire jusqu'à ce que la liste elle-même soit supprimée ou que l'élément contenant la chaîne soit supprimé de la liste. L’une ou l’autre de ces opérations entraînera la disparition de la seule chose contenant une référence à la chaîne.
Considérons maintenant cet exemple :
x = "Hello there" y = [x]
Si nous supprimons le premier élément y de , ou supprimons entièrement la liste y, la chaîne est toujours en mémoire. En effet, le nom x contient une référence à celui-ci.
Dans la plupart des cas, le comptage de références fonctionne correctement. Mais parfois, vous rencontrez une situation où deux objets contiennent chacun une référence à l’autre. C'est ce qu'on appelle la période de référence. Dans ce cas, le compteur de références de l'objet n'atteint jamais zéro et il n'est jamais supprimé de la mémoire.
Ceci est un exemple artificiel :
x = SomeClass() y = SomeOtherClass() x.item = y y.item = x
Puisque x et y détiennent des références l'un à l'autre, ils ne sont jamais supprimés du système - même si rien d'autre ne fait référence à l'un ou l'autre.
Il est en fait assez courant que le propre runtime de Python génère des cycles de référence pour les objets. Un exemple est une exception avec un objet de traçage qui contient une référence à l'exception elle-même.
Dans les versions antérieures de Python, c'était un problème. Les objets avec des cycles de référence peuvent s'accumuler au fil du temps, ce qui constitue un gros problème pour les applications de longue durée. Mais Python a depuis introduit des systèmes de détection de cycle et de garbage collection pour gérer les cycles de référence.
Le garbage collector de Python détecte les objets avec des cycles de référence. Pour ce faire, il garde une trace des objets qui sont des « conteneurs » (par exemple des listes, des dictionnaires, des instances de classe personnalisées) et détermine lesquels d'entre eux ne sont accessibles nulle part ailleurs.
Une fois ces objets sélectionnés, le garbage collector les supprime en s'assurant que leur nombre de références peut tomber à zéro en toute sécurité.
La grande majorité des objets Python n'ont pas de cycles de référence, le garbage collector n'a donc pas besoin de fonctionner 24h/24 et 7j/7. Au lieu de cela, le ramasse-miettes utilise certaines heuristiques pour s'exécuter moins fréquemment et aussi efficacement que possible à chaque fois.
Lorsque l'interpréteur Python démarre, il garde une trace du nombre d'objets qui ont été alloués mais non libérés. La grande majorité des objets Python sont de courte durée, ils apparaissent et disparaissent donc rapidement. Mais avec le temps, des objets plus durables apparaîtront. Une fois qu'un certain nombre d'objets de ce type sont accumulés, le garbage collector s'exécute.
Chaque fois que le garbage collector s'exécute, il collecte tous les objets qui ont survécu à la collecte et les place dans un groupe appelé génération. Ces objets de « première génération » sont scrutés moins fréquemment dans le cycle de référence. Tous les objets de première génération qui survivent au garbage collector seront finalement migrés vers la deuxième génération, où ils seront analysés moins fréquemment.
同样，垃圾收集器不会跟踪所有内容。例如，像用户创建的类这样的复杂对象总是被跟踪。但是不会跟踪仅包含简单对象（如整数和字符串）的字典，因为该特定字典中的任何对象都不会包含对其他对象的引用。不能保存对其他元素（如整数和字符串）的引用的简单对象永远不会被跟踪。
通常，垃圾收集器不需要调整即可运行良好。Python 的开发团队选择了反映最常见现实世界场景的默认值。但是如果你确实需要调整垃圾收集的工作方式，你可以使用Python 的 gc 模块。该gc模块为垃圾收集器的行为提供编程接口，并提供对正在跟踪的对象的可见性。
gc当你确定不需要垃圾收集器时，你可以做的一件有用的事情是关闭它。例如，如果你有一个堆放大量对象的短运行脚本，则不需要垃圾收集器。脚本结束时，所有内容都将被清除。为此，你可以使用命令禁用垃圾收集器gc.disable()。稍后，你可以使用 重新启用它gc.enable()。
你还可以使用 手动运行收集周期gc.collect()。一个常见的应用是管理程序的性能密集型部分，该部分会生成许多临时对象。你可以在程序的该部分禁用垃圾收集，然后在最后手动运行收集并重新启用收集。
另一个有用的垃圾收集优化是gc.freeze(). 发出此命令时，垃圾收集器当前跟踪的所有内容都被“冻结”，或者被列为免于将来的收集扫描。这样，未来的扫描可以跳过这些对象。如果你有一个程序在启动之前导入库并设置大量内部状态，那么你可以gc.freeze()在所有工作完成后发出。这使垃圾收集器不必搜寻那些无论如何都不太可能被删除的东西。（如果你想对冻结的对象再次执行垃圾收集，请使用gc.unfreeze().）
你还可以使用它gc来调试垃圾收集行为。如果你有过多的对象堆积在内存中并且没有被垃圾收集，你可以使用gc's 检查工具来找出可能持有对这些对象的引用的对象。
如果你想知道哪些对象持有对给定对象的引用，可以使用gc.get_referrers(obj)列出它们。你还可以使用gc.get_referents(obj)来查找给定对象引用的任何对象。
如果你不确定给定对象是否是垃圾收集的候选对象，gc.is_tracked(obj)请告诉你垃圾收集器是否跟踪该对象。如前所述，请记住垃圾收集器不会跟踪“原子”对象（例如整数）或仅包含原子对象的元素。
如果你想亲自查看正在收集哪些对象，可以使用 设置垃圾收集器的调试标志gc.set_debug(gc.DEBUG_LEAK|gc.DEBUG_STATS)。这会将有关垃圾收集的信息写入stderr。它将所有作为垃圾收集的对象保留在只读列表中。
如前所述，如果你在某处仍有对它们的引用，则对象可能会堆积在内存中而不会被收集。这并不是 Python 垃圾收集本身的失败。垃圾收集器无法判断你是否不小心保留了对某物的引用。
让我们以一些防止对象永远不会被收集的指针作为结尾。
如果你将对象 1 指定为对象 2 的属性（例如类），则对象 2 将需要超出范围，然后对象 1 才会：
obj1 = MyClass() obj2.prop = obj1
更重要的是，如果这种情况发生在某种其他操作的副作用中，例如将对象 2 作为参数传递给对象 1 的构造函数，你可能不会意识到对象 1 持有一个引用：
obj1 = MyClass(obj2)
另一个例子：如果你将一个对象推入模块级列表并忘记该列表，则该对象将一直保留，直到从列表中删除，或者直到列表本身不再有任何引用。但是如果该列表是一个模块级对象，它可能会一直存在，直到程序终止。
简而言之，请注意你的对象可能被另一个看起来并不总是很明显的对象持有的方式。
Python 的 weakref 模块允许你创建对其他对象的弱引用。弱引用不会增加对象的引用计数，因此只有弱引用的对象是垃圾回收的候选对象。
一个常见的用途weakref是对象缓存。你不希望仅仅因为它具有缓存条目而保留引用的对象，因此你将 aweakref用于缓存条目。
Enfin, si vous savez qu'un objet donné contient une référence à un autre objet, vous pouvez toujours rompre manuellement une référence à cet objet. Par exemple, si vous avez instance_of_class.ref = other_object, vous pouvez définir instance_of_class.ref = None lorsque vous êtes prêt à supprimer instance_of_class.
En comprenant le fonctionnement de la gestion de la mémoire Python, nous examinons comment son système de garbage collection permet d'optimiser la mémoire dans les programmes Python, et comment vous pouvez contrôler l'utilisation de la mémoire et le garbage collection à l'aide de modules fournis par la bibliothèque standard et ailleurs.
Titre original :Python garbage collection et le module gc
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!
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
