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 trouver la clé avec la valeur minimale 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 !
Pour trouver la clé avec la valeur minimale dans un dictionnaire Python d , appelez le min(d, key=d.get) . Cela renvoie la clé avec la valeur minimale 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(min(income, key=income.get))
# Anne
Le min() la fonction passe sur toutes les touches, k , dans le dictionnaire income et prend celui qui a la valeur minimale 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 minimale dans un dictionnaire Python ?
- Comment obtenir la clé avec une valeur minimale dans un dictionnaire Python ?
- Comment obtenir la clé minimale dans un dictionnaire Python ?
- Comment obtenir la clé avec une valeur minimale dans un dictionnaire Python ?
- Comment obtenir la valeur la plus élevée et la plus faible dans un dictionnaire Python ?
Qu'est-ce que la fonction Min en Python ?
Très probablement, vous connaissez déjà le min() de Python fonction. Vous pouvez l'utiliser pour trouver la valeur minimale de n'importe quel itérable ou n'importe quel nombre de valeurs.
Le min() La fonction renvoie le minimum des arguments fournis. En tant qu'arguments, vous pouvez soit passer un certain nombre de valeurs séparées par des virgules, soit un seul itérable. Un key facultatif L'argument de la fonction vous permet de personnaliser le calcul du minimum en définissant explicitement le poids de chaque valeur dans l'itérable qui est utilisé comme base de comparaison.
Voici quelques exemples utilisant la fonction min sans spécifier d'arguments facultatifs.
income = {'Anne' : 1111,
'Bert' : 2222,
'Cara' : 9999999}
print(min(income, key=income.get))
# Anne
# Key that starts with 'smallest' letter of the alphabet
print(min(income))
# Anne
# Smallest value in the dictionary income
print(min(income.values()))
# 1111
# Smallest value in the given list
print(min([1,4,7,5,3,99,3]))
# 1
# Compare lists element-wise, min is first list to have a larger
# element
print(min([1,2,3],[5,6,4]))
# [1, 2, 3]
# Smallest value in the given sequence of numbers
print(min(5,7,99,88,123))
# 5
Jusqu'ici tout va bien. La fonction min 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.
Examinons maintenant les arguments optionnels de la fonction min. L'un d'eux est 'key' . Découvrons ce qu'il fait.
Comment fonctionne l'argument clé de la fonction min() de Python ?
Les derniers exemples montrent le fonctionnement intuitif de la fonction min :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 l'argument clé, 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(min(lst)) # 2 print(min(lst, key=inverse)) # 16
On définit une fonction inverse() qui renvoie la valeur multipliée par -1. Maintenant, nous imprimons deux exécutions du min() fonction.
- Le premier est l'exécution par défaut :le minimum de la liste
[2, 4, 8, 16]est 2. - La seconde utilise la clé. Nous spécifions
inversecomme fonction clé. Python applique cette fonction à toutes les valeurs de[2, 4, 8, 16]. Il compare ces nouvelles valeurs entre elles et renvoie le min. En utilisant la fonction inverse, Python effectue les mappages suivants :
| Valeur d'origine | Valeur après inverse() (base pour min()) |
| 2 | -2 |
| 4 | -4 |
| 8 | -8 |
| 16 | -16 |
Python calcule le minimum en fonction de ces mappages. Dans ce cas, la valeur 16 (avec mappage -16) est la valeur minimale car -2> -4> -8> -16.
Revenons maintenant à la question initiale :
Comment obtenir la clé avec la valeur minimale 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 avec le plus petit revenu. En d'autres termes, quelle est la clé avec la valeur minimale dans le dictionnaire ?
Maintenant, ne confondez pas la clé du dictionnaire avec l'argument clé facultatif du min() 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 une clé de dictionnaire. Donc, nous appelons min() sur les touches du dictionnaire. Notez que min(income.keys()) est identique à min(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 l'argument clé de min() 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') fait (presque) la même chose que income['Anne'] et c'est une fonction ! La seule différence est qu'il renvoie None si leur clé n'est pas dans le dictionnaire.
Nous allons donc passer cela à l'argument clé de min() .
income = {'Anne' : 1111,
'Bert' : 2222,
'Cara' : 9999999}
print(min(income, key=income.get))
# Anne Comment obtenir la clé avec la valeur maximale 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 maximale dans le dictionnaire, vous utilisez le max() fonction.
income = {'Anne' : 1111,
'Bert' : 2222,
'Cara' : 9999999}
print(max(income, key=income.get))
# Cara
La seule différence est que vous utilisez le max() intégré fonction au lieu de la fonction intégrée min() fonction. C'est tout.
Vidéo associée :
Article connexe :
- Comment obtenir la clé avec la valeur maximale dans un dictionnaire ?
Trouvez la clé avec la valeur minimale 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 minimale dans un dictionnaire.
Les voici :
income = {'Anne' : 11111,
'Bert' : 2222,
'Cara' : 9999999}
# Convert to lists and use .index(min())
def f1():
v=list(income.values())
k=list(income.keys())
return k[v.index(min(v))]
# Dictionary comprehension to swap keys and values
def f2():
d3={v:k for k,v in income.items()}
return d3[min(d3)]
# Use filter() and a lambda function
def f3():
return list(filter(lambda t: t[1]==min(income.values()), income.items()))[0][0]
# Same as f3() but more explicit
def f4():
m=min(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==min(income.values())][0]
# same as f5 but remove the max from the comprehension
def f6():
m=min(income.values())
return [k for k,v in income.items() if v==m][0]
# Method used in this article
def f7():
return min(income,key=income.get)
# Similar to f1() but shortened to 2 lines
def f8():
v=list(income.values())
return list(income.keys())[v.index(min(v))]
# Similar to f7() but use a lambda function
def f9():
return min(income, key=lambda k: income[k])
print(f1())
print(f2())
print(f3())
print(f4())
print(f5())
print(f6())
print(f7())
print(f8())
print(f9())
# Bert (all outputs)
Dans un benchmark effectué sur un grand dictionnaire par l'utilisateur de StackOverflow, f1() s'est avéré être le plus rapide.
Donc, la deuxième meilleure façon d'obtenir la clé avec la valeur minimale à partir d'un dictionnaire est :
income = {'Anne' : 11111,
'Bert' : 2222,
'Cara' : 9999999}
v=list(income.values())
k=list(income.keys())
print(k[v.index(min(v))])
# Bert Rechercher la clé avec la valeur la plus courte dans le dictionnaire
Nous savons comment trouver la valeur minimale 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 de 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 minimale.
>>> min(days_worked, key=days_worked.get) 'Anne'
Si nous mettons à jour notre dictionnaire afin que Bert ait travaillé le plus de jours et appliquions min() encore une fois, Python renvoie 'Anne' .
>>> 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]}
# Anne has now worked the least
>>> min(days_worked, key=days_worked.get) Rechercher une clé avec une valeur minimale dans une liste de dictionnaires
Disons que nous avons 3 dictionnaires contenant des informations sur le revenu. Nous voulons trouver la clé avec la valeur min dans les 3 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 'Anne' a le revenu le plus bas, nous nous attendons donc à ce qu'il soit remboursé.
Il y a plusieurs moyens de le faire.
Pour obtenir la clé avec la valeur minimale 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 min(d, key = dict.get) pour obtenir la clé du dictionnaire avec la valeur minimale.
Voici un exemple :
# 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 min() and specify key argument
>>> min(big_dict, key=big_dict.get)
'Anne' Comment obtenir la valeur minimale dans un dictionnaire Python ?
Pour obtenir la valeur minimale dans un dictionnaire Python d , appelez le min(d.values()) . Cela obtient d'abord un itérable de toutes les valeurs du dictionnaire avec d.values() et le passe dans le min() fonction qui trouve la valeur minimale unique.
Voici un exemple qui obtient la valeur entière minimale à partir des valeurs du dictionnaire :
d = {'Anne': 24,
'Alice': 19,
'Bob': 35}
min_val = min(d.values())
print(min_val)
# 19
Comment obtenir la clé minimale dans un dictionnaire Python ?
Pour obtenir la clé minimale dans un dictionnaire Python d , appelez le min(d) ou min(d.keys()) . Les deux sont équivalents car ils transmettent tous les deux l'itérable des clés dans le min() fonction qui obtient la clé min.
Voici un exemple qui obtient la chaîne minimale à partir des clés du dictionnaire :
d = {'Anne': 24,
'Alice': 19,
'Bob': 35}
print(min(d))
# 'Alice'
print(min(d.keys()))
# 'Alice'
Comment obtenir la valeur la plus élevée et la plus faible dans un dictionnaire Python ?
Pour obtenir la valeur la plus élevée et la plus faible 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
