Exercice Corrigé: Les dictionnaires en Python – Partie 2

Avec des exercices corrigés en Python, vous pratiquerez divers concepts du langage Python. Vous commencerez par des exercices Python de base à des exercices plus avancés. La solution est fournie pour chaque exercice. Vous devez essayer de résoudre chaque problème par vous-même avant de vérifier la solution. Si vous avez des questions concernant chaque problème, nous vous encourageons à les poster sur notre forum.
 
 

Exercice 1:

Écrire un programme Python pour créer et afficher toutes les combinaisons de lettres, en sélectionnant chaque lettre à partir d’une clé différente dans un dictionnaire.

Exemple:

Exemple de dictionnaire: {'1':['a','b'], '2':['c','d']}
ac
ad
bc
bd
Solution:

# Importez le module 'itertools', qui fournit des outils pour travailler avec des itérateurs et des objets itérables.
import itertools

# Créez un dictionnaire avec des clés '1' et '2', et des listes de caractères associées comme valeurs.
d = {'1': ['a', 'b'], '2': ['c', 'd']}

# Interroger les combinaisons de valeurs du dictionnaire 'd' en utilisant 'itertools.product'.
# Les valeurs sont triées en fonction de leurs clés afin de garantir un ordre spécifique.
for comb in itertools.product(*[d[k] for k in sorted(d.keys())]):
    # Affichez les combinaisons sous forme de chaînes de caractères en joignant les caractères de chaque combinaison.
    print(''.join(comb))
 

Exercice 2:

Écrire un programme Python pour trouver les 3 valeurs les plus élevées des clés correspondantes dans un dictionnaire.

Exemple:

Exemple de dictionnaire: 
{'a': 5, 'b': 1, 'c': 3, 'd': 8, 'e': 9, 'f': 7}

Résultat: ['e', 'd', 'f']
Solution:

# Importer la fonction 'nlargest' du module 'heapq'.
from heapq import nlargest

# Créer un dictionnaire 'd' avec des paires clé-valeur.
d = {'a': 5, 'b': 1, 'c': 3, 'd': 8, 'e': 9, 'f': 7}

# Utiliser la fonction 'nlargest' pour trouver les trois plus grandes clés du dictionnaire 'd' en fonction de leurs valeurs.
# L'argument 'key' spécifie que les valeurs doivent être utilisées pour la comparaison.
res = nlargest(3, d, key=d.get)

# Afficher les trois plus grandes clés trouvées dans le dictionnaire 'd'.
print(res)
 

Exercice 3:

Écrire un programme Python pour créer un dictionnaire à partir d’une chaîne de caractères.

Exemple:

Exemple de string: waytolearnx 

Résultat: {'w': 1, 'a': 2, 'y': 1, 't': 1, 'o': 1, 'l': 1, 'e': 1, 'r': 1, 'n': 1, 'x': 1}
Solution:

# Importez les classes 'defaultdict' et 'Counter' du module 'collections'.
from collections import defaultdict, Counter

# Créer une chaîne de caractères 'str'.
str = 'waytolearnx'

# Créez un dictionnaire vide 'd' pour stocker le nombre de caractères.
d = {}

# Parcourez les caractères de 'str' à l'aide d'une boucle for.
for letter in str:
    # Mettre à jour le 'd' en incrémentant le compteur du caractère courant.
    # Utiliser la méthode 'get' avec une valeur par défaut de 0 pour initialiser les compteurs des nouveaux caractères.
    d[letter] = d.get(letter, 0) + 1

# Afficher le dictionnaire 'd', qui contient le nombre de caractères.
print(d) 
 

Exercice 4:

Écrire un programme Python pour afficher un dictionnaire sous forme de table.

Exemple:

Exemple de dictionnaire: 
{'C1': [1, 2, 3], 'C2': [4, 5, 6], 'C3': [7, 8, 9]}

Résultat: 
C1 C2 C3
1  4  7
2  5  8
3  6  9
Solution:

# Créez un dictionnaire 'd' dont les clés sont 'C1', 'C2' et 'C3', et les valeurs correspondantes.
d = {'C1': [1, 2, 3], 'C2': [4, 5, 6], 'C3': [7, 8, 9]}

# Utiliser une liste de compréhension pour créer une liste de tuples où chaque tuple contient une clé et sa liste de valeurs correspondante.
# Trier les éléments (paires clé-valeur) dans le dictionnaire 'd' en fonction de leurs clés.
# La fonction 'zip' est utilisée pour transposer les lignes et les colonnes.
for row in zip(*([key] + (value) for key, value in sorted(d.items()))):
    # Affiche chaque ligne de données transposées sous forme de valeurs séparées par des espaces.
    print(*row)
 

Exercice 5:

Écrire un programme Python pour convertir une liste en un dictionnaire imbriqué de clés.

Exemple:

Exemple de liste: [1, 2, 3, 4]

Résultat: {1: {2: {3: {4: {}}}}}
Solution:

# Créer une liste 'liste' contenant des nombres.
liste = [1, 2, 3, 4]

# Créez un dictionnaire vide 'd' et initialisez 'current' pour qu'il fasse référence au même dictionnaire.
d = current = {}

# Parcourez les nombres de la 'liste' à l'aide d'une boucle 'for'.
for i in liste:
    # Créer un dictionnaire vide imbriqué sous le dictionnaire 'current' avec le 'i' actuel comme clé.
    current[i] = {}
    
    # Mettre à jour la référence 'current' pour qu'elle pointe vers le dictionnaire imbriqué nouvellement créé.
    current = current[i]

