Données mutables et immuables Python

couverture donnees mutables immuables python

Les fonctions de Python, qu’il s’agisse des fonctions intégrées (built-in) ou de celles que tu écris toi-même, sont des outils essentiels pour travailler avec des données.

Mais ce qu’elles font réellement avec tes données peut être déroutant, surtout si tu ignores ce qui se passe à l’intérieur. Cela peut provoquer de graves erreurs dans ton analyse, notamment si tu confonds les données mutables et immuables Python.

Dans cet article, tu vas voir comment Python traite différents types de données quand ils sont manipulés dans des fonctions. Tu apprendras aussi à faire en sorte que tes données ne soient modifiées que lorsque tu le souhaites.

En bref : en Python, les entiers, flottants, chaînes, booléens et tuples sont immuables, alors que les listes et les dictionnaires sont mutables. Quand tu passes une liste ou un dictionnaire à une fonction, la fonction peut donc modifier l’original. Pour l’éviter, travaille sur une copie avec .copy(), ou avec copy.deepcopy() si la structure est imbriquée.

Tu peux aussi exécuter tous les exemples dans ce notebook Google Colab : chaque extrait de code est dans sa propre cellule, prêt à être modifié.

Une fonction peut-elle modifier une variable globale ?

Pour comprendre comment Python gère les variables globales dans les fonctions, faisons une petite expérience.

Crée deux variables globales, number_1 et number_2, et affecte-leur les entiers 5 et 10. Utilise ensuite ces variables comme arguments d’une fonction qui effectue des calculs simples.

Les paramètres de la fonction portent les mêmes noms que les variables globales. Tu vas ainsi vérifier si l’utilisation de ces noms dans la fonction a modifié leur valeur globale.

number_1 = 5
number_2 = 10

def multiply_and_add(number_1, number_2):
    number_1 = number_1 * 10
    number_2 = number_2 * 10
    return number_1 + number_2

a_sum = multiply_and_add(number_1, number_2)
print(a_sum)
print(number_1)
print(number_2)
Python
150
5
10

La fonction a bien fonctionné, et les valeurs des variables globales number_1 et number_2 n’ont pas changé, même si elles portent le même nom que les paramètres.

En effet, Python garde les variables d’une fonction dans un espace de noms local, séparé de celui des variables globales. Les deux sont isolés : number_1 peut valoir 5 au niveau global et 50 à l’intérieur de la fonction.

Si tu ne vois pas bien la différence entre paramètre et argument, la documentation de Python sur le sujet l’explique très bien.

Que se passe-t-il avec les listes et les dictionnaires ?

Listes

Ce que tu fais avec une variable comme number_1 dans une fonction n’affecte donc pas sa valeur globale. Mais number_1 est un entier, un type de données assez basique.

Que se passe-t-il si tu refais la même expérience avec un autre type de données, comme une liste ?

Crée une fonction duplicate_last() qui duplique le dernier élément de n’importe quelle liste passée en argument.

initial_list = [1, 2, 3]

def duplicate_last(a_list):
    last_element = a_list[-1]
    a_list.append(last_element)
    return a_list

new_list = duplicate_last(a_list = initial_list)
print(new_list)
print(initial_list)
Python
[1, 2, 3, 3]
[1, 2, 3, 3]

La valeur globale de initial_list a été mise à jour, alors que tu ne l’as modifiée qu’à l’intérieur de la fonction !

Dictionnaires

Écris maintenant une fonction qui prend un dictionnaire en argument, pour voir si le dictionnaire global est modifié quand on le manipule dans une fonction.

Pour rester réaliste, utilisons les données du dataset AppleStore.csv, disponible ici.

Dans le code ci-dessous, on part d’un dictionnaire contenant le nombre d’applications pour chaque classe d’âge du dataset. Il y a donc 4 433 applications classées « 4+ », 987 classées « 9+ », etc.

Imagine que tu veuilles calculer un pourcentage pour chaque classe d’âge, afin de repérer les plus courantes parmi les applications de l’App Store.

Pour cela, tu écris une fonction make_percentages() qui prend un dictionnaire en argument et convertit les décomptes en pourcentages :

  1. démarre un compteur à zéro, puis parcours chaque valeur du dictionnaire en l’ajoutant au compteur, pour obtenir le nombre total d’applications ;
  2. parcours à nouveau le dictionnaire et calcule le pourcentage de chaque valeur.
