Pourquoi ma liste se modifie toute seule quand je la passe en argument à une fonction ?

En Python, les arguments sont passés par "affectation d'une référence". Si tu passes une liste mutable (comme une liste ou un dictionnaire) à une fonction et que cette fonction la modifie (avec .append(), .pop(), une réaffectation d'élément, etc.), la liste originale sera modifiée. Pour l'éviter, passe une copie (superficielle ou profonde selon le besoin) à ta fonction : ma_fonction(ma_liste.copy()) .

Quelle est la différence entre '==' et 'is' en Python ?

L'opérateur == compare les valeurs de deux objets. Il vérifie s'ils sont "égaux". L'opérateur is compare l' identité de deux objets. Il vérifie s'ils sont le même objet en mémoire (s'ils ont le même id() ). Par exemple, a = [1, 2]; b = [1, 2]; donne a == b # True (valeurs égales) mais a is b # False (objets différents).

Est-ce que les nombres et les strings sont aussi concernés par ce problème de références ?

Les types immuables (comme les entiers int , les flottants float , les chaînes de caractères str , les tuples tuple ) se comportent différemment. Comme on ne peut pas les modifier "en place", même si deux variables référencent le même objet (ex: a = 5; b = a ), le fait de réaffecter l'une ( b = 10 ) crée un nouvel objet pour b , sans affecter a . Le problème des références partagées est donc principalement critique avec les types mutables : listes, dictionnaires, ensembles.

Python et la gestion de la memoire : references et copies

Introduction : Pourquoi la mémoire est cruciale en Python ?

En NSI, quand tu programmes en Python, tu manipules constamment des variables, des listes, des dictionnaires. Mais sais-tu vraiment ce qui se passe "sous le capot" ? Contrairement à ce qu'on pourrait croire, l'opérateur d'affectation = ne copie pas toujours des données. Il crée souvent une référence. Ne pas comprendre ce mécanisme est une source majeure de bugs dans les projets, surtout quand tu travailles avec des structures de données complexes. Dans cet article, on va démystifier ensemble la gestion de la mémoire en Python, un concept clé pour réussir en NSI et écrire du code robuste.

Les références : le lien invisible entre tes variables

En Python, une variable n'est pas une boîte qui contient une valeur. C'est plutôt une étiquette (un nom) qui pointe vers un objet en mémoire. Quand tu écris a = [1, 2, 3], tu ne mets pas la liste dans 'a'. Tu crées un objet liste en mémoire, et 'a' devient une référence qui pointe vers cet objet.

Regardons ce qui se passe avec un exemple classique qui surprend beaucoup de débutants :

>>> liste_1 = [1, 2, 3] >>> liste_2 = liste_1 >>> liste_2.append(4) >>> print(liste_1) [1, 2, 3, 4]

Surprise ! Modifier liste_2 a aussi modifié liste_1. Pourquoi ? Parce que liste_2 = liste_1 n'a pas copié la liste. Il a juste créé une seconde référence (liste_2) qui pointe vers le même objet en mémoire que liste_1. Les deux variables sont des "étiquettes" collées sur la même boîte.

Comment vérifier l'identité d'un objet ?

Python te donne deux outils puissants pour investiguer :

id() : Renvoie un identifiant unique (l'adresse en mémoire) de l'objet. Si deux variables ont le même id, elles référencent le même objet.
is : L'opérateur d'identité. a is b renvoie True si a et b sont le même objet (même id).

>>> a = [1, 2] >>> b = a >>> print(id(a) == id(b)) # True >>> print(a is b) # True

La copie superficielle (shallow copy) : une solution... partielle

Pour éviter le problème des références partagées, tu as besoin de faire une copie. La méthode la plus simple est la copie superficielle. Elle crée un nouvel objet conteneur, mais elle ne copie pas récursivement les objets à l'intérieur de ce conteneur. Elle y place des références vers les objets originaux.

Plusieurs façons de faire une copie superficielle d'une liste :

Utiliser la méthode .copy() : nouvelle_liste = ancienne_liste.copy()
Utiliser le slicing [:] : nouvelle_liste = ancienne_liste[:]
Utiliser le constructeur list() : nouvelle_liste = list(ancienne_liste)

Pour un dictionnaire, tu peux utiliser .copy() ou dict(ancien_dict).

>>> l1 = [1, 2, [3, 4]] >>> l2 = l1.copy() # Copie superficielle >>> l2[0] = 100 # Modifie un élément simple >>> print(l1) [1, 2, [3, 4]] # l1 n'est pas modifié, super ! >>> l2[2].append(999) # Modifie l'objet *à l'intérieur* de la sous-liste >>> print(l1) [1, 2, [3, 4, 999]] # Oups ! l1 est modifié !

Tu vois la limite ? La copie superficielle a bien créé une nouvelle liste l2, mais l'élément l2[2] (qui est une liste) est toujours une référence partagée avec l1[2]. C'est là qu'intervient la copie profonde.

La copie profonde (deep copy) : la solution ultime pour les structures imbriquées

Quand tu as des structures de données imbriquées (une liste de listes, un dictionnaire contenant des listes, etc.), et que tu veux une copie totalement indépendante, tu as besoin du module copy et de sa fonction deepcopy().

La copie profonde crée un nouvel objet, puis, de manière récursive, insère des copies des objets trouvés dans l'original. Elle va "creuser" à tous les niveaux d'imbrication.

import copy l1 = [1, 2, [3, 4]] l2 = copy.deepcopy(l1) # Copie profonde l2[2].append(999) print(l1) # [1, 2, [3, 4]] -> Inchangé ! print(l2) # [1, 2, [3, 4, 999]] print(l1[2] is l2[2]) # False -> Ce sont bien deux objets différents

La copie profonde est plus coûteuse en temps et en mémoire (elle doit tout dupliquer), mais elle garantit l'indépendance totale. C'est essentiel pour :

Les projets où tu dois manipuler des données complexes sans altérer l'original.
La création de sauvegardes (backup) d'un état de données.
Tout algorithme récursif qui modifie des structures imbriquées.

Quand utiliser une référence, une copie superficielle ou une copie profonde ?

Voici un petit guide de décision pour tes projets NSI :

Utilise une simple affectation (référence) quand :
- Tu veux juste donner un autre nom à un objet.
- Tu passes un argument à une fonction et tu acceptes que la fonction puisse modifier l'objet original (modification "en place").
Utilise une copie superficielle quand :
- Ta structure est "plate" (pas d'imbrication), comme une liste simple d'entiers ou de strings.
- Tu veux éviter de modifier l'original en surface, mais les objets internes peuvent être partagés (et c'est acceptable).
- La performance est un critère et la structure est grande mais peu imbriquée.
Utilise une copie profonde quand :
- Ta structure est complexe et imbriquée sur plusieurs niveaux (listes de listes, dictionnaires de listes...).
- Tu as absolument besoin de deux versions totalement indépendantes et isolées.
- Tu implémentes des algorithmes comme le backtracking où tu dois explorer différents états d'une configuration.

Astuce NSI : Dans un grand projet, avant de modifier une structure de données, demande-toi toujours : "Est-ce que je travaille sur l'original ou sur une copie ? Est-ce que cette modification doit être visible ailleurs ?". Cette réflexion t'évitera des heures de debug !