madamasterclass.com

📔 Les dictionnaires

Exploration des dictionnaires en python

Les dictionnaires en Python. Les dictionnaires sont des collections d'objets non-ordonnées. Un dictionnaire est composé d'éléments et chaque élément se compose d'une paire clé: valeur. Dans d'autres langages de programmation, on parle de tableaux associatifs ou de hashs.


1. Introduction aux dictionnaires
  • Un dictionnaire est une structure de données en Python qui permet de stocker des paires clé-valeur.
  • Les clés sont uniques et servent d'index pour accéder aux valeurs correspondantes.
  • Les dictionnaires sont également appelés "maps", "hash maps" ou "tables de hachage".
2. Création et manipulation des dictionnaires :
  • Création d'un dictionnaire vide :
      my_dict = {}
  • Création d'un dictionnaire avec des paires clé-valeur :
      my_dict = {'clé1': 'valeur1', 'clé2': 'valeur2', 'clé3': 'valeur3'}
  • Accès aux valeurs d'un dictionnaire à l'aide des clés :
      value = my_dict['clé']
  • Modification des valeurs d'un dictionnaire :
      my_dict['clé'] = 'nouvelle valeur'
  • Suppression d'une paire clé-valeur d'un dictionnaire :
      del my_dict['clé']
3. Parcours de dictionnaire en Python :
  • Parcours des clés :
      for key in my_dict:
      print(key)
  • Parcours des valeurs :
      for value in my_dict.values():
      print(value)
  • Parcours des paires clé-valeur :
      for key, value in my_dict.items():
      print(key, value)
4. Méthodes prédéfinies des dictionnaires :
  • len() : Retourne le nombre de paires clé-valeur dans le dictionnaire.
  • keys() : Retourne une liste des clés du dictionnaire.
  • values() : Retourne une liste des valeurs du dictionnaire. 
  • items() : Retourne une liste de tuples (clé, valeur) représentant les paires clé-valeur.
  • Exemple :
    my_dict = {'a': 1, 'b': 2, 'c': 3}
    print(len(my_dict)) # Affiche 3
    print(my_dict.keys()) # Affiche ['a', 'b', 'c']
    print(my_dict.values()) # Affiche [1, 2, 3]
    print(my_dict.items()) # Affiche [('a', 1), ('b', 2), ('c', 3)]
5. Méthodes de manipulation des dictionnaires :
  • get(key) : Retourne la valeur correspondante à la clé donnée. Si la clé n'existe pas, retourne une valeur par défaut ou None.
  • pop(key) : Supprime et retourne la valeur correspondant à la clé donnée.
  • update(other_dict) : Met à jour le dictionnaire en ajoutant les paires clé-valeur d'un autre dictionnaire.
  • clear() : Supprime toutes les paires clé-valeur du dictionnaire.
  • Exemple :
    my_dict = {'a': 1, 'b': 2, 'c': 3}

    print(my_dict.get('a')) # Affiche 1
    print(my_dict.pop('b')) # Affiche 2 et supprime la paire ('b', 2)
    print(my_dict) # Affiche {'a': 1, 'c': 3}

    other_dict = {'d': 4, 'e': 5}
    my_dict.update(other_dict)
    print(my_dict) # Affiche {'a': 1, 'c': 3, 'd': 4, 'e': 5}

    my_dict.clear()
    print(my_dict) # Affiche {}

Exercices - corrigés: les dictionnaires
Exercice 1:

Écrivez une fonction Python qui prend en entrée une liste d'éléments et qui renvoie un dictionnaire contenant le nombre d'occurrences de chaque élément dans la liste.

def compter_occurrences(elements):
occurrences = {}
for element in elements:
if element in occurrences:
occurrences[element] += 1
else:
occurrences[element] = 1
return occurrences

# Exemple d'utilisation
liste = [1, 2, 3, 2, 1, 3, 3, 4, 5, 4, 4]
print(compter_occurrences(liste)) # Résultat : {1: 2, 2: 2, 3: 3, 4: 3, 5: 1}

Exercice 2:

Écrivez une fonction Python qui prend en entrée un dictionnaire contenant des noms et des âges, et qui renvoie le nom de la personne la plus âgée.

def personne_plus_agee(personnes):
plus_agee = None
age_max = float('-inf')
for nom, age in personnes.items():
if age > age_max:
plus_agee = nom
age_max = age
return plus_agee

# Exemple d'utilisation
personnes = {'Alice': 25, 'Bob': 30, 'Charlie': 22, 'David': 27}
print(personne_plus_agee(personnes)) # Résultat : 'Bob'