content_ratings = {'4+': 4433, '9+': 987, '12+': 1155, '17+': 622}

def make_percentages(a_dictionary):
    total = 0
    for key in a_dictionary:
        count = a_dictionary[key]
        total += count

    for key in a_dictionary:
        a_dictionary[key] = (a_dictionary[key] / total) * 100

    return a_dictionary
Python

Avant de voir le résultat, regardons ce que fait ce code. Après avoir affecté le dictionnaire des classes d’âge à la variable content_ratings, tu crées la fonction make_percentages(), qui prend un seul argument : a_dictionary.

Pour obtenir le pourcentage d’applications de chaque classe d’âge, il faut connaître le nombre total d’applications. Tu définis donc une variable total égale à 0, puis tu parcours chaque clé de a_dictionary en ajoutant sa valeur à total.

Il ne reste plus qu’à reparcourir a_dictionary, diviser chaque valeur par le total, puis multiplier le résultat par 100. Tu obtiens un dictionnaire de pourcentages.

Mais que se passe-t-il quand tu utilises la variable globale content_ratings comme argument de cette fonction ?

c_ratings_percentages = make_percentages(content_ratings)
print(c_ratings_percentages)
print(content_ratings)
Python
{'4+': 61.595109073224954, '9+': 13.714047519799916, '12+': 16.04835348061692, '17+': 8.642489926358204}
{'4+': 61.595109073224954, '9+': 13.714047519799916, '12+': 16.04835348061692, '17+': 8.642489926358204}

Comme pour les listes, la variable globale content_ratings a été modifiée, alors que le changement a lieu uniquement dans la fonction make_percentages().

Que se passe-t-il vraiment ici ?

Tu viens de rencontrer la différence entre les types de données mutables (qui peuvent changer) et immuables (qui ne changent pas).

Quelle est la différence entre types mutables et immuables en Python ?

Un type de données mutable peut être modifié après sa création, un type immuable non. En Python, un type de données est soit mutable (modifiable), soit immuable (non modifiable).

La plupart des types que tu rencontres quand tu débutes sont immuables : entiers, flottants, chaînes de caractères, booléens et tuples. En revanche, les listes et les dictionnaires sont mutables.

Une liste ou un dictionnaire global peut donc être modifié même s’il est utilisé dans une fonction, comme tu l’as vu dans les exemples précédents.

Pour bien comprendre la différence entre données mutables et immuables en Python, il est utile de regarder comment Python traite réellement les variables. Prenons une affectation simple : a = 5

Le nom de variable a agit comme un pointeur vers 5 et te permet de récupérer cette valeur quand tu en as besoin.

5 est un entier, et les entiers sont immuables : une fois créé, un objet immuable ne peut plus être modifié. Quand tu écris a += 1, tu ne transformes donc pas 5 en 6 :

  • a pointe d’abord vers 5 ;
  • avec a += 1, le pointeur passe de 5 à 6, mais l’entier 5 n’est pas modifié.

Les types mutables, comme les listes et les dictionnaires, se comportent différemment : ils peuvent être modifiés directement.

Prenons une liste très simple : list_1 = [1, 2]. Si tu ajoutes un 3 à la fin, tu ne fais pas pointer list_1 vers une autre liste : tu mets à jour la liste existante.

Si plusieurs variables pointent vers la même liste, elles reflètent toutes la modification, comme le montre ce code :

list_1 = [1, 2]
list_2 = list_1
list_1.append(3)
print(list_1)
print(list_2)
Python
[1, 2, 3]
[1, 2, 3]

Cela explique pourquoi tes variables globales ont été modifiées dans les expériences avec les listes et les dictionnaires. Comme ces types sont mutables, les modifier, même à l’intérieur d’une fonction, change la liste ou le dictionnaire lui-même. Ce n’est pas le cas des types immuables.

Comment empêcher une fonction de modifier une liste ou un dictionnaire ?

En général, tu ne veux pas que tes fonctions modifient les variables globales, même quand elles contiennent des listes ou des dictionnaires.

