Calculs malins avec des Dictionnaires Python

Manipuler des dictionnaires en Python est souvent simple… jusqu’à ce qu’il faille extraire l’élément le moins cher, trier des valeurs, ou associer un nom à une valeur maximale. Dans cet article, voyons ensemble comment éviter les pièges classiques et tirer le meilleur de vos données en dictionnaire — grâce à quelques techniques efficaces et faciles à retenir. Prenons ce dictionnaire qui associe des noms d’actions à leurs prix :

prices = {
    'ACME': 45.23,
    'AAPL': 612.78,
    'IBM': 205.55,
    'HPQ': 37.20,
    'FB': 10.75
}

Vous souhaitez maintenant :

  • Trouver le prix le plus bas et le plus haut
  • Connaître les noms des actions correspondantes
  • Trier les actions par prix

Pour effectuer des calculs utiles sur le contenu du dictionnaire, il est souvent pratique d'inverser les clés et les valeurs à l'aide de la fonction zip(). Par exemple, voici comment trouver le prix minimum et maximum, ainsi que le nom de l'action correspondante :

min_price = min(zip(prices.values(), prices.keys()))
# (10.75, 'FB')
max_price = max(zip(prices.values(), prices.keys()))
# (612.78, 'AAPL')

De la même manière, pour classer les données, utilisez zip() avec la fonction sorted(), comme ceci :

prices_sorted = sorted(zip(prices.values(), prices.keys()))
# [(10.75, 'FB'), (37.2, 'HPQ'), (45.23, 'ACME'), (205.55, 'IBM'), (612.78, 'AAPL')]

À savoir : Lorsque vous effectuez ces calculs, il est important de noter que zip() crée un itérateur qui ne peut être consommé qu'une seule fois. Si vous essayez de l'utiliser plusieurs fois, vous obtiendrez une erreur.

Par exemple, le code suivant provoquera une erreur :

prices_and_names = zip(prices.values(), prices.keys())
print(min(prices_and_names)) # OK, le premier appel fonctionne
print(max(prices_and_names)) # ValueError: max() arg is an empty sequence

Dans cet exemple, le premier appel à min() a consommé l'itérateur prices_and_names. L'itérateur étant maintenant vide, le deuxième appel à max() ne trouve rien à traiter. Pour éviter cela, créez un nouvel itérateur à chaque fois que vous en avez besoin, ou convertissez l'itérateur en une liste si vous devez le parcourir plusieurs fois :

prices_and_names_list = list(zip(prices.values(), prices.keys()))
print(min(prices_and_names_list)) # OK
print(max(prices_and_names_list)) # OK

Le piège des calculs directs sur les dictionnaires

Si vous essayez d'effectuer des calculs courants directement sur un dictionnaire, vous remarquerez qu'ils ne traitent que les clés, et non les valeurs. Par exemple :

min(prices) # Renvoie 'AAPL'
max(prices) # Renvoie 'IBM'

Ceci est probablement un comportement indésiré, car vous cherchez généralement à faire un calcul sur les valeurs du dictionnaire. Vous pourriez être tenté de corriger cela en utilisant la méthode values() du dictionnaire :

min(prices.values()) # Renvoie 10.75
max(prices.values()) # Renvoie 612.78

Malheureusement, cette approche n'est souvent pas suffisante. Par exemple, vous voudrez peut-être connaître la clé correspondante à cette valeur (quelle est l'action ayant le prix le plus bas ?).

Une solution alternative : la fonction key

Vous pouvez obtenir la clé correspondant à la valeur minimale ou maximale en fournissant une fonction key aux fonctions min() et max(). Cette approche permet d'indiquer à la fonction sur quelle base la comparaison doit être effectuée. Par exemple :

min(prices, key=lambda k: prices[k]) # Renvoie 'FB'
max(prices, key=lambda k: prices[k]) # Renvoie 'AAPL'

Cependant, pour obtenir la valeur minimale, vous devrez effectuer une étape de recherche supplémentaire. Par exemple :

min_value = prices[min(prices, key=lambda k: prices[k])]
# Renvoie 10.75

la solution avec zip() est souvent la meilleure

La solution impliquant zip() résout le problème en « inversant » le dictionnaire pour en faire une séquence de paires (valeur, clé). Lorsque Python effectue des comparaisons sur de tels tuples, il compare d'abord l'élément de la valeur, puis l'élément de la clé. Cela vous donne exactement le comportement souhaité et permet d'effectuer facilement des calculs et des tris sur le contenu du dictionnaire en une seule instruction.

Il est important de noter que dans les calculs impliquant des paires (valeur, clé), la clé sera utilisée pour départager les résultats si plusieurs entrées ont la même valeur. Par exemple, dans les calculs tels que min() et max(), l'entrée avec la plus petite ou la plus grande clé sera renvoyée si des valeurs en double existent.

prices = { 'AAA' : 45.23, 'ZZZ': 45.23 }
min(zip(prices.values(), prices.keys())) # (45.23, 'AAA')
max(zip(prices.values(), prices.keys())) # (45.23, 'ZZZ')

Dans ce cas, comme les valeurs sont identiques, min() et max() se basent sur les clés pour prendre leur décision. L'ordre lexicographique des clés ('AAA' vient avant 'ZZZ') détermine le résultat.

Publié le

me contacter

* champ obligatoire