Python 3 est un langage de programmation orienté objet (OOP). Mais… qu’est-ce qu’un objet ? Nous pourrions le définir comme quelque chose qu’une variable peut référencer et comme une instance d’une classe. D’autre part, les variables sont des références qui pointent vers les objets en mémoire.

En Python, tout est un objet qui peut être assigné à une variable et passé en argument dans une fonction.

De plus, ils peuvent être de deux types (que nous verrons plus tard) : mutables et immuables, et la plupart d’entre eux possèdent des attributs et des méthodes.

Voici quelques définitions avant de commencer :

Objet : instance d’une classe, quelque chose qu’une variable peut référencer.

Classe : C’est une structure pour créer des objets.

Référence : Une référence est un nom qui fait référence à l’emplacement spécifique dans la mémoire d’un objet.

Affectation: Les instructions d’affectation sont utilisées pour lier des noms à des valeurs et pour modifier les valeurs d’objets mutables (ex. : a = [1, 2, 3]).

Alias : (ici) Un alias est un deuxième nom pour un objet. Par exemple, si vous assignez [1, 2, 3] à a, vous pouvez créer un alias b en exécutant b = a.

type et id

Une chose à savoir, c’est que chaque instance d’une classe (donc un objet) possède un id et un type.

La fonction type() retourne le type d’un objet, qui est généralement une classe, c’est-à-dire un prototype à partir duquel les objets sont créés. Voici un exemple d’utilisation de type():

On peut voir ici que l’objet assigné à la variable a a un type de classe int.

À l’instanciation, chaque objet possède un identifiant unique (qui est l’adresse en mémoire dans l’implémentation CPython) que nous pouvons récupérer avec la fonction id() :

L’identifiant (id) d’un objet peut être utile pour vérifier si deux variables réfèrent au même objet (c’est-à-dire si elles ont le même identifiant d’objet). Mais il y a une autre façon de faire cela : en utilisant l’opérateur de comparaison is.

a is b renvoie True si les deux variables ont le même identifiant d’objet, et False sinon.

Mais faites attention de ne pas le confondre avec l’opérateur de comparaison ==, qui ne renvoie True que si les VALEURS de a et b sont les mêmes !

Objets mutables

Comme mentionné précédemment, il existe différents types d’objets : mutables et immuables. Les objets mutables sont des objets qui peuvent être modifiés sans changer leur identifiant.

Certains types mutables intégrés sont :

list (liste)
dictionary (dictionnaire)
set (ensemble)
classes définies par l’utilisateur

Voici un exemple :

Lorsque vous ajoutez un nouvel élément avec append(), cela fonctionne car append() est une méthode qui fait partie de notre objet. Lorsque vous modifiez la liste sans utiliser cette méthode, il créera un nouvel objet :

Une dernière chose, lorsque vous assignez une variable à une autre, vous créez ce que l’on appelle des alias. En faisant cela, votre objet a deux « noms » et toute modification effectuée avec un alias affectera les autres alias également.

Objets immuables

Contrairement aux objets mutables, vous ne pouvez pas changer la valeur d’un objet immuable sans changer son identifiant. En fait, lorsque vous mettez à jour un objet immuable, vous créez un nouvel objet. De plus, ce type d’objet ne supporte pas l’affectation d’éléments.

Certains types immuables intégrés sont :

int (entiers)
float (flottants)
str (chaînes de caractères)
decimal
bool (booléens)
tuple (tuples)
range (intervalles)

Voici un exemple :

Mais… Il y a une exception… Les tuples !

En effet, un tuple est un type immuable intégré, mais il peut contenir des objets mutables comme des listes. Ainsi, comme pour les autres objets immuables, vous ne pouvez pas mettre à jour un tuple sans changer son identifiant. Cependant, si vous modifiez un objet mutable contenu dans le tuple, cela ne créera pas un nouvel objet :

Pour les objets de type chaîne (string), lorsque vous assignez la même valeur à deux variables différentes, elles « pointent » vers le même objet :

Donc, si vous supprimez seulement l’une de ces variables (avec del), l’objet chaîne ne sera pas supprimé. Pour le supprimer, vous devez supprimer toutes les variables qui font référence à cet objet.

Pour aller plus loin…

D’après vous, combien d’objets ont été créés ?

Peut-être voulez-vous répondre 1 ? (parce que les objets de type int sont immuables)

Eh bien, laissez-moi vous dire que la réponse est… 0 !

En réalité, CPython, une implémentation de Python3, conserve un tableau de 262 entiers, de -5 à 256, et utilise des macros appelées NNSMALLPOSINTS et NSMALLNEGINTS. Ainsi, si vous assignez à une variable un objet de type int ayant une valeur comprise entre -5 et 256, aucun objet ne sera créé. En revanche, si vous assignez à une variable un objet ayant une valeur supérieure à 256 (ou inférieure à -5), un nouvel objet sera créé :

Pourquoi est-ce important ?

Il est très important de comprendre les différences entre les objets mutables et immuables, car cela vous permet de créer des programmes plus efficaces. En effet, vous devriez maintenant savoir qu’ajouter de nouveaux caractères à une chaîne dans une boucle (par exemple) n’est pas une bonne idée, car cela consomme beaucoup d’espace mémoire et n’est pas efficace. Dans ce cas, votre programme devra allouer de l’espace pour une nouvelle chaîne à chaque itération de la boucle, car les chaînes sont immuables !

Comment Python traite-t-il différemment les objets mutables et immuables ?

Python traite différemment les objets mutables et immuables. Les objets immuables sont plus rapides à accéder que les objets mutables, mais leur mise à jour est très coûteuse, car Python doit créer une copie de l’objet. Ainsi, si vous devez modifier un objet plusieurs fois dans un programme, il est préférable d’utiliser des objets mutables, car ils sont plus faciles à modifier.

Comment les arguments sont-ils passés aux fonctions et qu’est-ce que cela implique pour les objets mutables et immuables ?

Lorsqu’un objet mutable est passé à une fonction, cette fonction peut le modifier tout en conservant son identité :

Nous pouvons voir ici que les modifications sont visibles en dehors de la fonction, car aucun nouvel objet n’a été créé et il a conservé son identifiant.

Testons maintenant avec un objet immuable :

Nous pouvons noter que a a conservé son identifiant. C’est parce qu’un nouvel objet a été créé par la fonction et que a ne fait pas référence à celui-ci. Si vous souhaitez que a fasse référence à ce nouvel objet, vous devez ajouter une instruction return à la fonction :