Une plongée profonde dans les variables en Python – Alberto Oshiro

Apprenez les tenants et aboutissants de la façon dont les variables en Python fonctionnent avec les références et les différents styles de passage de paramètres.

Dans les langages de bas niveau comme Java et C, les déclarations de variables allouent de l’espace en mémoire selon le type de variable; par conséquent, les programmeurs doivent spécifier le type de variable pour chaque nouvelle variable. En utilisant le langage C, par exemple, supposons qu’une nouvelle variable de type soit définie. Le programme allouera de l’espace dans la pile de taille 1 octet, correspondant à la taille du type en C. Si la valeur est alors affectée à la variable, le programme stocke la représentation binaire de dans l’espace alloué. Enfin, la variable stocke directement la valeur.

Les variables en Python fonctionnent différemment. Python n’a pas de déclaration de type variable; la même variable peut être réaffectée à des objets de types différents sans avoir à modifier l’espace de la variable en mémoire. Comme pour les pointeurs en C, les variables en Python ne stockent pas directement les valeurs; ils fonctionnent avec des références pointant vers des objets en mémoire.

Objets en Python

Tout en Python est un objet. D’autres langages comme Java ont des types primitifs qui ne servent qu’à représenter des valeurs statiques. Les types primitifs en Java, par exemple, n’ont pas d’autre attribut que leurs valeurs. En Python, en revanche, même les entiers sont des objets (en savoir plus sur la représentation entière de Python).

Python a la fonction intégrée qui renvoie une liste d’attributs d’un objet. Pour montrer comment les entiers en Python sont des objets, il est possible d’appeler la fonction avec l’entrée. L’appel renvoie la liste d’attributs suivante:

À des fins de formatage, la liste ci-dessus n’est pas la liste complète renvoyée par.

Parce que tout en Python est un objet, les variables fonctionnent avec des références au lieu de travailler directement avec les valeurs.

Lorsqu’une variable se voit attribuer une valeur en Python, la variable ne stocke pas directement la valeur absolue. Au lieu de cela, Python crée une nouvelle référence à un objet représentant cette valeur. Par exemple, la ligne affecte la valeur à la variable. Dans les coulisses, Python crée une nouvelle référence pour pointer vers l’objet représentant la valeur. Plus d’informations sur les références ci-dessous.

Visualisation de référence

Les variables en Python peuvent être visualisées avec des boîtes pointant vers des objets situés en mémoire. Par exemple, la variable avec valeur peut être visualisée de cette façon:

Création de références

Il existe deux façons de créer des références en Python. Une façon consiste à affecter une expression à une variable:, où est le nom de la variable et la valeur affectée à la variable.

Les expressions ne seront pas discutées en détail dans cet article, mais pour le lecteur plus curieux, voici un lien pour en savoir plus sur expressions.

Les expressions valides se réduisent à des valeurs qui peuvent être représentées par des objets en Python. Lors de l’affectation d’une expression valide à une variable, Python localise un objet en mémoire représentant la valeur ou crée un nouvel objet. Une fois la représentation de l’objet localisée ou construite, Python crée une nouvelle référence pour que la variable pointe vers l’objet.

La deuxième méthode de création de références en Python consiste à affecter une variable à une autre variable:, où les deux et sont deux variables distinctes. Par exemple, laissez la variable contenir la valeur. Maintenant, si la variable est affectée à la variable, les deux variables et référencent le même objet représentant la valeur mais les deux variables et ont des références différentes.

L’affectation d’une variable à une autre variable crée un alias de chaque variable. Un alias est une variable qui pointe vers le même objet en mémoire qu’une autre variable. Dans l’exemple ci-dessus, les deux variables et sont des alias l’une de l’autre.

Détruire Références

En Python, il est possible de détruire les références. Après avoir affecté une variable ou un express à une autre variable, il est possible de détruire la référence créée. La fonction détruit les références. En revenant à l’exemple ci-dessus, l’exécution de la commande entraîne la destruction de la référence de la variable vers l’objet représentant la valeur.

L’utilisation de la variable après avoir supprimé sa référence entraînerait l’erreur suivante:

Notez que cela ne détruit pas l’objet vers lequel la référence pointe. Le garbage collector de Python est responsable de la destruction des objets. Le garbage collector détruit un objet lorsqu’il n’y a plus de références pouvant y accéder. Si la commande était exécutée dans l’exemple ci-dessus et qu’il n’y avait plus de références accessibles à l’objet représentant la valeur, le garbage collector de Python détruirait l’objet.

