Compréhension de la liste Python et comportement de la mémoire itérateur Analyse approfondie

Cet article explore profondément le comportement des littéraux de la liste, des compréhensions de la liste et des itérateurs dans Python dans la gestion de la mémoire. Le point central est que les caractéristiques d'évaluation non paresseuses de Python conduisent à une compréhension de la liste qui sera créée et consommée de mémoire d'abord, qu'elle soit affectée ou non à une variable. La principale différence est que la liste que les littéraux de variables non liés sont les déchets collectés plus rapidement après la création de l'itérateur, tandis que les listes sont liées aux variables restent occupantes tout au long du cycle de vie variable.

Mécanisme d'évaluation non-paresseux de Python

Dans Python, l'évaluation d'une expression est généralement "non-paresseuse", ce qui signifie que lorsqu'une expression est exécutée, sa valeur est calculée immédiatement, plutôt que d'attendre qu'il soit nécessaire. Pour la compréhension de la liste [Expression pour l'élément dans ITable], cela signifie que, que le résultat de cette compréhension de cette liste soit attribué à une variable, il créera d'abord un objet de liste complet et tous ses éléments en mémoire.

Considérez deux scénarios qui montrent un degré élevé de similitude dans l'empreinte de mémoire initiale:

Scénario 1: Répertoriez explicitement les variables

Lorsque nous attribuons le résultat d'une compréhension de la liste à une variable, l'objet de liste et tous les éléments qu'il contient resteront en mémoire jusqu'à ce que la variable soit réaffectée, supprimée ou dépassé son étendue.

 # Code 1: Liste se lie explicitement à la variable importation sys

# Cette ligne de code créera immédiatement une liste complète de 5000 entiers et le liera à my_list
my_list = [l pour l dans la plage (5000)]
print (f "list 'my_list' object 'Memory Footprint (excluant l'élément lui-même): {sys.getSizeof (my_list)} octets")
# Remarque: Sys.getSizeof () Renvoie l'empreinte de la mémoire de l'objet List lui-même.
# Exclut l'utilisation totale de la mémoire de 5000 objets entiers à l'intérieur. Mais surtout, ces 5000 objets entiers ont en effet été créés.

# Créer un iterateur à partir d'une liste existante my_iter1 = iter (my_list)
print (f "iterator 'my_iter1' objet 'Memory Footprint: {sys.getSizeof (my_iter1)} octets (généralement plus petit)")

# Dans ce scénario, My_List et tous les objets entiers référencés continueront d'occuper la mémoire.
# Jusqu'à ce que My_List soit collecté des ordures ou que le programme se termine.

Dans cet exemple, [l pour l dans la gamme (5000)] crée une liste de 5000 entiers. Même si nous en créons ensuite un itérateur à partir de celui-ci, la My_List d'origine et tous ses éléments existent toujours en mémoire et sont accessibles via la variable my_list.

Scénario 2: Liste les littéraux sont directement utilisés pour la création d'Itérator

Lorsque le résultat de la compréhension de la liste n'est pas explicitement attribué à une variable, mais qu'il est directement transmis à une fonction (comme iter ()), Python créera également cette liste complètement d'abord.

 # Code 2: Liste Les littéraux sont utilisés directement pour créer des systèmes d'importation par itérateur

# Bien qu'il n'y ait pas de réception variable explicite, [i pour i dans la plage (5000)] créera immédiatement une liste complète de # avec 5000 entiers.
# Ensuite, la fonction iter () recevra cette liste temporairement créée en tant que paramètre.
my_iter2 = iter ([i pour i dans la plage (5000)])
Imprimer (f "Iterator 'my_iter2' Object's Memory Footprint: {sys.getSizeof (my_iter2)} octets (généralement plus petit)")

# Point clé: objet de liste anonyme utilisé pour créer un iterator, après le retour de la fonction iter (),
# S'il n'y a pas d'autres références, il deviendra immédiatement un candidat pour la collecte des ordures.

Dans ce scénario, [i pour i dans la gamme (5000)] créera également une liste de 5000 entiers. La fonction iter () reçoit cette liste temporaire et renvoie un itérateur pour lui. Une fois la fonction iter () exécutée et nulle part ailleurs référence à cet objet de liste créé temporairement, le mécanisme de collecte des ordures de Python peut recycler la mémoire de la liste et de ses éléments.

La différence de base entre l'utilisation de la mémoire et le cycle de vie

Grâce à l'analyse ci-dessus, nous pouvons tirer les conclusions suivantes:

