Comment parcourir un dictionnaire en Python – Real Python

By | mai 27, 2019

Python pas cher

Les dictionnaires sont l’une des structures de données les plus importantes et les plus utiles de Python. Ils peuvent vous aider à résoudre une grande variété de problèmes de programmation. Ce tutoriel vous plongera dans une plongée en profondeur dans la façon de parcourir un dictionnaire en Python.

À la fin de ce tutoriel, vous saurez:

  • Que sont les dictionnaires, ainsi que certaines de leurs principales caractéristiques et détails de mise en œuvre?
  • Comment parcourir un dictionnaire en Python en utilisant les outils de base offerts par le langage
  • Quel type de tâches du monde réel pouvez-vous effectuer en effectuant une itération dans un dictionnaire en Python?
  • Comment utiliser des techniques et des stratégies plus avancées pour parcourir un dictionnaire en Python

Pour plus d'informations sur les dictionnaires, vous pouvez consulter les ressources suivantes:

Prêt? Allons-y!

Quelques mots sur les dictionnaires

Les dictionnaires sont la pierre angulaire de Python. La langue elle-même est construite autour de dictionnaires. Modules, classes, objets, globals (), des locaux(): ce sont tous des dictionnaires. Les dictionnaires sont au cœur de Python depuis le début.

La documentation officielle de Python définit un dictionnaire comme suit:

Un tableau associatif, où des clés arbitraires sont mappées à des valeurs. Les clés peuvent être n'importe quel objet avec __hacher__() et __eq __ () méthodes. (La source)

Il y a quelques points à garder à l'esprit:

  1. Les dictionnaires associent les clés aux valeurs et les stockent dans un tableau ou une collection.
  2. Les clés doivent être de type hashable, ce qui signifie qu’elles doivent avoir une valeur de hachage qui ne change jamais pendant la durée de vie de la clé.

Les dictionnaires sont fréquemment utilisés pour résoudre toutes sortes de problèmes de programmation. Ils constituent donc un élément fondamental de votre boîte à outils en tant que développeur Python.

contrairement à des séquences, qui sont des itérables qui supportent l’accès aux éléments à l’aide d’indices entiers, les dictionnaires sont indexés par des clés.

Les clés dans un dictionnaire ressemblent beaucoup à un ensemble, qui est une collection d’objets déchirables et uniques. Comme les objets doivent pouvoir être hachés, les objets mutables ne peuvent pas être utilisés comme clés de dictionnaire.

D'un autre côté, les valeurs peuvent être de n'importe quel type Python, qu'elles soient ou non lavables. Il n'y a littéralement aucune restriction pour les valeurs.

Dans Python 3.6 et les versions ultérieures, les clés et les valeurs d'un dictionnaire sont itérées dans le même ordre dans lequel elles ont été créées. Toutefois, ce comportement peut varier d’une version à l’autre de Python et dépend de l’historique des insertions et des suppressions dans le dictionnaire.

Dans Python 2.7, les dictionnaires sont des structures non ordonnées. L'ordre des items des dictionnaires est brouillé. Cela signifie que l'ordre des éléments est déterministe et reproductible. Voyons un exemple:

>>>

>>> # Python 2.7
>>> un_dict = 'Couleur': 'bleu', 'fruit': 'Pomme', 'animal de compagnie': 'chien'
>>> un_dict
'couleur': 'bleu', 'animal': 'chien', 'fruit': 'pomme'
>>> un_dict
'couleur': 'bleu', 'animal': 'chien', 'fruit': 'pomme'

Si vous quittez l'interprète et ouvrez une nouvelle session interactive plus tard, vous obtiendrez le même ordre d'éléments:

>>>

>>> # Python 2.7. Nouvelle session interactive
>>> un_dict = 'Couleur': 'bleu', 'fruit': 'Pomme', 'animal de compagnie': 'chien'
>>> un_dict
'couleur': 'bleu', 'animal': 'chien', 'fruit': 'pomme'
>>> un_dict
'couleur': 'bleu', 'animal': 'chien', 'fruit': 'pomme'

Un examen plus approfondi de ces deux sorties montre que l’ordre obtenu est exactement le même dans les deux cas. C’est pourquoi vous pouvez dire que l’ordre est déterministe.

Dans Python 3.5, les dictionnaires ne sont toujours pas ordonnés, mais cette fois, randomisé structures de données. Cela signifie que chaque fois que vous ré-exécuterez le dictionnaire, vous obtiendrez un ordre d’articles différent. Nous allons jeter un coup d'oeil:

>>>

>>> # Python 3.5
>>> un_dict = 'Couleur': 'bleu', 'fruit': 'Pomme', 'animal de compagnie': 'chien'
>>> un_dict
'couleur': 'bleu', 'animal': 'chien', 'fruit': 'pomme'
>>> un_dict
'couleur': 'bleu', 'animal': 'chien', 'fruit': 'pomme'

Si vous entrez dans une nouvelle session interactive, vous obtiendrez ce qui suit:

>>>

>>> # Python 3.5. Nouvelle session interactive
>>> un_dict = 'Couleur': 'bleu', 'fruit': 'Pomme', 'animal de compagnie': 'chien'
>>> un_dict
'fruit': 'pomme', 'animal': 'chien', 'couleur': 'bleu'
>>> un_dict
'fruit': 'pomme', 'animal': 'chien', 'couleur': 'bleu'

Cette fois, vous pouvez voir que l'ordre des éléments est différent dans les deux sorties. C’est pourquoi vous pouvez dire qu’il s’agit de structures de données randomisées.

En Python 3.6 et au-delà, les dictionnaires sont commandé les structures de données, ce qui signifie qu'elles conservent leurs éléments dans le même ordre dans lequel ils ont été introduits, comme vous pouvez le voir ici:

>>>

>>> # Python 3.6 et au-delà
>>> un_dict = 'Couleur': 'bleu', 'fruit': 'Pomme', 'animal de compagnie': 'chien'
>>> un_dict
'couleur': 'bleu', 'fruit': 'pomme', 'animal': 'chien'
>>> un_dict
'couleur': 'bleu', 'fruit': 'pomme', 'animal': 'chien'