# Afficher le dictionnaire 'd', qui est une structure imbriquée avec des dictionnaires vides.
print(d)
 

Exercice 6:

Écrire un programme Python pour trier une liste par ordre alphabétique dans un dictionnaire.

Exemple:

Exemple de dictionnaire: 
{'a': [2, 3, 1], 'b': [5, 1, 2], 'c': [3, 2, 4]}

Résultat: 
{'a': [1, 2, 3], 'b': [1, 2, 5], 'c': [2, 3, 4]}
Solution:

# Créez un dictionnaire 'd' avec les clés 'n1', 'n2' et 'n3', et des listes de nombres associées comme valeurs.
d = {'n1': [2, 3, 1], 'n2': [5, 1, 2], 'n3': [3, 2, 4]}

# Utiliser un dictionnaire pour créer un nouveau dictionnaire 'd'.
# Itère à travers les paires clé-valeur dans 'd' et trie les listes de nombres 'y' pour chaque clé 'x'.
d = {x: sorted(y) for x, y in d.items()}

# Affichez le dictionnaire 'd', qui contient les mêmes clés avec des listes triées de nombres comme valeurs.
print(d)
 

Exercice 7:

Écrire un programme Python pour supprimer les espaces dans les clés du dictionnaire.

Exemple:

Dictionnaire original: 
{'a  lex': 1, 'b o b': 2, 'em i ly': 3}

Résultat: 
{'alex': 1, 'bob': 2, 'emily': 3}
Solution:

d = {'a  lex': 1, 'b o b': 2, 'em i ly': 3}

print("Dictionnaire original: ", d)

# Utiliser un dictionnaire de compréhension pour créer un nouveau dictionnaire 'res'.
# Interroger les paires clé-valeur dans 'd'.
# Supprimer les espaces supplémentaires des clés en utilisant la méthode 'translate' avec une table de traduction.
res = {x.translate({32: None}): y for x, y in d.items()}

print("Résultat:", res) 
 

Exercice 8:

Écrire un programme Python pour obtenir la clé, la valeur et le compteur d’un dictionnaire.

Exemple:

Dictionnaire original: 
{'a': 10, 'b': 20, 'c': 30}

Résultat: 
key  value  count
a     10      1
b     20      2
c     30      3
Solution:

d = {'a': 10, 'b': 20, 'c': 30}

# Afficher un en-tête pour la table de sortie.
print("key  value  count")

# Parcourir les paires clé-valeur dans 'd' à l'aide de la fonction 'enumerate'.
# La fonction 'enumerate' attribue un compteur à partir de 1 à chaque paire et les décompose en (count, (key, value)).
for count, (key, value) in enumerate(d.items(), 1):
    # Afficher la clé, la valeur et le nombre dans une table formatée.
    print(key, '   ', value, '    ', count) 
 

Exercice 9:

Écrire un programme Python pour afficher un dictionnaire ligne par ligne.

Exemple:

Dictionnaire original: 
{'Mercedes':{'model': 'C190', 'id':2}, 'Audi': {'model': 'A9', 'id':3}}

Résultat: 
Mercedes
model : C190
id : 2
Audi
model : A9
id : 3
Solution:

cars = {'Mercedes': {'model': 'C190', 'id': 2}, 'Audi': {'model': 'A9', 'id': 3}}

# Parcourez les noms des voitures (clés) dans le dictionnaire à l'aide d'une boucle for.
for a in cars:
    # Afficher le nom de la voiture.
    print(a)
    
    # Parcourir les clés du dictionnaire imbriqué associé à la voiture actuelle à l'aide d'une boucle for imbriquée.
    for b in cars[a]:
        # Afficher la clé, les deux points et la valeur correspondante du dictionnaire imbriqué.
        print(b, ':', cars[a][b])
 

Exercice 10:

Écrire un programme Python pour vérifier si plusieurs clés existent dans un dictionnaire.

Exemple:

Dictionnaire original: {'name': 'Mercedes', 'model': 'C190', 'id':2}

Résultat: 
{'name', 'model'} -> True
{'name', 'Mercedes'} -> False
{'name', 'id'} -> True
Solution:

myCar = {'name': 'Mercedes', 'model': 'C190', 'id': 2}

# Vérifier si l'ensemble des clés de 'myCar' contient les clés 'name' et 'model'.
print(myCar.keys() >= {'name', 'model'})

print(myCar.keys() >= {'name', 'Mercedes'})

print(myCar.keys() >= {'id', 'name'})
 

Éditeur de code Python: Testez votre code en ligne!


 

QCM Python

Une réflexion sur “Exercice Corrigé: Les dictionnaires en Python – Partie 2

  • février 8, 2025 à 6:21 pm
    Permalien

    Exercice Corrigé: Les dictionnaires en Python – Partie 2 Exercice3
    Dans la solution proposée, dans la ligne suivante : from collections import defaultdict, Counter
    Le Counter est inutile. from collections import defaultdict est suffisant.

    Autre solution possible:

    from collections import defaultdict
    string="waytolearnx"
    dic = defaultdict(int)
    for i in string:
        dic[i] += 1
    print(dic)
    Répondre

Laisser un commentaire

Votre adresse e-mail ne sera pas publiée. Les champs obligatoires sont indiqués avec *