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.
my_dict = {}
my_dict = {'clé1': 'valeur1', 'clé2': 'valeur2', 'clé3': 'valeur3'}
value = my_dict['clé']
my_dict['clé'] = 'nouvelle valeur'
del my_dict['clé']
for key in my_dict:
print(key)
for value in my_dict.values():
print(value)
for key, value in my_dict.items():
print(key, value)
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.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)]
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.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 {}
É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}
É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'
É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}
É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'
É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é.
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'}
Écrivez une fonction trier_dictionnaire_par_valeurs(dictionnaire)
qui prend un dictionnaire et retourne une liste de tuples triée par valeur.
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)]
É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.
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']}
Les mathématiques ont souvent la réputation d'être une discipline austère et difficile, mais ...
Read more.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.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.Abonnez-vous maintenant et recevez notre newsletter hebdomadaire avec des matériaux éducatifs, de nouveaux cours, des articles intéressants, des livres populaires et bien plus encore !