C’est une fonctionnalité relativement nouvelle des dictionnaires Python, et elle est très utile. Toutefois, si vous écrivez du code censé être exécuté dans différentes versions de Python, vous ne devez pas vous fier à cette fonctionnalité, car elle peut générer des comportements erronés.

Une autre caractéristique importante des dictionnaires est qu'ils sont des structures de données modifiables, ce qui signifie que vous pouvez ajouter, supprimer et mettre à jour leurs éléments. Cela vaut la peine de noter que cela signifie également qu'ils ne peuvent pas être utilisés comme clés pour d'autres dictionnaires, car ils ne sont pas des objets pouvant être hachés.

Comment parcourir un dictionnaire en Python: notions de base

Les dictionnaires constituent une structure de données utile et largement utilisée en Python. En tant que codeur Python, vous vous retrouverez souvent dans des situations où vous devrez parcourir un dictionnaire en Python, tout en effectuant des actions sur ses paires clé-valeur.

Lorsqu’il s’agit d’itérer à travers un dictionnaire en Python, le langage vous fournit de très bons outils que nous allons couvrir dans cet article.

Itérer directement à travers les touches

Les dictionnaires Python sont des objets de mappage. Cela signifie qu'ils héritent de certains méthodes spéciales, que Python utilise en interne pour effectuer certaines opérations. Ces méthodes sont nommées selon la convention de dénomination qui consiste à ajouter un double soulignement au début et à la fin du nom de la méthode.

Pour visualiser les méthodes et les attributs de tout objet Python, vous pouvez utiliser dir (), qui est une fonction intégrée qui remplit cet objectif. Si tu cours dir () avec un dictionnaire vide comme argument, vous pourrez voir toutes les méthodes et tous les attributs que les dictionnaires implémentent:

>>>

>>> dir()
['__class__', '__contains__', '__delattr__', ... , '__iter__', ...]

Si vous regardez de plus près la sortie précédente, vous verrez '__iter__'. Il s'agit d'une méthode appelée lorsqu'un itérateur est requis pour un conteneur. Elle doit renvoyer un nouvel objet itérateur capable de parcourir tous les objets du conteneur.

Pour les mappages (comme les dictionnaires), .__ iter __ () devrait parcourir les clés. Cela signifie que si vous mettez un dictionnaire directement dans un pour boucle, Python appellera automatiquement .__ iter __ () sur ce dictionnaire, et vous obtiendrez un itérateur sur ses clés:

>>>

>>> un_dict = 'Couleur': 'bleu', 'fruit': 'Pomme', 'animal de compagnie': 'chien'
>>> pour clé dans un_dict:
...     impression(clé)
...
Couleur
fruit
animal de compagnie

Python est assez intelligent pour savoir que un_dict est un dictionnaire et qu'il met en œuvre .__ iter __ (). Dans cet exemple, Python a appelé .__ iter __ () automatiquement, ce qui vous a permis de parcourir les clés de un_dict.

C'est le moyen le plus simple de parcourir un dictionnaire en Python. Il suffit de le mettre directement dans un pour boucle, et vous avez terminé!

Si vous utilisez cette approche avec une petite astuce, vous pouvez alors traiter les clés et les valeurs de n'importe quel dictionnaire. L'astuce consiste à utiliser l'opérateur d'indexation [] avec le dictionnaire et ses clés pour accéder aux valeurs:

>>>