1. Empreinte de mémoire initiale: dans les deux scénarios, les expressions [L pour L dans la plage (5000)] ou [i pour i dans la plage (5000)] créeront et occuperont approximativement le même espace mémoire lorsqu'ils sont exécutés, car Python créera cette liste en totalité. Par conséquent, du point de vue de "si une grande quantité de données a été créée", le code 1 et le code 2 sont similaires dans l'étape de création de la liste.
2. Cycle de vie de la mémoire: la différence de base réside dans le cycle de vie des objets de liste en mémoire.
   • Dans le scénario un , la liste est liée à la variable my_list, et sa mémoire continuera à être consommée jusqu'à ce que le cycle de vie de la variable my_list se termine.
   • Dans le scénario 2 , la liste est un objet temporaire et anonyme. Il est créé et utilisé comme argument de la fonction iter (), et une fois que la fonction iter () renvoie et aucune autre référence ne pointe vers cet objet de liste, il devient immédiatement un candidat pour la collecte des ordures. Cela signifie que son empreinte mémoire est de courte durée.

En bref, func (expression) et variable = expression; Les modes FUNC (variable), sous le mécanisme d'évaluation non-paresseux de Python, l'expression doit être entièrement calculée et allouée à la mémoire. La seule différence est qu'après que func () revient, si la mémoire n'est pas stockée en interne par func (), sa mémoire sera recyclable immédiatement; tandis que ce dernier prolongera le cycle de vie de la mémoire en raison de l'existence d'une variable.

Optimisation et précautions

Pour les applications qui traitent de grands ensembles de données ou poursuivent l'efficacité de la mémoire, la création d'une liste complète n'est souvent pas le meilleur choix.

1. Optimiser la mémoire à l'aide d'expressions de générateur

Si votre objectif est de créer un itérateur et que vous n'avez pas besoin de garder la liste entière en mémoire en même temps, vous devez utiliser les expressions de générateur au lieu de compréhensions de la liste. L'expression du générateur utilise des parenthèses () au lieu de crochets [], qui ne construit pas tous les éléments à la fois, mais les génère à la demande:

 # Utiliser l'expression du générateur Import Sys

# my_generator_iter est un objet générateur qui ne crée pas les 5000 entiers immédiatement my_generator_iter = (i pour i dans la plage (5000))
print (f "Utilisation de la mémoire de l'objet générateur 'my_generator_iter': {sys.getSizeof (my_generator_iter)} octets (très petit)")

# Uniquement lors de l'itération, les éléments seront générés un par un et prendront la mémoire pour l'élément dans my_generator_iter:
    # Élément de processus
    passer

L'avantage des expressions du générateur est qu'il calcule et génère l'élément suivant en cas de besoin, réduisant considérablement l'empreinte de mémoire de pointe.

2. Comprendre les responsabilités de la fonction iter ()

La fonction de la fonction iter () est d'obtenir un itérateur d'un objet. Il n'est pas responsable de la création des données elle-même, mais plutôt d'obtenir un itérateur à partir d'un objet itérable existant. Par conséquent, si vous passez ITER () une grande liste, la création et l'utilisation de la mémoire de cette grande liste se sont déjà produites, et Iter () fournit simplement un mécanisme de traversée sur cette base.

3. Mécanisme de collecte des ordures de Python

Python utilise le comptage des références comme principal mécanisme de collecte des ordures. Lorsque le nombre de références d'un objet devient 0, il devient un candidat pour la collecte des ordures. Pour les références circulaires, Python utilise également l'algorithme Mark-and-Sweep pour le traitement. Comprendre ces mécanismes aide à mieux gérer la mémoire.

Résumer

Lorsque Python traite les compréhensions de la liste, que le résultat soit attribué à une variable, il effectuera d'abord une évaluation complète et créera un objet de liste complet en mémoire. Par conséquent, iter ([i pour i dans la plage (5000)]) et my_list = [l pour l dans la plage (5000)]; Iter (my_list) est similaire dans l'allocation de mémoire initiale, car les deux créent une liste de 5000 entiers. La principale différence est le cycle de vie de cet objet de liste: une liste littérale non liée à une variable deviendra un candidat pour la collecte des ordures plus rapidement après avoir terminé ses responsabilités (si elle est utilisée par Iter ()), tandis qu'une liste d'une variable continuera de consommer de la mémoire jusqu'à la fin du cycle de vie de la variable.

Pour gérer efficacement la mémoire, en particulier lors du traitement de grandes quantités de données, il est recommandé d'utiliser des expressions de générateur pour un élément dans itérable pour créer des itérateurs pour éviter de charger toutes les données en mémoire à la fois.

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!