Exercices sur les dictionnaires

Objectif

Identifier et corriger des erreurs de syntaxe courantes dans la déclaration d’un dictionnaire, distinguer une clé d’une variable, et mettre à jour une valeur.

Énoncé

Un étudiant a écrit le code suivant pour stocker des informations sur un personnage de jeu vidéo, mais le programme contient plusieurs erreurs.

personnage = {
    nom: "Link"
    "race": "Hylien",
    'vie': 100,
}

print(personnage["rasse"])
print(personnage[vie])

1. Corriger les erreurs de syntaxe dans la déclaration du dictionnaire personnage.
2. Corriger les instructions print pour qu’elles affichent correctement la vie et la race du personnage.
3. Écrire une nouvelle instruction qui retire 10 points de vie au personnage en mettant à jour la valeur de la clé 'vie'.

Objectif

Créer un dictionnaire, accéder à une valeur par sa clé, ajouter et modifier des paires clé-valeur. Vérifier la présence d’une clé avec l’opérateur in et parcourir les éléments d’un dictionnaire.

Énoncé

Écrire un programme qui gère un inventaire simple pour un personnage de jeu vidéo.

1. Créer un dictionnaire vide nommé inventaire. Ensuite, ajouter les éléments suivants : 'potion' avec la valeur 3, et 'pierre' avec la valeur 5.
2. Modifier la quantité de 'potion' pour qu’elle devienne 5.
3. Afficher un message si l’item 'épée' est déjà dans l’inventaire. Sinon, en ajouter une.
4. Parcourir l’inventaire pour afficher chaque item et sa quantité au format Item: quantité.

Sortie attendue

potion: 5
pierre: 5
épée: 1

L’ordre des lignes peut varier.

Objectif

Parcourir une collection de dictionnaires pour en modifier les éléments, puis réorganiser le code dans une fonction.

Énoncé

Une liste de contacts contient des noms et prénoms saisis au clavier, sans aucune mise en forme. Il faut normaliser ces données directement dans la liste existante.

1. Compléter le code ci-dessous pour corriger les données : le nom de chaque personne doit être en majuscules (cf méthode upper()) et le prénom avec une majuscule au début (cf capitalize()).

from typing import List, Dict

contacts: List[Dict] = [
    {"nom": "tehei", "prenom": "mehiti"},
    {"nom": "hauata", "prenom": "manu"},
    {"nom": "wei", "prenom": "lin"},
    {"nom": "durand", "prenom": "pierre"}
]

for i in range(len(contacts)):
    #A COMPLETER

2. Une fois le code fonctionnel, réécrire la boucle en utilisant la syntaxe “pour chaque élément de la collection” (sans utiliser d’index i).

3. Transformer le code de la question 1 en une fonction nommée normaliser_noms dont la spécification doit être écrite : cette fonction prend en paramètre en entrée-sortie une collection (tableau) de contacts et ne renvoie rien.

4. Écrire le code qui utilise cette fonction normaliser_noms puis afficher la liste des contacts pour vérifier le résultat.

Objectif

Itérer sur une collection pour enrichir chaque dictionnaire avec de nouvelles données générées (login, mot de passe) en s’appuyant sur une fonction existante.

Énoncé

Pour des raisons de sécurité, chaque contact de la liste doit maintenant se voir attribuer un identifiant (login) et un mot de passe. Pour cela, on va utiliser une fonction de génération de mots de passe déjà écrite.

En partant de la liste contacts correctement formatée (NOM, Prénom), écrire une boucle qui parcourt chaque personne et, pour chacune :

• Génére un login et l’ajoute au dictionnaire ; le login est composé de la première lettre du prénom (en minuscule), suivie d’un point, puis des quatre premières lettres du nom (en minuscule) le tout en minuscules ; exemple : “TEHEI Mehiti” → “m.tehe”.
• Génére un mot_de_passe et l’ajoute au dictionnaire.

Afficher le résultat pour vérifier.

Indications

Voici la fonction et les constantes à utiliser. Copiez-les au début de votre fichier.

from random import randint

def gen_password(length: int, chars: str) -> str:
    """ Génère un mot de passe aléatoire.
    @param length la longueur désirée
    @param chars les caractères autorisés
    @return: le mot de passe généré
    """
    password = ""
    for _ in range(length):
        k = randint(0, len(chars) - 1)
        password += chars[k]
    return password