Dans des analyses ou des programmes plus complexes, tu utilises souvent de nombreuses fonctions. Si chacune modifie les listes et dictionnaires qu’elle reçoit, il devient vite difficile de suivre ce qui change.

Heureusement, il existe une solution simple : faire une copie de la liste ou du dictionnaire avec la méthode native .copy().

Si tu ne connais pas encore les méthodes, pas d’inquiétude : elles sont couvertes dans le parcours Python de DataXp, avec des exercices corrigés. Pour ce tutoriel, retiens simplement que .copy() s’utilise comme .append(), c’est-à-dire qu’on l’appelle sur la liste :

ma_liste = [1, 2]
ma_liste.append(3)          # ajoute un élément à la liste
ma_copie = ma_liste.copy()  # fait une copie de la liste
print(ma_liste, ma_copie)
Python
[1, 2, 3] [1, 2, 3]

Reprends la fonction écrite pour les listes et modifie-la pour que ce qui se passe dans la fonction ne change pas initial_list.

Il suffit de remplacer l’argument initial_list par initial_list.copy() :

initial_list = [1, 2, 3]

def duplicate_last(a_list):
    last_element = a_list[-1]
    a_list.append(last_element)
    return a_list

new_list = duplicate_last(a_list = initial_list.copy()) # copie de la liste
print(new_list)
print(initial_list)
Python
[1, 2, 3, 3]
[1, 2, 3]

Le problème est résolu. Voici pourquoi : .copy() crée une copie distincte de la liste.

Au lieu de pointer vers initial_list, le paramètre a_list pointe vers une nouvelle liste, qui contient au départ les mêmes éléments que initial_list.

Toutes les modifications faites ensuite sur a_list touchent cette liste séparée, et non initial_list. La valeur globale de initial_list reste donc inchangée.

L’illustration ci-dessous montre le résultat : à gauche sans .copy(), à droite avec.

Schéma : liste modifiée sans .copy() à gauche, liste d'origine inchangée avec .copy() à droite - données mutables et immuables Python

Cette solution n’est pourtant pas parfaite : tu dois penser à ajouter .copy() à chaque appel de ta fonction. Un oubli, et tu risques de modifier accidentellement la valeur globale de initial_list.

Pour ne plus avoir à t’en soucier, tu peux créer la copie directement dans la fonction :

initial_list = [1, 2, 3]

def duplicate_last(a_list):
    copy_list = a_list.copy() # copie de la liste directement dans la fonction
    last_element = copy_list[-1]
    copy_list.append(last_element)
    return copy_list

new_list = duplicate_last(a_list = initial_list)
print(new_list)
print(initial_list)
Python
[1, 2, 3, 3]
[1, 2, 3]

Avec cette approche, tu peux passer sans risque une variable globale mutable, comme initial_list, à ta fonction. La valeur globale n’est pas modifiée : la fonction fait elle-même une copie, puis travaille sur cette copie.

La méthode .copy() fonctionne aussi pour les dictionnaires. Comme pour les listes, tu peux l’ajouter à l’argument passé à ta fonction pour qu’elle travaille sur une copie :

content_ratings = {'4+': 4433, '9+': 987, '12+': 1155, '17+': 622}

def make_percentages(a_dictionary):
    total = 0
    for key in a_dictionary:
        count = a_dictionary[key]
        total += count

    for key in a_dictionary:
        a_dictionary[key] = (a_dictionary[key] / total) * 100

    return a_dictionary

c_ratings_percentages = make_percentages(content_ratings.copy()) # copie du dictionnaire
print(c_ratings_percentages)
print(content_ratings)
Python
{'4+': 61.595109073224954, '9+': 13.714047519799916, '12+': 16.04835348061692, '17+': 8.642489926358204}
{'4+': 4433, '9+': 987, '12+': 1155, '17+': 622}

Là encore, tu dois penser à ajouter .copy() à chaque appel de make_percentages(). Si tu utilises souvent cette fonction, mieux vaut intégrer la copie dans la fonction elle-même, pour ne pas avoir à t’en souvenir.

Dans le code suivant, .copy() est appelé dans la fonction. Tu peux ainsi l’utiliser sans modifier les variables globales passées en argument, et sans ajouter .copy() à chaque appel.