>>> pour clé dans un_dict:
...     impression(clé, '->', un_dict[[[[clé])
...
couleur -> bleu
fruit -> pomme
animal de compagnie -> chien

Le code précédent vous permettait d’avoir accès aux clés (clé) et les valeurs (un_dict[key]) de un_dict en même temps. De cette façon, vous pouvez effectuer n'importe quelle opération à la fois avec les clés et les valeurs.

Itérant à travers .articles()

Lorsque vous utilisez des dictionnaires, il est probable que vous souhaiterez utiliser à la fois les clés et les valeurs. L’un des moyens les plus utiles de parcourir un dictionnaire en Python consiste à utiliser .articles(), qui est une méthode qui renvoie une nouvelle vue des éléments du dictionnaire:

>>>

>>> un_dict = 'Couleur': 'bleu', 'fruit': 'Pomme', 'animal de compagnie': 'chien'
>>> d_items = un_dict.articles()
>>> d_items  # Ici d_items est une vue des items
dict_items ([('color', 'blue'), ('fruit', 'apple'), ('pet', 'dog')])

Vues de dictionnaire comme d_items fournir une vue dynamique sur les entrées du dictionnaire, ce qui signifie que lorsque le dictionnaire est modifié, les vues reflètent ces modifications.

Les vues peuvent être itérées pour générer leurs données respectives. Vous pouvez ainsi parcourir un dictionnaire en Python en utilisant l'objet view renvoyé par .articles():

>>>

>>> pour article dans un_dict.articles():
...     impression(article)
...
('Couleur bleue')
('fruit', 'pomme')
('chien de compagnie')

L'objet de vue renvoyé par .articles() renvoie les paires clé-valeur une à la fois et vous permet de parcourir un dictionnaire en Python, mais de manière à ce que vous puissiez accéder simultanément aux clés et aux valeurs.

Si vous examinez de plus près les éléments individuels générés par .articles(), vous remarquerez qu’ils sont vraiment tuple objets. Nous allons jeter un coup d'oeil:

>>>

>>> pour article dans un_dict.articles():
...     impression(article)
...     impression(type(article))
...
('Couleur bleue')

('fruit', 'pomme')

('chien de compagnie')

Une fois que vous savez cela, vous pouvez utiliser tuple décompactez pour parcourir les clés et les valeurs du dictionnaire avec lequel vous travaillez. Pour ce faire, il vous suffit de décompresser les éléments de chaque élément en deux variables différentes représentant la clé et la valeur:

>>>

>>> pour clé, valeur dans un_dict.articles():
...     impression(clé, '->', valeur)
...
couleur -> bleu
fruit -> pomme
animal de compagnie -> chien

Ici, les variables clé et valeur dans l'en-tête de votre pour boucle faire le déballage. Chaque fois que la boucle s'exécute, clé va stocker la clé, et valeur stockera la valeur de l'article qui a été traité. De cette manière, vous aurez plus de contrôle sur les éléments du dictionnaire et pourrez traiter les clés et les valeurs séparément et de manière plus lisible et en Pythonic.

Itérant à travers .clés()

Si vous avez juste besoin de travailler avec les clés d’un dictionnaire, vous pouvez utiliser .clés(), qui est une méthode qui renvoie un nouvel objet de vue contenant les clés du dictionnaire:

>>>

>>> un_dict = 'Couleur': 'bleu', 'fruit': 'Pomme', 'animal de compagnie': 'chien'
>>> clés = un_dict.clés()
>>> clés
dict_keys (['color', 'fruit', 'pet'])

L'objet retourné par .clés() ici fourni une vue dynamique sur les clés de un_dict. Cette vue peut être utilisée pour parcourir les clés de un_dict.

Pour parcourir un dictionnaire en Python en utilisant .clés(), il vous suffit d'appeler .clés() dans l'en-tête d'un pour boucle:

>>>

>>> pour clé dans un_dict.clés():
...     impression(clé)
...
Couleur
fruit
animal de compagnie

Quand vous appelez .clés() sur un_dict, vous obtenez une vue des clés. Python sait que les objets de vue sont des objets itérables. Il commence donc à mettre en boucle et vous pouvez traiter les clés de un_dict.

D'autre part, en utilisant le même truc que vous avez vu auparavant (opérateur d'indexation []), vous pouvez accéder aux valeurs du dictionnaire:

>>>

>>> pour clé dans un_dict.clés():
...     impression(clé, '->', un_dict[[[[clé])
...
couleur -> bleu
fruit -> pomme
animal de compagnie -> chien

De cette façon, vous avez accès aux clés (clé) et des valeurs (un_dict[key]) de un_dict en même temps, et vous pourrez effectuer n'importe quelle action sur eux.

Itérant à travers .valeurs()

Il est également courant d’utiliser uniquement les valeurs pour effectuer une itération dans un dictionnaire en Python. Une façon de le faire est d'utiliser .valeurs(), qui retourne une vue avec les valeurs du dictionnaire:

>>>

>>> un_dict = 'Couleur': 'bleu', 'fruit': 'Pomme', 'animal de compagnie': 'chien'
>>> valeurs = un_dict.valeurs()
>>> valeurs
dict_values ​​(['blue', 'apple', 'dog'])

Dans le code précédent, valeurs contient une référence à un objet de vue contenant les valeurs de un_dict.

Comme tout objet de vue, l’objet retourné par .valeurs() peut également être itéré sur. Dans ce cas, .valeurs() donne les valeurs de un_dict:

>>>

>>> pour valeur dans un_dict.valeurs():
...     impression(valeur)
...
bleu
Pomme
chien

En utilisant .valeurs(), vous aurez accès uniquement aux valeurs de un_dict, sans traiter avec les clés.

Il convient de noter qu’ils soutiennent également les tests d’effectif (dans), qui est une caractéristique importante si vous essayez de savoir si un élément spécifique est dans un dictionnaire ou non:

>>>

>>> un_dict = 'Couleur': 'bleu', 'fruit': 'Pomme', 'animal de compagnie': 'chien'
>>> 'animal de compagnie' dans un_dict.clés()
Vrai
>>> 'Pomme' dans un_dict.valeurs()
Vrai
>>> 'oignon' dans un_dict.valeurs()
Faux

Le test d'adhésion à l'aide de dans résultats Vrai si la clé (ou la valeur ou l'élément) est présent dans le dictionnaire que vous testez et renvoie Faux autrement. Le test d'appartenance vous permet de ne pas parcourir un dictionnaire en Python si vous voulez simplement savoir si une clé (ou une valeur ou un élément) est présent dans un dictionnaire ou non.

Modification des valeurs et des clés

Il peut être assez courant de devoir modifier les valeurs et les clés lorsque vous effectuez une itération dans un dictionnaire en Python. Vous devez tenir compte de certains points pour accomplir cette tâche.

Les valeurs, par exemple, peuvent être modifiées à tout moment, mais vous devrez utiliser le dictionnaire d'origine et la clé qui mappe la valeur que vous souhaitez modifier:

>>>

>>> des prix = 'Pomme': 0,40, 'Orange': 0,35, 'banane': 0,25
>>> pour k, v dans des prix.articles():
...     des prix[[[[k] = rond(v * 0,9, 2)  # Appliquer un rabais de 10%
...
>>> des prix
'pomme': 0,36, 'orange': 0,32, 'banane': 0,23

Dans l'exemple de code précédent, pour modifier les valeurs de des prix et appliquer un rabais de 10%, vous avez utilisé l'expression des prix[k] = rond (v * 0,9, 2).

Alors, pourquoi devez-vous utiliser le dictionnaire original si vous avez accès à sa clé (k) et ses valeurs (v)? Devez-vous pouvoir les modifier directement?

Le vrai problème est que k et v les modifications ne sont pas reflétées dans le dictionnaire d'origine. C’est-à-dire que si vous en modifiez un (k ou v) directement dans la boucle, alors ce qui se passe réellement, c’est que vous perdrez la référence au composant de dictionnaire pertinent sans rien changer au dictionnaire.

D'autre part, les clés peuvent être ajoutées ou supprimées d'un dictionnaire en convertissant la vue renvoyée par .clés() dans une liste objet:

>>>

>>> des prix = 'Pomme': 0,40, 'Orange': 0,35, 'banane': 0,25
>>> pour clé dans liste(des prix.clés()):  # Utiliser une liste au lieu d'une vue
...     si clé == 'Orange':
...         del des prix[[[[clé]  # Supprimer une clé des prix
...
>>> des prix
'pomme': 0,4, 'banane': 0,25

Cette approche peut avoir des conséquences sur les performances, principalement liées à la consommation de mémoire. Par exemple, au lieu d’un objet de vue générant des éléments à la demande, vous aurez un tout nouveau liste dans la mémoire de votre système. Toutefois, cela peut constituer un moyen sûr de modifier les clés lorsque vous parcourez un dictionnaire en Python.

Enfin, si vous essayez de supprimer une clé de des prix en utilisant .clés() directement, alors Python lèvera un Erreur d'exécution vous indiquant que la taille du dictionnaire a changé pendant l'itération:

>>>

>>> # Python 3. dict.keys () renvoie un objet de vue, pas une liste
>>> des prix = 'Pomme': 0,40, 'Orange': 0,35, 'banane': 0,25
>>> pour clé dans des prix.clés():
...     si clé == 'Orange':
...         del des prix[[[[clé]
...
Traceback (dernier appel le plus récent):
  Fichier "", ligne 1, dans 
    pour clé dans des prix.clés():
Erreur d'exécution: dictionnaire a changé de taille pendant l'itération

Ceci est dû au fait .clés() renvoie un objet en mode dictionnaire, qui fournit les clés à la demande une par une, et si vous supprimez un élément (del prix[key]), alors Python lève un Erreur d'exécution, car vous avez modifié le dictionnaire lors de son itération.

Exemples concrets

Jusqu’à présent, vous avez vu les méthodes les plus élémentaires d’itération dans un dictionnaire en Python. Il est maintenant temps de voir comment vous pouvez effectuer certaines actions avec les éléments d’un dictionnaire pendant l’itération. Voyons quelques exemples concrets.

Transformer les clés en valeurs et vice-versa

Supposons que vous ayez un dictionnaire et que, pour une raison quelconque, vous deviez transformer les clés en valeurs et inversement. Dans cette situation, vous pouvez utiliser un pour boucle pour parcourir le dictionnaire et construire le nouveau dictionnaire en utilisant les clés comme valeurs et inversement:

>>>

>>> un_dict = 'un': 1, 'deux': 2, 'te': 3, 'quatre': 4
>>> new_dict = 
>>> pour clé, valeur dans un_dict.articles():
...     new_dict[[[[valeur] = clé
...
>>> new_dict
1: 'un', 2: 'deux', 3: 'toi', 4: 'quatre'

L'expression new_dict[value] = clé a fait tout le travail pour vous en transformant les clés en valeurs et en les utilisant comme clés. Pour que ce code fonctionne, les données stockées dans les valeurs d'origine doivent être d'un type de données hashable.

Filtrage des articles

Parfois, vous aurez un dictionnaire et voudrez en créer un nouveau pour ne stocker que les données répondant à une condition donnée. Vous pouvez le faire avec un si déclaration à l'intérieur d'un pour boucle comme suit:

>>>

>>> un_dict = 'un': 1, 'deux': 2, 'te': 3, 'quatre': 4
>>> new_dict =   # Créer un nouveau dictionnaire vide
>>> pour clé, valeur dans un_dict.articles():
...     # Si la valeur satisfait à la condition, stockez-la dans new_dict
...     si valeur <= 2:
...         new_dict[[[[clé] = valeur
...
>>> new_dict
'un': 1, 'deux': 2

Dans cet exemple, vous avez filtré les éléments dont la valeur est supérieure à 2. À présent new_dict contient uniquement les éléments qui remplissent la condition valeur <= 2. C'est une solution possible pour ce genre de problème. Plus tard, vous verrez un moyen plus lisible et Pythonic d’obtenir le même résultat.

Faire des calculs

Il est également courant de devoir effectuer certains calculs pendant que vous parcourez un dictionnaire en Python. Supposons que vous ayez stocké les données relatives aux ventes de votre entreprise dans un dictionnaire et que vous souhaitiez maintenant connaître le revenu total de l’année.

Pour résoudre ce problème, vous pouvez définir une variable avec une valeur initiale de zéro. Ensuite, vous pouvez accumuler chaque valeur de votre dictionnaire dans cette variable:

>>>

>>> les revenus = 'Pomme': 5600.00, 'Orange': 3500,00, 'banane': 5000.00
>>> revenu total = 0.00
>>> pour valeur dans les revenus.valeurs():
...     revenu total + = valeur  # Accumule les valeurs dans total_income
...
>>> revenu total
14100.0

Ici, vous avez parcouru les revenus et séquentiellement accumulé ses valeurs dans revenu total comme tu voulais faire. L'expression total_income + = valeur fait la magie, et à la fin de la boucle, vous obtiendrez le revenu total de l’année. Notez que total_income + = valeur est équivalent à total_income = total_income + valeur.

Utiliser des compréhensions

UNE compréhension du dictionnaire est un moyen compact de traiter tout ou partie des éléments d'une collection et de renvoyer un dictionnaire en tant que résultat. Contrairement aux listes de compréhension, ils ont besoin de deux expressions séparées par deux points, suivies de pour et si (facultatif) clauses. Lorsqu'une compréhension de dictionnaire est exécutée, les paires clé-valeur résultantes sont insérées dans un nouveau dictionnaire dans le même ordre dans lequel elles ont été produites.

Supposons, par exemple, que vous ayez deux listes de données et que vous deviez créer un nouveau dictionnaire à partir de celles-ci. Dans ce cas, vous pouvez utiliser le logiciel Python. zip (* iterables) faire une boucle sur les éléments des deux listes par paires:

>>>

>>> objets = [[[['bleu', 'Pomme', 'chien']
>>> catégories = [[[['Couleur', 'fruit', 'animal de compagnie']
>>> un_dict = clé: valeur pour clé, valeur dans Zip *: français(catégories, objets)
>>> un_dict
'couleur': 'bleu', 'fruit': 'pomme', 'animal': 'chien'

Ici, Zip *: français() reçoit deux itérables (catégories et objets) comme arguments et crée un itérateur qui agrège les éléments de chaque itérable. le tuple objets générés par Zip *: français() sont ensuite déballés dans clé et valeur, qui sont finalement utilisés pour créer le nouveau dictionnaire.

La compréhension du dictionnaire ouvre un large éventail de nouvelles possibilités et vous fournit un excellent outil pour parcourir un dictionnaire en Python.

Transformer les clés en valeurs et vice-versa: revisité

Si vous prenez un autre regard sur le problème de la transformation des clés en valeurs et vice-versa, vous verrez que vous pourriez écrire une solution plus pythonique et plus efficace en utilisant un dictionnaire comprenant:

>>>

>>> un_dict = 'un': 1, 'deux': 2, 'te': 3, 'quatre': 4
>>> new_dict = valeur: clé pour clé, valeur dans un_dict.articles()
>>> new_dict
1: 'un', 2: 'deux', 3: 'toi', 4: 'quatre'

Avec cette compréhension du dictionnaire, vous avez créé un dictionnaire totalement nouveau dans lequel les clés ont pris la place des valeurs et inversement. Cette nouvelle approche vous a permis d'écrire du code plus lisible, succinct, efficace et Pythonic.

La condition pour que ce code fonctionne est la même que celle que vous avez vue auparavant: les valeurs doivent être des objets hashable. Sinon, vous ne pourrez pas les utiliser comme clés pour un_dict.

Filtrage des éléments: revisité

Pour filtrer les éléments d'un dictionnaire avec une compréhension, il vous suffit d'ajouter un si clause qui définit la condition que vous souhaitez remplir. Dans l'exemple précédent où vous avez filtré un dictionnaire, cette condition était si v <= 2. Avec ça si clause ajoutée à la fin de la compréhension du dictionnaire, vous allez filtrer les éléments dont les valeurs sont supérieures à 2. Nous allons jeter un coup d'oeil:

>>>

>>> un_dict = 'un': 1, 'deux': 2, 'te': 3, 'quatre': 4
>>> new_dict = k: v pour k, v dans un_dict.articles() si v <= 2
>>> new_dict
'un': 1, 'deux': 2

À présent new_dict contient uniquement les éléments qui répondent à votre condition. Par rapport aux solutions précédentes, celle-ci est plus efficace et pythonique.

Faire des calculs: revisité

Vous souvenez-vous de l'exemple avec les ventes de l'entreprise? Si vous utilisez une liste de compréhension pour parcourir les valeurs du dictionnaire, vous obtiendrez un code plus compact, rapide et Pythonic:

>>>

>>> les revenus = 'Pomme': 5600.00, 'Orange': 3500,00, 'banane': 5000.00
>>> revenu total = somme([[[[valeur pour valeur dans les revenus.valeurs()])
>>> revenu total
14100.0

La compréhension de la liste a créé un liste objet contenant les valeurs de les revenus, puis vous les avez tous résumés en utilisant somme() et stocké le résultat dans revenu total.

Si vous travaillez avec un dictionnaire très volumineux et que l'utilisation de la mémoire est un problème pour vous, vous pouvez utiliser une expression génératrice au lieu d'une compréhension de liste. UNE expression du générateur est une expression qui renvoie un itérateur. Cela ressemble à une compréhension de liste, mais au lieu de crochets, vous devez utiliser des parenthèses pour le définir:

>>>

>>> revenu total = somme(valeur pour valeur dans les revenus.valeurs())
>>> revenu total
14100.0

Si vous modifiez les crochets pour une paire de parenthèses (les parenthèses de somme() ici), vous allez transformer la compréhension de la liste en une expression génératrice et votre code sera efficace en mémoire, car les expressions génératrices génèrent des éléments à la demande. Au lieu de créer et de stocker toute la liste en mémoire, il vous suffira de stocker un élément à la fois.

Enfin, il existe un moyen plus simple de résoudre ce problème en utilisant simplement revenus.valeurs () directement comme un argument à somme():

>>>

>>> revenu total = somme(les revenus.valeurs())
>>> revenu total
14100.0

somme() reçoit un argument itérable et renvoie la somme totale de ses éléments. Ici, revenus.valeurs () joue le rôle de l'itérable passé à somme(). Le résultat est le revenu total que vous recherchiez.

Supprimer des éléments spécifiques

Supposons maintenant que vous avez un dictionnaire et que vous devez en créer un avec les clés sélectionnées supprimées. Rappelez-vous comment les objets de vue clé sont comme des ensembles? Ces similitudes ne se limitent pas à des collections d’objets uniques et déchirables. Les objets de vue clé prennent également en charge ensemble opérations. Voyons comment en tirer parti pour supprimer des éléments spécifiques d’un dictionnaire:

>>>

>>> les revenus = 'Pomme': 5600.00, 'Orange': 3500,00, 'banane': 5000.00
>>> non_citric = k: les revenus[[[[k] pour k dans les revenus.clés() - 'Orange'
>>> non_citric
'apple': 5600.0, 'banane': 5000.0

Ce code fonctionne car les objets de vue clé prennent en charge ensemble des opérations telles que des unions, des intersections et des différences. Quand tu as écrit incomes.keys () - 'orange' dans la compréhension du dictionnaire, vous faisiez vraiment une ensemble opération de différence. Si vous avez besoin d'effectuer ensemble opérations avec les clés d’un dictionnaire, vous pouvez simplement utiliser l’objet key-view directement sans le convertir au préalable en un ensemble. Il s'agit d'une fonctionnalité peu connue des objets de vue clé qui peut être utile dans certaines situations.

Tri d'un dictionnaire

Il est souvent nécessaire de trier les éléments d’une collection. Depuis Python 3.6, les dictionnaires sont des structures de données ordonnées. Ainsi, si vous utilisez Python 3.6 (et au-delà), vous pourrez trier les éléments de n’importe quel dictionnaire en utilisant triés () et avec l'aide d'un dictionnaire compréhension:

>>>

>>> # Python 3.6 et au-delà
>>> les revenus = 'Pomme': 5600.00, 'Orange': 3500,00, 'banane': 5000.00
>>> trié = k: les revenus[[[[k] pour k dans triés(les revenus)
>>> trié
'apple': 5600.0, 'banane': 5000.0, 'orange': 3500.0

Ce code vous permet de créer un nouveau dictionnaire avec ses clés dans un ordre trié. C'est possible parce que triés (revenus) renvoie une liste de clés triées que vous pouvez utiliser pour générer le nouveau dictionnaire sort_dict.

Itération par ordre de tri

Parfois, vous devrez peut-être parcourir un dictionnaire en Python mais vouloir le faire dans un ordre trié. Ceci peut être réalisé en utilisant triés (). Quand vous appelez trié (itérable), vous obtenez un liste avec les éléments de itérable dans l'ordre trié.

Voyons comment vous pouvez utiliser triés () parcourir un dictionnaire en Python lorsque vous devez le faire dans un ordre trié.

Trié par clés

Si vous devez parcourir un dictionnaire en Python et que vous voulez le trier par clés, vous pouvez utiliser votre dictionnaire comme argument pour: triés (). Cela retournera un liste contenant les clés dans un ordre trié, et vous pourrez les parcourir:

>>>

>>> les revenus = 'Pomme': 5600.00, 'Orange': 3500,00, 'banane': 5000.00
>>> pour clé dans triés(les revenus):
...     impression(clé, '->', les revenus[[[[clé])
...
pomme -> 5600.0
banane -> 5000.0
orange -> 3500.0

Dans cet exemple, vous avez trié le dictionnaire (par ordre alphabétique) à l'aide de touches à l'aide de triés (revenus) dans l'en-tête du pour boucle. Notez que vous pouvez également utiliser triés (revenus.des clés ()) pour obtenir le même résultat. Dans les deux cas, vous obtiendrez un liste contenant les clés de votre dictionnaire dans un ordre trié.

Trié par valeurs

Vous pouvez également avoir besoin de parcourir un dictionnaire en Python avec ses éléments triés par valeur. Vous pouvez utiliser triés () aussi, mais avec un deuxième argument appelé clé.

le clé mot-clé argument spécifie une fonction d'un argument utilisée pour extraire une clé de comparaison de chaque élément traité.

Pour trier les éléments d’un dictionnaire par valeurs, vous pouvez écrire une fonction qui renvoie la valeur de chaque élément et utiliser cette fonction comme clé argument à triés ():

>>>

>>> les revenus = 'Pomme': 5600.00, 'Orange': 3500,00, 'banane': 5000.00
>>> def by_value(article):
...     revenir article[[[[1]
...
>>> pour k, v dans triés(les revenus.articles(), clé=by_value):
...     impression(k, '->', v)
...
('orange', '->', 3500.0)
('banane', '->', 5000.0)
('apple', '->', 5600.0)

Dans cet exemple, vous avez défini by_value () et utilisé pour trier les articles de les revenus par valeur. Ensuite, vous avez parcouru le dictionnaire par ordre trié en utilisant triés (). La fonction clé (by_value ()) raconte triés () Trier incomes.items () par le deuxième élément de chaque élément, c’est-à-dire par la valeur (article[1]).

Vous pouvez également simplement vouloir parcourir les valeurs d'un dictionnaire dans un ordre trié, sans vous soucier des clés. Dans ce cas, vous pouvez utiliser .valeurs() comme suit:

>>>

>>> pour valeur dans triés(les revenus.valeurs()):
...     impression(valeur)
...
3500.0
5000.0
5600.0

triés (revenus.valeurs ()) a renvoyé les valeurs du dictionnaire dans un ordre trié comme vous le souhaitez. Les clés ne seront pas accessibles si vous utilisez revenus.valeurs (), mais parfois vous n’avez pas vraiment besoin des clés, mais seulement des valeurs. C’est un moyen rapide d’y accéder.

Renversé

Si vous avez besoin de trier vos dictionnaires dans l’ordre inverse, vous pouvez ajouter reverse = True comme argument pour triés (). L'argument du mot clé sens inverse devrait prendre une valeur booléenne. S'il est réglé sur Vrai, les éléments sont ensuite triés dans l’ordre inverse:

>>>

>>> les revenus = 'Pomme': 5600.00, 'Orange': 3500,00, 'banane': 5000.00
>>> pour clé dans triés(les revenus, sens inverse=Vrai):
...     impression(clé, '->', les revenus[[[[clé])
...
orange -> 3500.0
banane -> 5000.0
pomme -> 5600.0

Ici, vous avez itéré sur les clés de les revenus dans l'ordre inverse en utilisant triés (revenus, inverse = vrai) dans l'en-tête du pour boucle.

Enfin, il est important de noter que triés () ne modifie pas vraiment l'ordre du dictionnaire sous-jacent. Qu'est-ce qui se passe vraiment c'est que triés () crée une liste indépendante avec son élément dans l'ordre de tri, donc les revenus reste le même:

>>>

>>> les revenus
'apple': 5600.0, 'orange': 3500.0, 'banane': 5000.0

Ce code vous montre que les revenus n'a pas changé. triés () n'a pas modifié les revenus. Il vient de créer une nouvelle liste triée à partir des clés de les revenus.

Itération destructive avec .popitem()

Parfois, vous devez parcourir un dictionnaire en Python et supprimer ses éléments de manière séquentielle. Pour accomplir cette tâche, vous pouvez utiliser .popitem (), qui supprimera et renverra une paire clé-valeur arbitraire d'un dictionnaire. D'autre part, lorsque vous appelez .popitem () sur un dictionnaire vide, il soulève une KeyError.

Si vous avez vraiment besoin de parcourir de manière destructive un dictionnaire en Python, alors .popitem () peut être utile. Voici un exemple:

    1 # Fichier: dict_popitem.py
    2 
    3 un_dict = 'Couleur': 'bleu', 'fruit': 'Pomme', 'animal de compagnie': 'chien'
    4 
    5 tandis que Vrai:
    6     essayer:
    7         impression(F'Longueur du dictionnaire: len (a_dict)')
    8         article = un_dict.popitem()
    9         # Faites quelque chose avec l'article ici ...
dix         impression(F'article    enlevé ')
11     sauf KeyError:
12         impression("Le dictionnaire n'a pas d'article maintenant ...")
13         Pause

Ici, vous avez utilisé un tandis que boucle au lieu d'un pour boucle. La raison en est qu’il n’est jamais prudent de parcourir un dictionnaire en Python si vous prétendez le modifier de cette façon, c’est-à-dire si vous supprimez ou ajoutez des éléments à celui-ci.

À l'intérieur de tandis que boucle, vous avez défini un essayez ... sauf bloquer pour attraper le KeyError élevé par .popitems () quand un_dict tourne à vide. dans le essayez ... sauf bloquer, vous traitez le dictionnaire en supprimant un élément à chaque itération. La variable article conserve une référence aux éléments successifs et vous permet d'effectuer certaines actions avec eux.

Si vous exécutez ce script à partir de votre ligne de commande, vous obtiendrez les résultats suivants:

$ python3 dict_popitem.py
Longueur du dictionnaire: 3
('animal', 'chien') enlevé
Longueur du dictionnaire: 2
('fruit', 'pomme') enlevé
Longueur du dictionnaire: 1
('couleur', 'bleu') enlevé
Longueur du dictionnaire: 0
Le dictionnaire n'a pas d'article maintenant ...

Ici .popitem () séquentiellement retiré les éléments de un_dict. La boucle a éclaté quand le dictionnaire est devenu vide, et .popitem () soulevé un KeyError exception.

Utilisation de certaines fonctions intégrées de Python

Python fournit des fonctions intégrées qui pourraient être utiles lorsque vous travaillez avec des collections, telles que des dictionnaires. Ces fonctions sont une sorte d'outil d'itération qui vous fournit un autre moyen de parcourir le dictionnaire en Python. Voyons certains d’entre eux.

carte()

Python carte() est défini comme carte (fonction, iterable, ...) et retourne un itérateur qui s'applique une fonction à chaque article de itérable, donnant les résultats à la demande. Alors, carte() pourrait être considéré comme un outil d'itération que vous pouvez utiliser pour parcourir un dictionnaire en Python.

Supposons que vous disposiez d'un dictionnaire contenant les prix d'un groupe de produits et que vous deviez leur appliquer un rabais. Dans ce cas, vous pouvez définir une fonction qui gère la remise et l’utilise ensuite comme premier argument de carte(). Le deuxième argument peut être prix.items ():

>>>

>>> des prix = 'Pomme': 0,40, 'Orange': 0,35, 'banane': 0,25
>>> def remise(prix actuel):
...     revenir (prix actuel[[[[0], rond(prix actuel[[[[1] * 0.95, 2))
...
>>> new_prices = dict(carte(remise, des prix.articles()))
>>> new_prices
'pomme': 0,38, 'orange': 0,33, 'banane': 0,24

Ici, carte() itéré à travers les éléments du dictionnaire (prix.items ()) d'appliquer une réduction de 5% sur chaque fruit en utilisant remise(). Dans ce cas, vous devez utiliser dict () générer le new_prices dictionnaire de l'itérateur retourné par carte().

Notez que remise() renvoie un tuple de la forme (valeur clé), où prix actuel[0] représente la clé et round (current_price[1] * 0.95, 2) représente la nouvelle valeur.

filtre()

filtre() est une autre fonction intégrée que vous pouvez utiliser pour parcourir un dictionnaire en Python et filtrer certains de ses éléments. Cette fonction est définie comme filtre (fonction, iterable) et retourne un itérateur de ces éléments de itérable Pour qui une fonction résultats Vrai.

Supposons que vous souhaitiez connaître les produits dont le prix est inférieur à 0,40. Vous devez définir une fonction pour déterminer si le prix remplit cette condition et le transmettre comme premier argument à filtre(). Le deuxième argument peut être price.keys ():

>>>

>>> des prix = 'Pomme': 0,40, 'Orange': 0,35, 'banane': 0,25
>>> def has_low_price(prix):
...     revenir des prix[[[[prix] < 0.4
...
>>> bas prix = liste(filtre(has_low_price, des prix.clés()))
>>> bas prix
['orange', 'banana']

Ici, vous avez parcouru les touches de des prix avec filtre(). ensuite filtre() applique has_low_price () à chaque touche de des prix. Enfin, vous devez utiliser liste() pour générer la liste des produits à bas prix, car filtre() renvoie un itérateur, et vous avez vraiment besoin d'un liste objet.

En utilisant collections.ChainMap

collections est un module utile de la bibliothèque standard Python qui fournit des types de données de conteneur spécialisés. Un de ces types de données est ChainMap, qui est une classe de type dictionnaire permettant de créer une vue unique de plusieurs mappages (tels que les dictionnaires). Avec ChainMap, vous pouvez regrouper plusieurs dictionnaires pour créer une seule vue pouvant être mise à jour.

Maintenant, supposons que vous ayez deux dictionnaires (ou plus) et que vous deviez les parcourir ensemble. Pour ce faire, vous pouvez créer un ChainMap objet et initialisez-le avec vos dictionnaires:

>>>

>>> de collections importation ChainMap
>>> fruits_prices = 'Pomme': 0,40, 'Orange': 0,35
>>> prix_légumes = 'poivre': 0,20, 'oignon': 0,55
>>> chained_dict = ChainMap(fruits_prices, prix_légumes)
>>> chained_dict  # Un objet ChainMap
ChainMap ('apple': 0.4, 'orange': 0.35, 'poivre': 0.2, 'onion': 0.55)
>>> pour clé dans chained_dict:
...     impression(clé, '->', chained_dict[[[[clé])
...
poivre -> 0.2
orange -> 0,35
oignon -> 0.55
pomme -> 0.4

Après importation ChainMap de collections, vous devez créer un ChainMap objet avec les dictionnaires que vous souhaitez chaîner, puis vous pouvez parcourir librement l’objet résultant comme vous le feriez avec un dictionnaire classique.

ChainMap les objets implémentent aussi .clés(), valeurs(), et .articles() comme le fait un dictionnaire standard, vous pouvez donc utiliser ces méthodes pour parcourir l'objet semblable à un dictionnaire généré par ChainMap, just like you would do with a regular dictionary:

>>>

>>> pour clé, valeur dans chained_dict.articles():
...     impression(clé, '->', valeur)
...
apple -> 0.4
pepper -> 0.2
orange -> 0.35
onion -> 0.55

In this case, you’ve called .items() sur un ChainMap objet. le ChainMap object behaved as if it were a regular dictionary, and .items() returned a dictionary view object that can be iterated over as usual.

Python’s itertools is a module that provides some useful tools to perform iteration tasks. Let’s see how you can use some of them to iterate through a dictionary in Python.

Cyclic Iteration With cycle()

Suppose you want to iterate through a dictionary in Python, but you need to iterate through it repeatedly in a single loop. To get this task done, you can use itertools.cycle(iterable), which makes an iterator returning elements from itérable and saving a copy of each. Quand itérable is exhausted, cycle() returns elements from the saved copy. This is performed in cyclic fashion, so it’s up to you to stop the cycle.

In the following example, you’ll be iterating through the items of a dictionary three consecutive times:

>>>

>>> de itertools importation cycle
>>> des prix = 'apple': 0,40, 'orange': 0.35, 'banana': 0.25
>>> fois = 3  # Define how many times you need to iterate through prices
>>> total_items = fois * len(des prix)
>>> pour article dans cycle(des prix.articles()):
...     si ne pas total_items:
...         Pause
...     total_items -= 1
...     impression(article)
...
('apple', 0.4)
('orange', 0.35)
('banana', 0.25)
('apple', 0.4)
('orange', 0.35)
('banana', 0.25)
('apple', 0.4)
('orange', 0.35)
('banana', 0.25)

The preceding code allowed you to iterate through des prix a given number of times (3 in this case). This cycle could be as long as you need, but you are responsible for stopping it. le si condition breaks the cycle when total_items counts down to zero.

Chained Iteration With chain()

itertools also provides chain(*iterables), which gets some iterables as arguments and makes an iterator that yields elements from the first iterable until it’s exhausted, then iterates over the next iterable and so on, until all of them are exhausted.

This allows you to iterate through multiple dictionaries in a chain, like to what you did with collections.ChainMap:

>>>

>>> de itertools importation chaîne
>>> fruit_prices = 'apple': 0,40, 'orange': 0.35, 'banana': 0.25
>>> vegetable_prices = 'pepper': 0,20, 'onion': 0,55, 'tomato': 0.42
>>> pour article dans chaîne(fruit_prices.articles(), vegetable_prices.articles()):
...     impression(article)
...
('apple', 0.4)
('orange', 0.35)
('banana', 0.25)
('pepper', 0.2)
('onion', 0.55)
('tomato', 0.42)

In the above code, chain() returned an iterable that combined the items from fruit_prices et vegetable_prices.

It’s also possible to use .keys() ou .values(), depending on your needs, with the condition of being homogeneous: if you use .keys() for an argument to chain(), then you need to use .keys() for the rest of them.

Using the Dictionary Unpacking Operator (**)

Python 3.5 brings a new and interesting feature. PEP 448 – Additional Unpacking Generalizations can make your life easier when it comes to iterating through multiple dictionaries in Python. Let’s see how this works with a short example.

Suppose you have two (or more) dictionaries, and you need to iterate through them together, without using collections.ChainMap ou itertools.chain(), as you’ve seen in the previous sections. In this case, you can use the dictionary unpacking operator (**) to merge the two dictionaries into a new one and then iterate through it:

>>>

>>> fruit_prices = 'apple': 0,40, 'orange': 0.35
>>> vegetable_prices = 'pepper': 0,20, 'onion': 0,55
>>> # How to use the unpacking operator **
>>> **vegetable_prices, **fruit_prices
'pepper': 0.2, 'onion': 0.55, 'apple': 0.4, 'orange': 0.35
>>> # You can use this feature to iterate through multiple dictionaries
>>> pour k, v dans **vegetable_prices, **fruit_prices.articles():
...     impression(k, '->', v)
...
pepper -> 0.2
onion -> 0.55
apple -> 0.4
orange -> 0.35

The dictionary unpacking operator (**) is really an awesome feature in Python. It allows you to merge multiple dictionaries into a new one, as you did in the example with vegetable_prices et fruit_prices. Once you’ve merged the dictionaries with the unpacking operator, you can iterate through the new dictionary as usual.

It’s important to note that if the dictionaries you’re trying to merge have repeated or common keys, then the values of the right-most dictionary will prevail:

>>>

>>> vegetable_prices = 'pepper': 0,20, 'onion': 0,55
>>> fruit_prices = 'apple': 0,40, 'orange': 0.35, 'pepper': .25
>>> **vegetable_prices, **fruit_prices
'pepper': 0.25, 'onion': 0.55, 'apple': 0.4, 'orange': 0.35

le poivre key is present in both dictionaries. After you merge them, the fruit_prices la valeur pour poivre (0.25) prevailed, because fruit_prices is the right-most dictionary.

Conclusion

You now know the basics of how to iterate through a dictionary in Python, as well as some more advanced techniques and strategies!

You’ve learned:

  • What dictionaries are, as well as some of their main features and implementation details
  • What the basic ways to iterate through a dictionary in Python are
  • What kind of tasks you can accomplish by iterating through a dictionary in Python
  • How to use some more elaborated techniques and strategies to iterate through a dictionary in Python

You have the tools and knowledge you’ll need to get the most out of dictionaries in Python. This will help you be more efficient and effective in your use of dictionary iteration in the future.