PASSWORD_LENGTH = 14
PASSWORD_CHARS = "".join(chr(code) for code in range(32, 127)) #les caractères imprimables

Objectif

Itérer sur une collection pour accumuler des valeurs numériques dans une variable simple.

Énoncé

Vous disposez d’une liste de dépenses, où chaque dépense est un dictionnaire avec un libellé et un montant en Francs Pacifiques. L’objectif est de calculer puis d’afficher le montant total de toutes ces dépenses.

Exemple

Données de départ :

achats = [
    {"libelle": "Casse-croute", "montant": 500},
    {"libelle": "Cinéma", "montant": 1200},
    {"libelle": "Plein de scooter", "montant": 2000},
    {"libelle": "Paquet de mangue", "montant": 500},
    {"libelle": "Ticket de bus", "montant": 200}
]

Résultat attendu :

Le total des dépenses est : 4400

Objectif

Itérer sur une collection pour cumuler des valeurs dans un nouveau dictionnaire de synthèse.

Énoncé

Vous disposez de la même liste de dépenses que dans l’exercice précédent, mais cette fois-ci chaque achat possède une catégorie. L’objectif est de regrouper ces dépenses par catégorie pour connaître le total dépensé dans chacune d’elles.

Parcourir la liste des achats pour créer un nouveau dictionnaire nommé depenses_par_categorie ; ce dictionnaire doit avoir pour clés les noms des catégories et pour valeurs la somme totale des montants dépensés dans chaque catégorie.

Indications

La logique à l’intérieur de la boucle sera la suivante :

• si la catégorie de l’achat est déjà une clé dans depenses_par_categorie, augmentez la valeur associée.
• sinon, créez cette nouvelle clé avec le montant de l’achat comme valeur de départ.

Exemple

Données de départ :

achats = [
    {"libelle": "Casse-croute", "montant": 500, "categorie": "nourriture"},
    {"libelle": "Cinéma", "montant": 1200, "categorie": "loisir"},
    {"libelle": "Plein de scooter", "montant": 2000, "categorie": "transport"},
    {"libelle": "Paquet de mangue", "montant": 500, "categorie": "nourriture"},
    {"libelle": "Ticket de bus", "montant": 200, "categorie": "transport"}
]

Résultat attendu (str(depenses_par_categorie)) :

{'loisir': 1200, 'nourriture': 1000, 'transport': 2200}

Gestion d’une collection

Le programme suivant est typique d’une application legacy (en mode console — avec utilisation d’un menu de choix) de gestion d’une collection. Il s’agit ici de gérer une liste d’étudiant·e·s : ajout, suppression, affichage et calcul de statistiques (moyenne d’âge).

Travail à faire:

• compléter le programme ; remarque : les instructions pass sont à retirer (elles servent à éviter les erreurs de syntaxe en attendant sa mise au point) ;
• améliorer les indications de typage ;
• ajouter la spécification des fonctions ;
• ajouter des “doctests” pour le calcul de la moyenne.

from typing import List, Dict

def menu(choix : List[str]) -> int:
    print("")
    for i in range(len(choix)) :
        print(i,":",choix[i])
    reponse = int (input("votre choix : "))
    print("")
    return reponse

def ajouter(classe : List[Dict], prenom : str, age : int):
    classe.append( { "prenom" : prenom, "age" : age })

def supprimer(classe : List[Dict], prenom : str):
    pass #A COMPLETER

def afficher(classe : List[Dict]):
    pass #A COMPLETER

def moyenne(classe : List[Dict]) -> int:
    pass #A COMPLETER

if __name__ == "__main__":
    sio = []
    choix = -1
    while (choix != 0):
        if (choix == 1):
            p = input("prénom : ")
            a = int(input("age : "))
            ajouter(sio, p, a)
        elif (choix == 2):
            p = input("prénom : ")
            supprimer(sio, p)
        elif (choix == 3):
            afficher(sio)
        elif (choix == 4):
            pass #A COMPLETER
        choix = menu(["quitter", "ajouter","supprimer","afficher","moyenne"])

Projet jeu de rôle

Céer un jeu de rôle en mode console comprenant joueurs et personnages non joueurs.