J'ai passé mes heures du matin sur une mission importante. Quelle est la réponse la plus claire, la plus rapide et la plus concise à la question suivante :
💬 Comment trouvez-vous la clé avec la valeur maximale dans un dictionnaire Python ?
La plupart des réponses sur le Web disent que vous devez utiliser une bibliothèque, mais ce n'est pas vrai ! Au lieu de cela, vous pouvez simplement appliquer la solution suivante à ce problème :
Pour trouver la clé avec la valeur maximale dans un dictionnaire Python d , appelez le max(d, key=d.get) . Cela renvoie la clé avec la valeur maximale après avoir appliqué le dict.get(k) k pour obtenir leurs valeurs associées.
Voici un exemple minimal :
income = {'Anne' : 1111,
'Bert' : 2222,
'Cara' : 9999999}
print(max(income, key=income.get))
# Cara
Le max() la fonction passe sur toutes les touches k , dans le dictionnaire revenu et prend celui qui a une valeur maximale après application du income.get(k) méthode. Le get() la méthode renvoie la valeur spécifiée pour la clé k dans le dictionnaire.
Dans le reste de l'article, vous apprendrez la réponse à quelques questions connexes afin qu'en fin de compte, vous connaissiez beaucoup mieux les dictionnaires :
- Comment obtenir la valeur maximale dans un dictionnaire Python ?
- Comment obtenir la clé avec la valeur maximale dans un dictionnaire Python ?
- Comment obtenir la clé maximale dans un dictionnaire Python ?
- Comment obtenir la clé avec la valeur maximale dans un dictionnaire Python ?
- Comment obtenir la valeur la plus élevée et la plus faible dans un dictionnaire Python ?
Mais avant de commencer, n'hésitez pas à consulter mon best-seller sur la construction d'une carrière passionnante en utilisant uniquement vos compétences Python et un cahier :
Voulez-vous développer les compétences d'un professionnel Python complet —tout en étant payé dans le processus ? Devenez freelance Python et commandez votre livre Leaving the Rat Race with Python sur Amazon (Kindle/Print ) !
Qu'est-ce que la fonction Max en Python ?
Très probablement, vous connaissez déjà le max() de Python fonction. Vous pouvez l'utiliser pour trouver la valeur maximale de n'importe quel itérable ou n'importe quel nombre de valeurs.
Le max() La fonction renvoie le maximum des arguments fournis. Vous pouvez passer soit un nombre arbitraire de valeurs, séparées par des virgules, soit un itérable comme arguments. Un key facultatif L'argument de la fonction vous permet de personnaliser le calcul du maximum en définissant explicitement le poids de chaque valeur dans l'itérable qui est utilisé comme base de comparaison.
Apprenez-en plus dans notre guide ultime sur le max() fonction sur le blog Finxter ici.
Pourquoi ne pas jeter un coup d'œil rapide sur quelques exemples de base sans le key argument pour commencer ?
# Key that starts with 'largest' letter of the alphabet print(max(income)) # Mary # Largest value in the dictionary income print(max(income.values())) # 878000 # Largest value in the given list print(max([1,4,7,5,3,99,3])) # 99 # Compare lists element wise, max is first list to have a larger # element print(max([1,2,3],[5,6,4])) # [5, 6, 4] # Largest value in the given sequence of numbers print(max(5,7,99,88,123)) # 123
Jusqu'ici tout va bien. Le max la fonction est très flexible. Cela fonctionne non seulement pour les nombres, mais aussi pour les chaînes, les listes et tout autre objet que vous pouvez comparer à d'autres objets.
Voyons maintenant les arguments optionnels du max fonction. L'un d'eux est 'key' . Découvrons ce qu'il fait.
Comment fonctionne l'argument clé de la fonction max() de Python ?
Les derniers exemples montrent le fonctionnement intuitif de la fonction max :vous passez un ou plusieurs itérables comme arguments positionnels.
🎓 Que sont les itérables ? Un itérable est un objet à partir duquel vous pouvez obtenir un itérateur. Un itérateur est un objet sur lequel vous pouvez appeler le next() fonction. Chaque fois que vous appelez le next() , vous obtenez l'élément suivant jusqu'à ce qu'il ne reste plus d'éléments dans l'itérateur. Par exemple, Python utilise des itérateurs dans for boucles pour parcourir tous les éléments d'une liste, tous les caractères d'une chaîne ou toutes les clés d'un dictionnaire.
Lorsque vous spécifiez le key argument, définissez une fonction qui renvoie une valeur pour chaque élément de l'itérable.
Ensuite, chaque élément est comparé en fonction de la valeur de retour de cette fonction, et non de l'élément itérable (le comportement par défaut).
Voici un exemple :
lst = [2, 4, 8, 16] def inverse(val): return -val print(max(lst)) # 16 print(max(lst, key=inverse)) # 2
On définit une fonction inverse() qui renvoie la valeur multipliée par -1 .
Maintenant, nous imprimons deux exécutions de la fonction max().
- Le premier est l'exécution par défaut :le maximum de la liste
[2, 4, 8, 16]est16. - Le second utilise
key. Nous spécifionsinversecomme lekeyfonction. Python applique cette fonction à toutes les valeurs de[2, 4, 8, 16]. Il compare ces nouvelles valeurs entre elles et renvoie le max.
Utilisation du inverse() la fonction Python effectue les mappages suivants :
| Valeur d'origine | Valeur après inverse() appliqué comme base pour max() |
| 2 | -2 |
| 4 | -4 |
| 8 | -8 |
| 16 | -16 |
Python calcule le maximum en fonction de ces mappages. Dans ce cas, la valeur 2 (avec mapping -2) est la valeur maximale car -2 > -4 > -8 > -1 6.
Revenons maintenant à la question initiale :
Comment obtenir la clé avec la valeur maximale dans un dictionnaire ?
Nous utilisons le même exemple que ci-dessus. Le dictionnaire stocke les revenus de trois personnes John, Mary et Alice. Supposons que vous vouliez trouver la personne ayant le revenu le plus élevé.
En d'autres termes, quelle est la clé avec la valeur maximale dans le dictionnaire ?
Maintenant, ne confondez pas la clé du dictionnaire avec l'optionnel key argument du max() fonction. Ils n'ont rien en commun - c'est juste une malheureuse coïncidence qu'ils portent le même nom !
D'après le problème, nous savons que le résultat est un dictionnaire key . Donc, nous appelons max( ) sur les touches du dictionnaire. Notez que max(income.keys()) est identique à max(income) .
✏️ Ressource :Pour en savoir plus sur les dictionnaires, consultez notre article Python Dictionary – The Ultimate Guide.
Cependant, nous voulons comparer les valeurs du dictionnaire, pas les clés. Nous utiliserons le key argument de max() pour faire ça. Il faut lui passer une fonction mais laquelle ?
Pour obtenir la valeur de 'Anne' , nous pouvons utiliser la notation parenthèses – income['Anne'] . Mais la notation entre parenthèses n'est pas une fonction, donc cela ne fonctionne pas.
Heureusement, income.get('Anne') est similaire à income['Anne'] et c'est une fonction ! La seule différence est qu'il renvoie None si la clé n'est pas dans le dictionnaire.
Nous allons donc passer cela à l'argument clé de max() .
income = {'Anne' : 1111,
'Bert' : 2222,
'Cara' : 9999999}
print(max(income, key=income.get))
# Cara
Comment obtenir la clé avec la valeur minimale dans un dictionnaire ?
Si vous avez compris l'extrait de code précédent, celui-ci sera facile.
Pour trouver la clé avec la valeur minimale dans le dictionnaire, nous utilisons le min(income, key=income.get) fonction.
income = {'Anne' : 1111,
'Bert' : 2222,
'Cara' : 9999999}
print(min(income, key=income.get))
# Anne
La seule différence est que nous utilisons le min( intégré ) au lieu de la fonction intégrée max() fonction. C'est tout.
Tutoriels associés
- Comment obtenir la clé avec la valeur minimale dans un dictionnaire ?
Trouvez la clé avec la valeur maximale dans un dictionnaire - Méthodes alternatives
Il existe de nombreuses façons de résoudre ce problème. Ils ne sont pas aussi beaux ou propres que la méthode ci-dessus. Mais, pour être complet, explorons d'autres façons d'obtenir la même chose.
Dans une réponse StackOverflow, un utilisateur a comparé neuf (!) Méthodes différentes pour trouver la clé avec la valeur maximale dans un dictionnaire.
Les voici :
# Convert to lists and use .index(max())
def f1():
v=list(income.values())
k=list(income.keys())
return k[v.index(max(v))]
# Dictionary comprehension to swap keys and values
def f2():
d3={v:k for k,v in income.items()}
return d3[max(d3)]
# Use filter() and a lambda function
def f3():
return list(filter(lambda t: t[1]==max(income.values()), income.items()))[0][0]
# Same as f3() but more explicit
def f4():
m=max(income.values())
return list(filter(lambda t: t[1]==m, income.items()))[0][0]
# List comprehension
def f5():
return [k for k,v in income.items() if v==max(income.values())][0]
# same as f5 but remove the max from the comprehension
def f6():
m=max(income.values())
return [k for k,v in income.items() if v==m][0]
# Method used in this article
def f7():
return max(income,key=income.get)
# Similar to f1() but shortened to 2 lines
def f8():
v=list(income.values())
return list(income.keys())[v.index(max(v))]
# Similar to f7() but use a lambda function
def f9():
return max(income, key=lambda k: income[k])
print(f1())
print(f2())
print(f3())
print(f4())
print(f5())
print(f6())
print(f7())
print(f8())
print(f9())
# Cara (all outputs)
Dans un benchmark effectué sur un grand dictionnaire par l'utilisateur StackOverflow, f1() s'est avéré être le plus rapide.
Donc, la deuxième meilleure façon d'obtenir la clé avec la valeur maximale à partir d'un dictionnaire est :
income = {'Anne' : 1111,
'Bert' : 2222,
'Cara' : 9999999}
v=list(income.values())
k=list(income.keys())
print(k[v.index(max(v))])
# Cara Rechercher la clé avec la valeur la plus longue dans le dictionnaire
Nous savons comment trouver la valeur maximale si les valeurs sont des nombres. Qu'en est-il s'il s'agit de listes ou de chaînes ?
Disons que nous avons un dictionnaire qui enregistre le nombre de jours travaillés par chaque personne ce mois-ci. S'ils ont travaillé un jour, nous ajoutons 1 à la liste de cette personne. S'ils ne fonctionnent pas, nous ne faisons rien. À la fin du mois, notre dictionnaire ressemble à ceci.
days_worked = {'Anne': [1, 1, 1, 1],
'Bert': [1, 1, 1, 1, 1, 1],
'Cara': [1, 1, 1, 1, 1, 1, 1, 1]} Le nombre total de jours travaillés chaque mois correspond à la longueur de chaque liste.
Si tous les éléments des deux listes sont identiques (comme c'est le cas ici), ils sont comparés en fonction de leur longueur.
# Length 2 is less than length 4 >>> [1, 1] < [1, 1, 1, 1] True
Nous pouvons donc utiliser le même code que nous avons utilisé dans l'article pour trouver la clé avec la valeur maximale.
>>> max(days_worked, key=days_worked.get) 'Cara'
Si nous mettons à jour notre dictionnaire afin que Bert ait travaillé le plus de jours et appliquons max() encore une fois, Python renvoie 'Bert' .
>>> days_worked = {'Anne': [1, 1, 1, 1],
'Bert': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
'Cara': [1, 1, 1, 1, 1, 1, 1, 1]}
# Bert has now worked the most
>>> max(days_worked, key=days_worked.get) Rechercher une clé avec une valeur maximale dans une liste de dictionnaires
Disons que nous avons trois dictionnaires contenant des informations sur le revenu. Nous voulons trouver la clé avec la valeur maximale dans les trois dictionnaires.
income1 = {'Anne': 1111,
'Bert': 2222,
'Cara': 3333}
income2 = {'Dani': 4444,
'Ella': 5555,
'Fred': 6666}
income3 = {'Greg': 7777,
'Hope': 8888,
'Igor': 999999999999}
list_of_dicts = [income1, income2, income3]
Nous pouvons voir que 'Igor' a le revenu le plus élevé, nous nous attendons donc à ce qu'il soit remboursé.
Il y a plusieurs moyens de le faire.
Pour obtenir la clé avec la valeur maximale dans une liste de dictionnaires, fusionnez d'abord tous les dictionnaires au moyen d'un dict.update() méthode dans une boucle for itérant sur la liste de tous les dictionnaires. Puis avec les paires clé-valeur dans un grand dictionnaire d , appelez le max(d, key = dict.get) pour obtenir la clé du dictionnaire avec la valeur maximale.
Voici un exemple simple :
# Initialise empty dict
>>> big_dict = {}
# Use for loop and .update() method to add the key-value pairs
>>> for dic in list_of_dicts:
big_dict.update(dic)
# Check the result is as expected
>>> big_dict
{'Anne': 1111,
'Bert': 2222,
'Cara': 3333,
'Dani': 4444,
'Ella': 5555,
'Fred': 6666,
'Greg': 7777,
'Hope': 8888,
'Igor': 999999999999}
# Call max() and specify key argument
>>> max(big_dict, key=big_dict.get)
'Igor' Comment obtenir la valeur maximale dans un dictionnaire Python ?
Pour obtenir la valeur maximale dans un dictionnaire Python d , appelez le max(d.values()) . Cela obtient d'abord un itérable de toutes les valeurs du dictionnaire avec d.values() et le passe dans le max() fonction qui trouve la valeur maximale unique.
Voici un exemple qui obtient la valeur entière maximale à partir des valeurs du dictionnaire :
d = {'Anne': 24,
'Alice': 19,
'Bob': 35}
max_val = max(d.values())
print(max_val)
# 35
Comment obtenir la clé maximale dans un dictionnaire Python ?
Pour obtenir la clé maximale dans un dictionnaire Python d , appelez le max(d) ou max(d.keys()) . Les deux sont équivalents car ils transmettent tous les deux l'itérable des clés dans le max() fonction qui obtient la clé max.
Voici un exemple qui obtient la chaîne maximale à partir des clés du dictionnaire :
d = {'Anne': 24,
'Alice': 19,
'Bob': 35}
print(max(d))
# 'Bob'
print(max(d.keys()))
# 'Bob'
Comment obtenir la valeur la plus élevée et la plus faible dans un dictionnaire Python ?
Pour obtenir la valeur la plus haute et la plus basse dans un dictionnaire Python d , appelez les fonctions max(d) et min(d) , respectivement.
d = {1: 'a',
0: 'b',
2: 'c'}
print(max(d))
# 2
print(min(d))
# 0