content_ratings = {'4+': 4433, '9+': 987, '12+': 1155, '17+': 622}

def make_percentages(a_dictionary):
    copy_dict = a_dictionary.copy() # crée une copie du dictionnaire
    total = 0
    for key in a_dictionary:
        count = a_dictionary[key]
        total += count

    for key in copy_dict: # utilise la copie, de sorte que l'original reste inchangé
        copy_dict[key] = (copy_dict[key] / total) * 100

    return copy_dict

c_ratings_percentages = make_percentages(content_ratings)
print(c_ratings_percentages)
print(content_ratings)
Python
{'4+': 61.595109073224954, '9+': 13.714047519799916, '12+': 16.04835348061692, '17+': 8.642489926358204}
{'4+': 4433, '9+': 987, '12+': 1155, '17+': 622}

En modifiant la fonction pour qu’elle copie le dictionnaire et ne convertisse en pourcentages que cette copie, tu obtiens le résultat voulu sans toucher à content_ratings.

Pourquoi .copy() ne suffit-il pas toujours (copie superficielle) ?

Dernier point important : .copy() crée une copie dite superficielle (shallow copy). Elle copie le conteneur, mais pas les objets mutables qu’il contient.

Si ta liste contient d’autres listes (ou ton dictionnaire d’autres dictionnaires), la copie et l’original partagent donc les mêmes objets internes :

nested = [[1, 2], [3]]
shallow = nested.copy()
shallow[0].append(99)
print(nested)
Python
[[1, 2, 99], [3]]

La liste interne a été modifiée dans l’original. Dans ce cas, utilise la fonction deepcopy() du module copy de la bibliothèque standard, qui copie aussi tous les objets imbriqués :

import copy

nested = [[1, 2], [3]]
deep = copy.deepcopy(nested)
deep[0].append(99)
print(nested)
print(deep)
Python
[[1, 2], [3]]
[[1, 2, 99], [3]]

Pour les listes et dictionnaires simples, comme dans les exemples de cet article, .copy() suffit amplement.

Questions fréquentes sur les données mutables et immuables en Python

Quels types de données sont mutables et immuables en Python ?

Les entiers, flottants, chaînes de caractères, booléens et tuples sont immuables : on ne peut pas les modifier une fois créés. Les listes et les dictionnaires sont mutables : on peut les modifier directement.

Pourquoi une fonction modifie-t-elle ma liste globale ?

Parce qu’une liste est mutable : le paramètre de la fonction et la variable globale pointent vers la même liste. Modifier la liste dans la fonction modifie donc aussi la valeur globale. Ce n’est pas le cas des types immuables comme les entiers.

Comment empêcher une fonction de modifier une liste ou un dictionnaire ?

En travaillant sur une copie, avec la méthode .copy(). Pour ne pas avoir à y penser à chaque appel, crée la copie directement à l’intérieur de la fonction : tu peux alors lui passer une variable globale sans risque.

Quelle est la différence entre copy() et deepcopy() en Python ?

.copy() fait une copie superficielle : elle copie le conteneur, mais pas les objets mutables qu’il contient, que la copie et l’original partagent donc. copy.deepcopy(), du module copy, copie aussi tous les objets imbriqués. Pour des listes et dictionnaires simples, .copy() suffit.

Modifier un entier dans une fonction change-t-il la variable globale ?

Non. Python garde les variables d’une fonction dans un espace de noms local, séparé de celui des variables globales, et les entiers sont immuables. Une variable globale number_1 peut valoir 5 et son paramètre homonyme 50 dans la fonction sans qu’elles interfèrent.

Conclusion

Dans cet article, tu as vu la différence entre les types de données mutables (qui peuvent changer) et immuables (qui ne le peuvent pas) en Python.

Tu as aussi appris à utiliser la méthode .copy() pour copier des listes et des dictionnaires, afin de les utiliser dans des fonctions sans modifier leurs valeurs globales, et tu sais que copy.deepcopy() prend le relais pour les structures imbriquées.

Pour aller plus loin avec Python, consulte aussi notre guide des 21 astuces et concepts Python pour améliorer ton code.

Publications similaires

Laisser un commentaire

Votre adresse e-mail ne sera pas publiée. Les champs obligatoires sont indiqués avec *