Les Dictionnaires en Python

# Fiche d'un élève — dictionnaire
eleve = {
    "nom"    : "Dupont",
    "prenom" : "Alice",
    "age"    : 16,
    "classe" : "1NSI",
    "note"   : 17.5
}

print(eleve["nom"])    # 'Dupont'
print(eleve["note"])   # 17.5
print(type(eleve))     # <class 'dict'>
print(len(eleve))      # 5  (nombre de paires clé:valeur)

# Dictionnaire non vide
scores = {"Alice": 18, "Bob": 12, "Clara": 15}

# Dictionnaire vide
vide = {}
vide2 = dict()   # autre syntaxe

# Avec des arguments nommés (clés = identifiants Python)
eleve = dict(nom="Alice", age=16, note=17)

# À partir d'une liste de tuples (clé, valeur)
paires = [("a", 1), ("b", 2), ("c", 3)]
d = dict(paires)   # {"a": 1, "b": 2, "c": 3}

# Avec zip() — associer deux listes
prenoms = ["Alice", "Bob", "Clara"]
notes   = [18, 12, 15]
scores  = dict(zip(prenoms, notes))
# {"Alice": 18, "Bob": 12, "Clara": 15}

# Initialiser toutes les clés avec la même valeur
matieres = ["Maths", "NSI", "Français"]
bulletins = dict.fromkeys(matieres, 0)
# {"Maths": 0, "NSI": 0, "Français": 0}

d = {"nom": "Alice", "age": 16, "note": 17}

# Méthode 1 — crochets (lève KeyError si clé absente)
print(d["nom"])     # "Alice"
# print(d["absent"])  → KeyError !

# Méthode 2 — get() (retourne None si absent, ou une valeur par défaut)
print(d.get("age"))           # 16
print(d.get("absent"))        # None
print(d.get("absent", 0))     # 0  (valeur par défaut)

d = {"nom": "Alice", "age": 16}

# L'opérateur 'in' teste la présence d'une CLÉ (pas d'une valeur)
print("nom"  in d)   # True
print("note" in d)   # False
print("Alice" in d)  # False — "Alice" est une valeur, pas une clé !

# Tester une valeur
print("Alice" in d.values())  # True

d = {"nom": "Alice", "age": 16}

# Ajouter une nouvelle paire clé:valeur
d["note"] = 17
print(d)  # {"nom": "Alice", "age": 16, "note": 17}

# Modifier une valeur existante
d["age"] = 17
print(d)  # {"nom": "Alice", "age": 17, "note": 17}

# Supprimer une clé avec del
del d["note"]
print(d)  # {"nom": "Alice", "age": 17}

# Supprimer et récupérer la valeur avec pop()
age = d.pop("age")
print(age)  # 17
print(d)    # {"nom": "Alice"}

# pop() avec valeur par défaut (évite KeyError si clé absente)
val = d.pop("absent", 0)   # retourne 0 sans erreur

scores = {"Alice": 18, "Bob": 12, "Clara": 15}

# for ... in d  →  parcourt les CLÉS
for prenom in scores:
    print(prenom)            # Alice, Bob, Clara

# Identique à :
for prenom in scores.keys():
    print(prenom)

for note in scores.values():
    print(note)              # 18, 12, 15

for prenom, note in scores.items():
    print(f"{prenom} a eu {note}/20")
# Alice a eu 18/20
# Bob a eu 12/20
# Clara a eu 15/20

scores = {"Alice": 18, "Bob": 12, "Clara": 15}

# ── Somme des valeurs ────────────────────────────
total = 0
for note in scores.values():
    total += note
print(total)   # 45   (ou : sum(scores.values()))

# ── Moyenne ──────────────────────────────────────
moy = sum(scores.values()) / len(scores)
print(moy)     # 15.0

# ── Clé du maximum ───────────────────────────────
def meilleur(d):
    cle_max = None
    val_max = None
    for cle, val in d.items():
        if val_max is None or val > val_max:
            cle_max, val_max = cle, val
    return cle_max

print(meilleur(scores))   # "Alice"
# Ou avec max() + key= :
print(max(scores, key=scores.get))   # "Alice"

# ── Filtrer (élèves avec note ≥ 15) ─────────────
admis = {p: n for p, n in scores.items() if n >= 15}
print(admis)   # {"Alice": 18, "Clara": 15}

# ── Compter (occurrences dans une liste) ─────────
lettres = ["a", "b", "a", "c", "b", "a"]
comptage = {}
for lettre in lettres:
    comptage[lettre] = comptage.get(lettre, 0) + 1
print(comptage)   # {"a": 3, "b": 2, "c": 1}

# Chaque élève est un dictionnaire, la classe est une liste
classe = [
    {"nom": "Alice", "note": 18, "mention": "TB"},
    {"nom": "Bob",   "note": 12, "mention": "AB"},
    {"nom": "Clara", "note": 15, "mention": "B"},
]

# Accéder à la note de Bob
print(classe[1]["note"])   # 12

# Afficher tous les noms
for eleve in classe:
    print(eleve["nom"])      # Alice, Bob, Clara

# Calculer la moyenne de la classe
moy = sum(e["note"] for e in classe) / len(classe)
print(round(moy, 1))       # 15.0

# Élève avec la meilleure note
top = max(classe, key=lambda e: e["note"])
print(top["nom"])           # "Alice"

# Notes par matière
notes_par_matiere = {
    "Maths"  : [14, 16, 11, 18],
    "NSI"    : [17, 15, 19, 13],
    "Anglais": [12, 10, 15, 14]
}

# Moyenne de NSI
n_nsi = notes_par_matiere["NSI"]
moy_nsi = sum(n_nsi) / len(n_nsi)
print(moy_nsi)   # 16.0

# Ajouter une note en NSI
notes_par_matiere["NSI"].append(20)

# Afficher toutes les moyennes
for matiere, notes in notes_par_matiere.items():
    moy = round(sum(notes) / len(notes), 1)
    print(f"{matiere} : {moy}/20")

# Carrés des entiers de 0 à 4
carres = {x: x**2 for x in range(5)}
# {0:0, 1:1, 2:4, 3:9, 4:16}

# Inverser un dictionnaire (clés ↔ valeurs)
d = {"a": 1, "b": 2, "c": 3}
inverse = {v: k for k, v in d.items()}
# {1: "a", 2: "b", 3: "c"}

# Filtrer : garder seulement les notes ≥ 15
scores = {"Alice": 18, "Bob": 12, "Clara": 15}
admis = {p: n for p, n in scores.items() if n >= 15}
# {"Alice": 18, "Clara": 15}

# Transformer : convertir les notes sur 20 en pourcentages
pct = {p: round(n * 5, 1) for p, n in scores.items()}
# {"Alice": 90.0, "Bob": 60.0, "Clara": 75.0}

# Construire depuis deux listes avec zip
prenoms = ["Alice", "Bob", "Clara"]
notes   = [18, 12, 15]
d = {p: n for p, n in zip(prenoms, notes)}
# {"Alice": 18, "Bob": 12, "Clara": 15}