Les dictionnaires et p-uplets nommés (namedtuples) sont deux structures de données puissantes en Python pour gérer des collections d'objets. Alors que les dictionnaires associent des clés à des valeurs, les namedtuples permettent de créer des tuples avec des champs nommés pour un accès plus lisible.

1. Rappel sur les dictionnaires

• ✅ Collection mutable de paires clé-valeur.
• ✅ Clés uniques et valeurs accessibles par clé.
• ✅ Exemple : personne = {"nom": "Dupont", "âge": 30}

# Exemple complet de dictionnaire
personne = {
    "nom": "Dupont",
    "âge": 30,
    "ville": "Paris"
}
print(personne["nom"])  # Accès par clé
personne["âge"] = 31   # Modification

2. P-uplets nommés (namedtuples)

• ✦ Définition : Tuple immuable avec des champs nommés (comme une mini-classe).
• ✦ Avantages :
  • Accès aux champs par attribut (obj.champ) ou indice (obj[0])
  • Plus léger qu'un dictionnaire.

from collections import namedtuple
Personne = namedtuple("Personne", ["nom", "âge"])
p1 = Personne(nom="Alice", âge=25)

# Accès aux champs
print(p1.nom)   # Alice
print(p1[1])    # 25 (accès par indice)

3. Quand utiliser l'un ou l'autre ?

4. Cas pratiques

• Dictionnaire : Gestion de configurations modifiables.

config = {"resolution": "1920x1080", "volume": 80}
config["volume"] = 90  # Modification facile
config["fullscreen"] = True  # Ajout d'une nouvelle clé

• Namedtuple : Stockage de données immuables (coordonnées, dates).

Point = namedtuple("Point", ["x", "y"])
p = Point(10, 20)
print(p.x, p.y)  # Lecture intuitive
# p.x = 30  # Erreur: immuable!

5. Conversions

• ✦ Namedtuple → Dictionnaire :

personne_dict = p1._asdict()
print(personne_dict)  # {'nom': 'Alice', 'âge': 25}

• ✦ Dictionnaire → Namedtuple :

p2 = Personne(**{"nom": "Bob", "âge": 40})
print(p2)  # Personne(nom='Bob', âge=40)

6. Conclusion

Les dictionnaires et namedtuples sont complémentaires en Python. Utilisez les dictionnaires pour des collections modifiables et les namedtuples pour des données immuables et structurées. Le choix dépendra de vos besoins spécifiques en termes de mutabilité, de performance et de lisibilité du code.

Dictionnaires en Python

Exercice 1: ★ ★ ★ ☆ ☆

On souhaite créer un dictionnaire représentant les notes d'élèves dans une classe. Chaque élève est associé à sa note.
1. Créez un dictionnaire notes contenant les élèves suivants et leurs notes :
      • Alice : 12
      • Bob : 15
      • Charlie : 9
      • David : 14
2. Ajoutez un nouvel élève, Eva, avec une note de 16.
3. Modifiez la note de Charlie à 10.
4. Supprimez Bob du dictionnaire.
5. Affichez les élèves et leurs notes.

notes = {
       "Alice": 12,
       "Bob": 15,
       "Charlie": 9,
       "David": 14
   }

notes["Eva"] = 16

notes["Charlie"] = 10

del notes["Bob"]

for eleve, note in notes.items():
       print(f"{eleve}: {note}")

Exercice 2: ★ ★ ★ ★ ☆

À partir du dictionnaire notes créé dans l'exercice précédent :
1. Calculez la moyenne des notes.
2. Trouvez l'élève ayant la note la plus élevée.
3. Trouvez l'élève ayant la note la plus basse.

moyenne = sum(notes.values()) / len(notes)

eleve_max = max(notes, key=notes.get)

eleve_min = min(notes, key=notes.get)

Exercice 3: ★ ★ ★ ★ ★

Créer un dictionnaire pour stocker les capitales de pays. Les pays et leurs capitales sont les suivants :
      • France : Paris
      • Espagne : Madrid
      • Italie : Rome
      • Allemagne : Berlin
1. Créez le dictionnaire et affichez-le.
2. Ajoutez le pays "Portugal" avec sa capitale "Lisbonne".
3. Changez la capitale de l'Italie pour "Florence".
4. Supprimez l'Allemagne.
5. Affichez toutes les capitales dans une liste formatée.

capitales = {
       "France": "Paris",
       "Espagne": "Madrid",
       "Italie": "Rome",
       "Allemagne": "Berlin"
   }

print(capitales)

capitales["Portugal"] = "Lisbonne"

capitales["Italie"] = "Florence"

del capitales["Allemagne"]

for pays, capitale in capitales.items():
       print(f"La capitale de {pays} est {capitale}.")

Exercice 4: ★ ★ ★ ★ ★

Vous avez un dictionnaire contenant les ventes de produits :
• Produit A : 100
• Produit B : 200
• Produit C : 150
1. Créez un dictionnaire ventes et affichez-le.
2. Calculez le total des ventes.
3. Trouvez le produit avec le maximum de ventes.
4. Ajoutez un produit D avec 250 ventes.
5. Affichez le produit avec le minimum de ventes.