Maintenant que les références aux variables et leurs illustrations sont expliquées, cet article décrit les différents styles de passage de paramètres et leurs similitudes et différences.

Styles de passage de paramètres

Les deux styles de passage de paramètres courants sont valeur de passage et passe-par-référence. Python, d’autre part, utilise une variation de ces deux styles appelée passe-par-référence-objet.

Par souci d’exemple en cours d’exécution, supposons que la liste et la fonction suivantes soient définies.

Pass-by-Value

Dans le style passe-par-valeur, les paramètres sont passés comme des copies des variables d’origine. Par exemple, si la fonction est appelée avec la liste, le programme crée une copie de la liste et utilise la copie à l’intérieur de la portée de la fonction. Cette méthode crée une référence indépendante complète et une représentation d’objet pour chaque argument. Toute modification des arguments à l’intérieur de la fonction n’affectera pas les variables d’origine transmises en tant que paramètres.

Pass-by-Reference

Dans le style passe-par-référence, les paramètres sont passés comme la même référence de la variable d’origine. Toute modification de l’argument modifiera directement la variable d’origine en dehors de la fonction. Même une nouvelle affectation entraînera la modification de la référence d’origine. Par exemple, supposons que la fonction soit appelée avec list. Quand ligne 3 est exécuté dans le code ci-dessus, le programme crée une nouvelle référence pointant vers la nouvelle liste et la variable en dehors de la fonction est également modifiée pour pointer vers la même liste. Par conséquent, aucune nouvelle référence ou objet n’est créé; la fonction continue d’utiliser la même référence que la variable d’origine.

Pass-by-Object-Reference

Enfin, dans un style de référence par objet, Python crée une nouvelle référence pour chaque argument. Cependant, contrairement au style passe-par-valeur, Python ne fait pas de copie de l’objet d’origine. Au lieu de cela, chaque nouvelle référence pointe vers son objet d’origine respectif.

Le diagramme ci-dessous décrit les différences entre chaque style:

Comme illustré dans le diagramme ci-dessus, le style de référence passe-par-objet ne crée pas un nouvel objet, permettant une modification directe sur l’objet d’origine. La méthode de liste sur ligne 2 est un exemple de modification de l’objet d’origine sans passer directement l’objet à la fonction.

Semblable au style passe-par-valeur, chaque fonction a sa propre portée en Python. Toute nouvelle déclaration d’arguments dans la portée de la fonction n’affectera pas les variables d’origine utilisées comme paramètres. Un exemple de nouvelles déclarations dans le cadre d’une fonction est ligne 3. La variable se voit attribuer une nouvelle liste. Cette affectation n’a aucune implication sur la variable utilisée pour appeler la fonction. D’un autre côté, sur le style passe-par-référence, toute nouvelle déclaration sur variable entraînerait la même affectation à variable que celle discutée précédemment.

L’implication principale du style de référence par objet est que les arguments de fonction deviennent des alias des variables d’origine. Pour les objets immuables, la création des alias n’a aucun impact sur le programme global; cependant, pour les objets mutables, un programmeur Python doit faire attention aux modifications sur place (par exemple ligne 3 dans la fonction ci-dessus). Si le programmeur ne souhaite pas modifier l’objet d’origine, il est possible de passer une copie de l’objet d’origine à la fonction et d’apporter les modifications uniquement à la copie.

Dernières pensées

En Python, tout est un objet. Les variables ne stockent pas directement les valeurs, à la place, comme les pointeurs en C, les variables Python fonctionnent avec des références aux objets représentant les valeurs. Les références sont uniques à chaque variable, mais plusieurs références peuvent pointer vers le même objet. Lorsque deux références ou plus pointent vers le même objet, les variables sont appelées alias les uns des autres.

Lorsqu’une variable est passée à une fonction en tant que paramètre, les arguments de la fonction deviennent des alias de la variable d’origine. Le style de passage des paramètres de Python est appelé passe-par-référence-objet. L’implication principale de ce style de passage est que les modifications apportées aux alias des objets modifiables entraînent la modification des valeurs de l’objet d’origine pour toutes les variables pointant vers cet objet. Si le programmeur souhaite modifier l’objet uniquement dans le cadre de la fonction, il est possible de créer une copie de l’objet d’origine et de le modifier à la place.

Merci beaucoup d’avoir lu cet article! Bientôt, je publierai plus sur Python et d’autres sujets de programmation.