Dans ce cours, nous allons explorer les types mutables en Python et les problèmes qu'ils peuvent engendrer. Nous verrons pourquoi la mutabilité, bien que pratique, peut conduire à des bugs subtils et comment les éviter grâce à de bonnes pratiques de programmation.

   a = [1, 2, 3]
   b = a  # b référence la même liste que a
   b.append(4)
   print(a)  # [1, 2, 3, 4] → a a aussi été modifié !
   

   def ajouter_element(element, liste=[]):
       liste.append(element)
       return liste

   print(ajouter_element(1))  # [1]
   print(ajouter_element(2))  # [1, 2] → La liste persiste entre les appels !
   

   nombres = [1, 2, 3, 4]
   for n in nombres:
       if n % 2 == 0:
           nombres.remove(n)  # Risque de sauter des éléments
   print(nombres)  # Résultat inattendu possible
   

   original = [1, 2, 3]
   copie = original.copy()  # ou list(original)
   copie.append(4)
   print(original)  # [1, 2, 3] → inchangé
   

   def ajouter_element(element, liste=None):
       if liste is None:
           liste = []
       liste.append(element)
       return liste
   

   # Solution 1 : Itérer sur une copie
   for n in nombres.copy():
       if n % 2 == 0:
           nombres.remove(n)
           
   # Solution 2 : Compréhension de liste
   nombres = [n for n in nombres if n % 2 != 0]
   

Objectif pédagogique : Comprendre la mutabilité des objets en Python.

Énoncé :
Un restaurant utilise une liste partagée pour enregistrer les commandes. Observez ce qui se passe.

def nouvelle_commande(commande):
    plats = ["eau", "pain"]
    commande.append(plats)
    return commande

cmd1 = []
cmd2 = nouvelle_commande(cmd1)
cmd2[0].append("vin")

print(cmd1)

Objectif pédagogique : Identifier les problèmes de mutabilité avec les valeurs par défaut.

Énoncé :
Une école veut ajouter des notes aux élèves. La fonction suivante semble mal se comporter. Pourquoi ?

def ajouter_notes(nom, notes=[]):
    notes.append(10)
    print(f"{nom} : {notes}")

ajouter_notes("Alice")
ajouter_notes("Bob")

Objectif pédagogique : Comprendre la gestion des objets mutables dans des structures de données.

Énoncé :
Un jeu ajoute des objets à l’inventaire du joueur. Mais l’inventaire semble se remplir tout seul !

def creer_joueur(nom, inventaire=[]):
    inventaire.append("épée")
    return { "nom": nom, "inventaire": inventaire }

j1 = creer_joueur("Arthur")
j2 = creer_joueur("Lancelot")

print(j1)
print(j2)

Objectif pédagogique : Identifier les erreurs de modification d'une liste en cours d'itération.

Énoncé :
Une fonction supprime les nombres pairs d'une liste. Le résultat est-il correct ?

nombres = [2, 3, 4, 5, 6]
for n in nombres:
    if n % 2 == 0:
        nombres.remove(n)
print(nombres)

Objectif pédagogique : Comprendre la différence entre référence et copie d'une liste.

Énoncé :
Une boutique duplique ses listes de produits mais constate des modifications inattendues.

produits = ["chaussures", "t-shirt"]
copie = produits
copie.append("chapeau")
print(produits)

Objectif pédagogique : Comprendre l'utilisation des dictionnaires et la gestion des références en Python.

Énoncé :
Un service de gestion des employés utilise un dictionnaire pour stocker les informations des employés. Observez le comportement de votre code. Répondez aux questions suivantes : 1. Que se passe-t-il si vous modifiez les informations d'un employé après l'avoir ajouté à la liste ? 2. Comment pourriez-vous éviter de modifier les données d'un employé par inadvertance ?

def ajouter_employe(employes, nom, age):
    employes[nom] = {"age": age, "projet": None}

employes = {}
ajouter_employe(employes, "Alice", 30)
ajouter_employe(employes, "Bob", 25)

# Modification
employes["Alice"]["age"] = 31
print(employes)

Objectif pédagogique : Comprendre l'impact des listes mutables sur les valeurs par défaut des fonctions.

Énoncé :
Un professeur utilise une fonction pour ajouter des notes à ses étudiants. Cependant, il constate des résultats étranges. Répondez aux questions ci-dessous : 1. Pourquoi les notes de chaque étudiant semblent-elles s'accumuler ? 2. Comment corriger cette fonction pour qu'elle fonctionne comme prévu ?

def ajouter_note(nom, notes=[]):
    notes.append(10)
    print(f"{nom} : {notes}")

ajouter_note("Claire")
ajouter_note("David")

Objectif pédagogique : Identifier les problèmes de référence lors de la création d'objets.

