Dictionnaires en Python : exercices corrigés de 1re NSI

notes["nsi"] renvoie la valeur associée à la clé "nsi" : c'est 17.

Les clés sont les chaînes "maths", "nsi" et "anglais". Les nombres 14, 17 et 12 sont les valeurs.

La clé "art" n'existe pas : Python lève une erreur KeyError. On l'évite avec if "art" in notes: avant la lecture, ou avec notes.get("art", 0) qui renvoie 0 si la clé est absente.

Avant la première instruction, stock["poires"] vaut 5. Le membre de droite calcule 5 + 8 = 13, et cette valeur est rangée sous la clé "poires".

La seconde instruction range 3 sous la clé "kiwis", qui n'existait pas encore.

Dictionnaire obtenu : {"pommes": 12, "poires": 13, "kiwis": 3}.

La première instruction modifie la valeur d'une clé existante ; la seconde ajoute une nouvelle association. La syntaxe est la même d[cle] = valeur, c'est l'état du dictionnaire qui décide du résultat.

Total : 12 + 13 + 3 = 28 fruits.

On initialise un accumulateur : somme = 0.

On parcourt les clés de quantites : for article in quantites:.

À chaque tour, on ajoute prix[article] * quantites[article] à somme. La même clé sert à lire dans les deux dictionnaires.

On renvoie somme après la boucle. Fonction complète :

def total(prix, quantites):
    somme = 0
    for article in quantites:
        somme = somme + prix[article] * quantites[article]
    return somme

Calcul : 1,5 × 4 + 3 × 2 + 2 × 1 = 6 + 6 + 2 = 14.

Si un article de quantites manque dans prix, prix[article] lève une erreur. Protection : if article in prix: avant le calcul, ou bien prix.get(article, 0).

On crée le dictionnaire vide : effectifs = {}.

On parcourt le mot lettre par lettre.

Si la lettre est déjà une clé, on augmente sa valeur de 1. Sinon, on crée l'association avec la valeur 1.

Fonction complète :

def compter(mot):
    effectifs = {}
    for lettre in mot:
        if lettre in effectifs:
            effectifs[lettre] = effectifs[lettre] + 1
        else:
            effectifs[lettre] = 1
    return effectifs

Pour "abracadabra" : {"a": 5, "b": 2, "r": 2, "c": 1, "d": 1}. Les lettres apparaissent dans l'ordre de leur première rencontre.

La lettre "a" apparaît 5 fois. Contrôle : a-b-r-a-c-a-d-a-b-r-a donne bien 5 occurrences, et 5 + 2 + 2 + 1 + 1 = 11 correspond à la longueur du mot.

Résultat attendu : {"1G1": ["Lea", "Ines", "Sam"], "1G2": ["Tom", "Paul"]}.

On part de groupes = {}.

On parcourt les élèves : for nom in eleves:, et on lit sa classe : classe = eleves[nom].

Si la classe n'est pas encore une clé de groupes, on lui associe une liste vide. Puis on ajoute le nom à la liste :

def par_classe(eleves):
    groupes = {}
    for nom in eleves:
        classe = eleves[nom]
        if classe not in groupes:
            groupes[classe] = []
        groupes[classe].append(nom)
    return groupes

Échanger simplement clés et valeurs ne marche pas : plusieurs élèves partagent la même classe. On aurait donc plusieurs associations pour une même nouvelle clé, et chacune écraserait la précédente. La liste permet de conserver tous les élèves.

classe["Tom"] est le dictionnaire {"maths": 9, "nsi": 12}, et ["nsi"] en extrait 12.

Pour la moyenne, on parcourt les élèves, on cumule classe[nom][matiere], puis on divise par le nombre d'élèves :

def moyenne(classe, matiere):
    somme = 0
    for nom in classe:
        somme = somme + classe[nom][matiere]
    return somme / len(classe)

En NSI : (18 + 12 + 15) / 3 = 45 / 3 = 15.

Pour bonus, on construit un nouveau dictionnaire au lieu de changer l'ancien :

def bonus(eleve, points):
    nouveau = {}
    for matiere in eleve:
        nouveau[matiere] = eleve[matiere]
    nouveau["nsi"] = eleve["nsi"] + points
    return nouveau

On suit ainsi la prudence indiquée par la ressource Éduscol : ne pas toucher aux dictionnaires qui représentent des p-uplets.² L'appel bonus(classe["Tom"], 2) renvoie {"maths": 9, "nsi": 14} et laisse classe["Tom"] intact.

On crée une liste vide resultat = [].

On parcourt liste et, pour chaque couleur, on ajoute code.get(couleur, 0) : c'est la valeur associée si la clé existe, sinon 0.

Fonction :

def encoder(liste):
    resultat = []
    for couleur in liste:
        resultat.append(code.get(couleur, 0))
    return resultat

encoder(["bleu", "jaune", "rouge"]) renvoie [3, 0, 1] : "jaune" n'est pas une clé, d'où le 0.

Pour decoder, on ne peut pas lire directement par la valeur. On parcourt les clés et on compare :

def decoder(n):
    for couleur in code:
        if code[couleur] == n:
            return couleur
    return None

Cette recherche par valeur oblige à parcourir le dictionnaire, alors que la recherche par clé est directe : c'est pour cela qu'on choisit comme clé ce par quoi on cherche le plus souvent.