ventes = {
       "Produit A": 100,
       "Produit B": 200,
       "Produit C": 150
   }

print(ventes)

total_ventes = sum(ventes.values())

produit_max = max(ventes, key=ventes.get)

ventes["Produit D"] = 250

produit_min = min(ventes, key=ventes.get)

Exercice 5: ★ ★ ★ ★ ★

Créer un dictionnaire pour répertorier les mots de passe des utilisateurs :
• utilisateur1 : "abc123"
• utilisateur2 : "password"
• utilisateur3 : "helloWorld"
1. Créez le dictionnaire mots_de_passe et affichez-le.
2. Changez le mot de passe de l'utilisateur2 en "newpassword".
3. Supprimez l'utilisateur3.
4. Vérifiez si un mot de passe existe pour un utilisateur donné.
5. Affichez tous les utilisateurs avec leurs mots de passe.

mots_de_passe = {
       "utilisateur1": "abc123",
       "utilisateur2": "password",
       "utilisateur3": "helloWorld"
   }

print(mots_de_passe)

mots_de_passe["utilisateur2"] = "newpassword"

del mots_de_passe["utilisateur3"]

utilisateur = "utilisateur1"
   existe = utilisateur in mots_de_passe

for utilisateur, mot_de_passe in mots_de_passe.items():
       print(f"{utilisateur}: {mot_de_passe}")

Dictionnaires et Fonctions en Python

Exercice 1: ★ ★ ★ ☆ ☆

Créez une fonction qui prend en entrée un dictionnaire d'élèves et leurs notes, et retourne la moyenne des notes.
1. Créez un dictionnaire notes avec les élèves suivants :
- Alice : 12
- Bob : 15
- Charlie : 9
- David : 14
2. Implémentez la fonction calculer_moyenne(d).

notes = {
       "Alice": 12,
       "Bob": 15,
       "Charlie": 9,
       "David": 14
   }

def calculer_moyenne(d):
       return sum(d.values()) / len(d)

   moyenne = calculer_moyenne(notes)
   print(f"Moyenne des notes: {moyenne}")

Exercice 2: ★ ★ ★ ★ ☆

Écrivez une fonction qui prend un dictionnaire de produits et leurs prix, et retourne le produit le plus cher.
1. Créez un dictionnaire produits avec les produits suivants :
- "Pomme": 1.5
- "Banane": 0.8
- "Cerise": 2.0
- "Date": 3.0
2. Implémentez la fonction produit_plus_cher(d).

produits = {
       "Pomme": 1.5,
       "Banane": 0.8,
       "Cerise": 2.0,
       "Date": 3.0
   }

def produit_plus_cher(d):
       return max(d, key=d.get)

   produit_max = produit_plus_cher(produits)
   print(f"Produit le plus cher: {produit_max}")

Exercice 3: ★ ★ ★ ★ ★

Créer une fonction qui prend un dictionnaire d'employés et leurs salaires, et retourne le salaire moyen. Ensuite, affichez les employés au-dessus de ce salaire moyen.
1. Créez un dictionnaire employes avec les employés suivants :
- "Jean": 3000
- "Marie": 3500
- "Pierre": 4500
- "Sophie": 4000
2. Implémentez la fonction salaires_moyens(d).

employes = {
       "Jean": 3000,
       "Marie": 3500,
       "Pierre": 4500,
       "Sophie": 4000
   }

def salaires_moyens(d):
       moyenne = sum(d.values()) / len(d)
       return {k: v for k, v in d.items() if v > moyenne}, moyenne

   employes_au_dessus_moyenne, moyenne = salaires_moyens(employes)
   print(f"Salaire moyen: {moyenne}")
   print(f"Employés au-dessus de la moyenne: {employes_au_dessus_moyenne}")

Exercice 4: ★ ★ ★ ☆ ☆

Écrivez une fonction qui prend un dictionnaire de pays et leurs populations, et retourne le pays avec la plus grande population.
1. Créez un dictionnaire pays avec les pays suivants :
- "France": 67_000_000
- "Allemagne": 83_000_000
- "Espagne": 47_000_000
- "Italie": 60_000_000
2. Implémentez la fonction pays_plus_popule(d).

pays = {
       "France": 67_000_000,
       "Allemagne": 83_000_000,
       "Espagne": 47_000_000,
       "Italie": 60_000_000
   }

def pays_plus_popule(d):
       return max(d, key=d.get)

   pays_max = pays_plus_popule(pays)
   print(f"Pays le plus peuplé: {pays_max}")

Exercice 5: ★ ★ ★ ★ ★

Créer une fonction qui prend un dictionnaire de mots et leurs fréquences, et retourne les mots qui apparaissent plus d'une fois.
1. Créez un dictionnaire frequences avec les mots suivants :
- "chat": 3
- "chien": 1
- "oiseau": 2
- "poisson": 5
2. Implémentez la fonction mots_frequents(d).

frequences = {
       "chat": 3,
       "chien": 1,
       "oiseau": 2,
       "poisson": 5
   }

def mots_frequents(d):
       return {k: v for k, v in d.items() if v > 1}

   mots_plus_frequents = mots_frequents(frequences)
   print(f"Mots fréquents: {mots_plus_frequents}")