Énoncé :
Un jeu vidéo crée des personnages avec un inventaire partagé. Répondez aux questions suivantes : 1. Que se passe-t-il lorsque vous créez plusieurs personnages ? 2. Comment éviter que l'inventaire soit partagé entre les personnages ?

def creer_personnage(nom, inventaire=[]):
    inventaire.append("épée")
    return {"nom": nom, "inventaire": inventaire}

p1 = creer_personnage("Héros")
p2 = creer_personnage("Mage")

print(p1)
print(p2)

Objectif pédagogique : Identifier les erreurs lors de la modification d'une liste pendant l'itération.

Énoncé :
Une fonction tente de supprimer les nombres pairs d'une liste, mais le résultat n'est pas celui attendu. Répondez aux questions suivantes : 1. Que se passe-t-il lorsque vous modifiez la liste pendant l'itération ? 2. Quelle serait la meilleure méthode pour supprimer des éléments d'une liste sans rencontrer d'erreurs ?

nombres = [1, 2, 3, 4, 5, 6]
for n in nombres:
    if n % 2 == 0:
        nombres.remove(n)
print(nombres)

Objectif pédagogique : Comprendre les différences entre les références et les copies profondes d'une liste.

Énoncé :
Une boutique essaie de dupliquer ses listes de produits, mais elle rencontre des modifications inattendues. Répondez aux questions suivantes : 1. Pourquoi les modifications dans la liste copiée apparaissent-elles également dans la liste d'origine ? 2. Quelle méthode pouvez-vous utiliser pour créer une copie indépendante d'une liste ?

produits = ["chaussures", "t-shirt"]
copie = produits
copie.append("chapeau")
print(produits)

Objectif pédagogique : Comprendre comment gérer des listes et éviter les erreurs de référence.

Énoncé :
Un magasin en ligne utilise une liste pour enregistrer les commandes de ses clients. Lisez le code suivant et répondez aux questions : 1. Que se passe-t-il si plusieurs clients passent des commandes en même temps ? 2. Comment cela pourrait-il affecter l'intégrité des données ? 3. Proposez une solution pour gérer chaque commande indépendamment.

def passer_commande(commande, articles):
    commande.append(articles)
    return commande

commande_client1 = []
commande_client2 = passer_commande(commande_client1, ["chaussures", "t-shirt"])
commande_client2[0].append("chapeau")

print(commande_client1)

Objectif pédagogique : Comprendre la gestion des listes et le calcul des moyennes.

Énoncé :
Un enseignant souhaite calculer la moyenne des notes des étudiants. Examinez le code ci-dessous et répondez aux questions : 1. Pourquoi la moyenne calculée est-elle incorrecte si plusieurs appels sont effectués ? 2. Comment corriger le code pour qu'il fonctionne correctement à chaque appel ?

def ajouter_note(nom, notes=[]):
    notes.append(10)
    moyenne = sum(notes) / len(notes)
    print(f"{nom} : moyenne = {moyenne}")

ajouter_note("Alice")
ajouter_note("Bob")

Objectif pédagogique : Identifier les problèmes de référence dans la gestion des objets.

Énoncé :
Un jeu vidéo permet de créer des personnages avec un inventaire. Examinez le code ci-dessous et répondez aux questions : 1. Que se passe-t-il lorsque plusieurs personnages sont créés ? 2. Comment cela affecte-t-il l'inventaire des personnages ? 3. Proposez une solution pour que chaque personnage ait un inventaire indépendant.

def creer_personnage(nom, inventaire=[]):
    inventaire.append("épée")
    return {"nom": nom, "inventaire": inventaire}

p1 = creer_personnage("Guerrier")
p2 = creer_personnage("Mage")

print(p1)
print(p2)

Objectif pédagogique : Apprendre à gérer les erreurs lors de la suppression d'éléments d'une liste pendant l'itération.

Énoncé :
Une fonction tente de supprimer les nombres impairs d'une liste, mais le comportement n'est pas celui attendu. Répondez aux questions suivantes : 1. Pourquoi certaines valeurs sont-elles omises lors de l'itération ? 2. Quelle méthode pourriez-vous utiliser pour éviter ce problème ?

nombres = [1, 2, 3, 4, 5, 6]
for n in nombres:
    if n % 2 != 0:
        nombres.remove(n)
print(nombres)

Objectif pédagogique : Comprendre les différences entre les références et les copies profondes d'une liste.

Énoncé :
Un magasin souhaite dupliquer sa liste de produits, mais il rencontre des modifications inattendues. Répondez aux questions suivantes : 1. Pourquoi les modifications dans la liste copiée apparaissent-elles également dans la liste d'origine ? 2. Quelle méthode pouvez-vous utiliser pour créer une copie indépendante d'une liste ?

produits = ["chaussures", "t-shirt"]
copie = produits
copie.append("chapeau")
print(produits)