Exercice 3:

Écrivez une fonction Python qui prend en entrée une liste de mots et qui renvoie un dictionnaire contenant le nombre de caractères de chaque mot.

def longueur_mots(mots):
longueurs = {}
for mot in mots:
longueurs[mot] = len(mot)
return longueurs

# Exemple d'utilisation
liste_mots = ['chat', 'chien', 'oiseau', 'souris']
print(longueur_mots(liste_mots)) # Résultat : {'chat': 4, 'chien': 5, 'oiseau': 6, 'souris': 6}

Exercice 4:

Écrivez une fonction Python qui prend en entrée un dictionnaire contenant des produits et leurs prix, et qui renvoie le produit le moins cher.

def produit_moins_cher(produits):
moins_cher = None
prix_min = float('inf')
for produit, prix in produits.items():
if prix < prix_min:
moins_cher = produit
prix_min = prix
return moins_cher

# Exemple d'utilisation
produits = {'Pommes': 2.5, 'Bananes': 1.8, 'Oranges': 3.2, 'Poires': 2.1}
print(produit_moins_cher(produits)) # Résultat : 'Bananes'

Exercice 5: Inverser un Dictionnaire

Écrivez une fonction inverser_dictionnaire(dictionnaire) qui prend un dictionnaire et retourne un nouveau dictionnaire où les clés deviennent des valeurs et vice versa. Si plusieurs clés ont la même valeur, ne gardez qu'une seule clé.

Exemple :
dico = {'a': 1, 'b': 2, 'c': 1}
resultat = inverser_dictionnaire(dico)
print(resultat)  # Output: {1: 'c', 2: 'b'}
def inverser_dictionnaire(dictionnaire):
resultat = {}
for cle, valeur in dictionnaire.items():
if valeur not in resultat: # ne garde qu'une seule clé
resultat[valeur] = cle
return resultat

# Exemple
dico = {'a': 1, 'b': 2, 'c': 1}
resultat = inverser_dictionnaire(dico)
print(resultat) # Output: {1: 'c', 2: 'b'}

Exercice 6: Classement par Valeurs

Écrivez une fonction trier_dictionnaire_par_valeurs(dictionnaire) qui prend un dictionnaire et retourne une liste de tuples triée par valeur.

Exemple :
dico = {'a': 3, 'b': 1, 'c': 2}
resultat = trier_dictionnaire_par_valeurs(dico)
print(resultat)  # Output: [('b', 1), ('c', 2), ('a', 3)]
def trier_dictionnaire_par_valeurs(dictionnaire):
return sorted(dictionnaire.items(), key=lambda item: item[1])

# Exemple
dico = {'a': 3, 'b': 1, 'c': 2}
resultat = trier_dictionnaire_par_valeurs(dico)
print(resultat) # Output: [('b', 1), ('c', 2), ('a', 3)]

Exercice 7: Dictionnaire de Groupes

Écrivez une fonction grouper_par_longueur(liste) qui prend une liste de mots et retourne un dictionnaire où les clés sont les longueurs des mots et les valeurs sont des listes de mots de cette longueur.

Exemple :
input_data = ["apple", "bat", "cat", "banana", "pear"]
resultat = grouper_par_longueur(input_data)
print(resultat)  # Output: {3: ['bat', 'cat'], 5: ['apple', 'pear'], 6: ['banana']}
def grouper_par_longueur(liste):
resultat = {}
for mot in liste:
longueur = len(mot)
if longueur not in resultat:
resultat[longueur] = []
resultat[longueur].append(mot)
return resultat

# Exemple
input_data = ["apple", "bat", "cat", "banana", "pear"]
resultat = grouper_par_longueur(input_data)
print(resultat) # Output: {3: ['bat', 'cat'], 5: ['apple', 'pear'], 6: ['banana']}

Forum(s) associé(s)

Mathématiques Magiques : Dévoilez les Mystères des Nombres

08 Apr, 2016

Les mathématiques ont souvent la réputation d'être une discipline austère et difficile, mais ...

Read more.

Voyage à Travers les Suites Numériques : Découvertes et Applications

27 Jan, 2014

Plongez dans l'univers fascinant des suites numériques, où chaque terme révèle des patterns surprenants et des applications pratiques dans les mathématiques et au-delà.

Read more.

Fonctions en Action : Comprendre et Explorer les Relations Mathématiques

30 Feb, 2015

Découvrez comment les fonctions tissent des liens entre les nombres et les concepts, transformant des idées abstraites en outils puissants pour résoudre des problèmes du quotidien.

Read more.
Page: