Objets mutables ou immuables en Python – Un guide visuel et pratique (2023)

Python est un langage génial. En raison de sa simplicité, de nombreuses personnes le choisissent comme premier langage de programmation.

Les programmeurs expérimentés utilisent également Python tout le temps, grâce à sa vaste communauté, son abondance de packages et sa syntaxe claire.

Mais il y a un problème qui semble dérouter les débutants ainsi que certains développeurs expérimentés : les objets Python. Plus précisément, la différence entremutableetimmuableobjets.

Dans cet article, nous approfondirons nos connaissances sur les objets Python, apprendrons la différence entremutableetimmuableobjets, et voir comment nous pouvons utiliser leinterprètepour mieux comprendre le fonctionnement de Python.

Nous utiliserons des fonctions et des mots-clés importants tels queidentifiantetest, et nous comprendrons la différence entrex == ouietx est y.

Êtes-vous prêt pour cela? Commençons.

Contrairement à d'autres langages de programmation où le langageles soutiensobjets, en Python vraimenttoutest un objet – comprenant des entiers, des listes et même des fonctions.

Nous pouvons utiliser notre interpréteur pour vérifier que :

>>> isinstance(1, object)True>>> isinstance(False, object)Truedef my_func() : renvoie "bonjour" >>> isinstance(my_func, object)True

Python a une fonction intégrée,identifiant, qui renvoie l'adresse d'un objet en mémoire. Par exemple:

>>> x = 1>>> identifiant(x)1470416816

Ci-dessus, nous avons créé unobjetPar le nom deX, et lui a attribué la valeur de1. Nous avons ensuite utiliséidentifiant(x)et découvert que cet objet se trouve à l'adresse1470416816en mémoire.

Cela nous permet de vérifier des choses intéressantes sur Python. Disons que nous créons deux variables en Python – une nomméeX, et un du nom deoui– et attribuez-leur la même valeur. Par exemple, ici :

>>> x = "J'aime Python !">>> y = "J'aime Python !"

Nous pouvons utiliser l'opérateur d'égalité (==) pour vérifier qu'ils ont bien la même valeur aux yeux de Python :

>>> x == yVrai

Mais s’agit-il du même objet en mémoire ? En théorie, il peut y avoir ici deux scénarios très différents.

Selon scénario(1), nous avons en réalité deux objets différents, l'un portant le nom deX, et un autre du nom deoui, cela se trouve avoir la même valeur.

Cependant, il se pourrait également que Python stocke ici un seul objet, qui porte deux noms qui y font référence – comme le montre le scénario(2):

Nous pouvons utiliser leidentifiantfonction introduite ci-dessus pour vérifier ceci :

>>> x = "J'aime Python !">>> y = "J'aime Python !">>> x == yTrue>>> id(x)52889984>>> id(y)52889384

Comme nous pouvons le voir, le comportement de Python correspond au scénario (1) décrit ci-dessus. Même six == ouidans cet exemple (c'est-à-direXetouiAvoir le mêmevaleurs), ce sont des objets différents en mémoire. Ceci est dû au faitidentifiant(x) != identifiant(y), comme on peut le vérifier explicitement :

>>> identifiant(x) == identifiant(y)Faux

Il existe un moyen plus court de faire la comparaison ci-dessus, et c'est d'utiliser Pythonestopérateur. Vérifier six est yc'est la même chose que vérifieridentifiant(x) == identifiant(y), ce qui signifie siXetouisont le même objet en mémoire :

>>> x == yTrue>>> id(x) == id(y)False>>> x est yFalse

Cela met en lumière la différence importante entre l’opérateur d’égalité==et l'opérateur d'identitéest.

Comme vous pouvez le voir dans l'exemple ci-dessus, il est tout à fait possible d'avoir deux noms en Python (Xetoui) pour être lié à deux objets différents (et donc,x est yestFAUX), où ces deux objets ont la même valeur (doncx == ouiestVrai).

Comment pouvons-nous créer une autre variable qui pointe vers le même objet queXpointe vers ? On peut simplement utiliser l'opérateur d'affectation=, ainsi:

>>> x = "J'adore Python !">>> z = x

Pour vérifier qu’ils pointent bien vers le même objet, on peut utiliser laestopérateur:

>>> x est zVrai

Bien sûr, cela signifie qu'ils ont la même adresse en mémoire, comme nous pouvons le vérifier explicitement en utilisantidentifiant:

>>> identifiant(x)54221824>>> identifiant(z)54221824

Et bien sûr, ils ont la même valeur, donc nous nous attendons à ce quex == zrendreVraiaussi:

>>> x == zVrai

Nous avons dit que tout en Python est un objet, mais il existe une distinction importante entre les objets. Certains objets sontmutablealors que certains sontimmuable.

Comme je l'ai mentionné précédemment, ce fait sème la confusion chez de nombreuses personnes qui découvrent Python, nous allons donc nous assurer que c'est clair.

Objets immuables en Python

Pour certains types en Python, une fois que nous avons créé des instances de ces types, elles ne changent jamais. Ils sontimmuable.

Par exemple,intles objets sont immuables en Python. Que se passera-t-il si nous essayons de modifier la valeur d'unintobjet?

>>> x = 24601>>> x24601>>> x = 24602>>> x24602

Eh bien, il semble que nous ayons changéXavec succès. C’est exactement là que beaucoup de gens sont confus. Que s'est-il passé exactement sous le capot ici ? Utilisonsidentifiantpour approfondir vos recherches :

>>> x = 24601>>> x24601>>> id(x)1470416816>>> x = 24602>>> x24602>>> id(x)1470416832

Nous pouvons donc le voir en attribuantx = 24602, nous n'avons pas modifié la valeur de l'objet quiXavait été lié auparavant. Au lieu de cela, nous avons créé un nouvel objet et lié le nomXà cela.

Donc après avoir attribué24601àXen utilisantx = 24601, nous avions l'état suivant :

Et après avoir utiliséx = 24602, nous avons créé un nouvel objet et lié le nomXà ce nouvel objet. L'autre objet avec la valeur de24601n'est plus joignable parX(ou tout autre nom dans ce cas) :

Chaque fois que nous attribuons une nouvelle valeur à un nom (dans l'exemple ci-dessus -X) qui est lié à unintobjet, nous modifions en fait la liaison de ce nom à un autre objet.

La même chose s'applique pourtuples, chaînes (strobjets), etbouffons aussi. Autrement dit,int(et d'autres types de numéros tels queflotter),tuple,bouffon, etstrles objets sontimmuable.

Testons cette hypothèse. Que se passe-t-il si nous créons untupleobjet, puis lui donner une valeur différente ?

>>> mon_tuple = (1, 2, 3)>>> id(mon_tuple)54263304>>> mon_tuple = (3, 4, 5)>>> id(mon_tuple)56898184

Tout comme unintobjet, nous pouvons voir que notre mission a réellement modifié l'objet dont le nommon_tupleest lié à.

Que se passe-t-il si nous essayons de modifier l'un destupleles éléments ?

>>> my_tuple[0] = 'une nouvelle valeur'Traceback (dernier appel le plus récent) : fichier "", ligne 1, dans TypeError : l'objet 'tuple' ne prend pas en charge l'affectation d'éléments

Comme nous pouvons le voir, Python ne nous permet pas de modifiermon_tuplele contenu, car il est immuable.

Objets mutables en Python

Certains types en Python peuvent être modifiés après la création, et ils sont appelésmutable. Par exemple, nous savons que nous pouvons modifier le contenu d'unlisteobjet:

>>> ma_liste = [1, 2, 3]>>> ma_liste[0] = 'une nouvelle valeur'>>> ma_liste['une nouvelle valeur', 2, 3]

Cela signifie-t-il que nous avons réellement créé un nouvel objet en attribuant une nouvelle valeur au premier élément dema liste? Encore une fois, nous pouvons utiliseridentifiantvérifier:

>>> ma_liste = [1, 2, 3]>>> id(ma_liste)55834760>>> ma_liste[1, 2, 3]>>> ma_liste[0] = 'une nouvelle valeur'>>> id(ma_liste )55834760>>> ma_liste['une nouvelle valeur', 2, 3]

Donc notre première missionma_liste = [1, 2, 3]créé un objet dans l'adresse55834760, avec les valeurs de1,2, et3:

Nous avons ensuite modifié le premier élément de celisteobjet utilisantmy_list[0] = 'une nouvelle valeur', c'est-à-dire - sans créer un nouveaulisteobjet:

Maintenant, créons deux noms –Xetoui, tous deux liés au mêmelisteobjet. Nous pouvons le vérifier soit en utilisantest, ou en vérifiant explicitement leuridentifiants :

>>> x = y = [1, 2]>>> x est yTrue>>> id(x)18349096>>> id(y)18349096>>> id(x) == id(y)True

Que se passe-t-il maintenant si nous utilisonsx.append(3)? Autrement dit, si nous ajoutons un nouvel élément (3) à l'objet portant le nom deX?

VolontéXpar changé ? Volontéoui?

Eh bien, comme nous le savons déjà, ce sont essentiellement deux noms du même objet :

Puisque cet objet a été modifié, lorsque nous vérifions ses noms, nous pouvons voir la nouvelle valeur :

>>> x.append(3)>>> x[1, 2, 3]>>> y[1, 2, 3]

Noter queXetouiAvoir le mêmeidentifiantcomme avant – car ils sont toujours liés au mêmelisteobjet:

>>> id(x)18349096>>> id(y)18349096

En plus delistes, d'autres types Python mutables incluentensemblesabledicters.

Dictionnaires (dicterobjets) sont couramment utilisés en Python. Pour rappel, nous les définissons ainsi :

mon_dict = {"name": "Omer", "number_of_pets": 1}

On peut alors accéder à un élément spécifique par son nom de clé :

>>> my_dict["name"]'Omer'

Les dictionnaires sontmutable, afin que nous puissions modifier leur contenu après la création. A un instant donné, une clé du dictionnaire ne peut pointer que vers un seul élément :

>>> mon_dict["nom"] = "Jean">>> mon_dict["nom"]'Jean'

Il est intéressant de noter qu'unles clés du dictionnaire doivent être immuables:

>>> my_dict = {[1,2] : "Hello"}Traceback (dernier appel le plus récent) : Fichier "", ligne 1, dans TypeError : type non hachable : 'list'

Pourquoi est-ce si?

Considérons le scénario hypothétique suivant (remarque : l'extrait ci-dessous ne peut pas vraiment être exécuté en Python) :

>>> x = [1, 2]>>> y = [1, 2, 3]>>> mon_dict = {x : 'a', y : 'b'}

Pour l’instant, les choses ne semblent pas si mauvaises. Nous supposerions que si nous accédonsmon_dictavec la clé de[1, 2], nous obtiendrons la valeur correspondante de'un', et si nous accédons à la clé[1, 2, 3], nous obtiendrons la valeur'b'.

Maintenant, que se passerait-il si nous essayions d'utiliser :

>>> x.append(3)

Dans ce cas,Xaurait la valeur de[1, 2, 3], etouiaurait également la valeur de[1, 2, 3]. Que devrions-nous obtenir lorsque nous demandonsmon_dict[[1, 2, 3]]? Qu'il sera'un'ou'b'? Pour éviter de tels cas, Python n'autorise tout simplement pas la modification des clés du dictionnaire.

Essayons d'appliquer nos connaissances à un cas un peu plus intéressant.

Ci-dessous, nous définissons unliste(unmutableobjet) et untuple(unimmuableobjet). Lelistecomprend untuple, et letuplecomprend unliste:

>>> ma_liste = [(1, 1), 2, 3]>>> mon_tuple = ([1, 1], 2, 3)>>> type(ma_liste)>>> type( ma_liste[0])>>> type(my_tuple)>>> type(my_tuple[0])

Jusqu'ici, tout va bien. Maintenant, essayez de réfléchir par vous-même : que se passera-t-il lorsque nous essaierons d’exécuter chacune des instructions suivantes ?

(1)>>> my_list[0][0] = 'Modifié !'

(2)>>> my_tuple[0][0] = 'Modifié !'

Dans l’énoncé (1), ce que nous essayons de faire, c’est de changerma listele premier élément, c'est-à-dire untuple. Depuis untupleestimmuable, cette tentative est vouée à l'échec :

>>> my_list[0][0] = 'Changed!'Traceback (dernier appel le plus récent) : fichier "", ligne 1, dans TypeError : l'objet 'tuple' ne prend pas en charge l'affectation d'éléments

Notez que ce que nous essayions de faire estpaschanger la liste, mais plutôt – changer le contenu de son premier élément.

Considérons l'énoncé (2). Dans ce cas, nous accédonsmon_tuplele premier élément de , qui se trouve être unliste, et modifiez-le. Examinons plus en détail ce cas et regardons les adresses de ces éléments :

>>> mon_tuple = ([1, 1], 2, 3)>>> id(mon_tuple)20551816>>> type(mon_tuple[0])>>> id(mon_tuple[0]) 20446248

Quand on changemon_tuple[0][0], on ne change pas vraimentmon_tupledu tout! En effet, après le changement,mon_tupleLe premier élément de sera toujours l'objet dont l'adresse en mémoire est20446248. Nous modifions cependant la valeur de cet objet :

>>> mon_tuple[0][0] = 'Modifié !'>>> id(mon_tuple)20551816>>> id(mon_tuple[0])20446248>>> mon_tuple(['Modifié !', 1], 2, 3)

Puisque nous avons seulement modifié la valeur demon_tuple[0], qui est un mutablelisteobjet, cette opération était bien autorisée par Python.

Dans cet article, nous avons découvert les objets Python. Nous avons dit cela en Pythontout est un objet, et j'ai dû utiliseridentifiantetestpour approfondir notre compréhension de ce qui se passe sous le capot lors de l'utilisation de Python pour créer et modifier des objets.

Nous avons également appris la différence entremutabledes objets, modifiables après création, etimmuabledes objets, ce qui ne le peut pas.

Nous avons vu que lorsque nous demandons à Python de modifier un objet immuable lié à un certain nom, nous créons en fait un nouvel objet et lui lions ce nom.

Nous avons ensuite appris pourquoi les clés du dictionnaire doivent êtreimmuableen Python.

Comprendre comment Python « voit » les objets est la clé pour devenir un meilleur programmeur Python. J'espère que cet article vous a aidé dans votre cheminement vers la maîtrise de Python.

Omer Rosenbaum,NagerDirecteur de la technologie de. Expert en cyberformation et fondateur de Checkpoint Security Academy. Auteur deRéseaux informatiques (en hébreu). Visitez monChaîne Youtube.