filtrer les éléments dans un python dictionnaire dont les clés contiennent une chaîne de caractères

Je suis un codeur C le développement de quelque chose en python. Je sais comment effectuer les opérations suivantes en C (et donc en C-comme la logique appliquée en cas de python), mais je me demandais ce que le "Python" de faire il est.

J'ai un dictionnaire d, et j'aimerais le faire fonctionner sur un sous-ensemble des éléments, seulement ceux qui s key (string) comprend une sous-chaîne.

c'est à dire le C logique serait:

for key in d:
    if filter_string in key:
        # do something
    else
        # do nothing, continue

J'imagine la version de python serait quelque chose comme

filtered_dict = crazy_python_syntax(d, substring)
for key,value in filtered_dict.iteritems():
    # do something

J'ai trouvé beaucoup de posts ici sur le filtrage des dictionnaires, mais ne pouvait pas en trouver un qui impliquait exactement cela.

Mon dictionnaire n'est pas imbriqué et j'utilise python 2.7

InformationsquelleAutor memo | 2014-05-26

148

Un dict compréhension:
```
filtered_dict = {k:v for k,v in d.iteritems() if filter_string in k}
```
Un vous le voyez, il devrait être auto-explicatif, comme on le lit comme l'anglais assez bien.

Cette syntaxe nécessite Python 2.7 ou plus.

En Python 3, il y a seulement dict.les éléments(), pas iteritems() donc vous l'utiliser:
```
filtered_dict = {k:v for (k,v) in d.items() if filter_string in k}
```
- Pourquoi ne pas filtered_dict = {k:d[k] for k in d if filter_string in k}?
- Je vais suppose que que le mien est plus rapide, car il n'a pas incurrent la d[k] de recherche.
- Aussi, dit-il # do something dans les commentaires, mais nous déposer quelques touches ici.
- Nous n'avons iteritems en Python 3? Je ne le pense pas. Donc, ma version est compatible, non?
- En Python 3 de remplacer iteritems avec items, qui est le même que Python 2.7 est iteritems.
- grâce étonnante. une seule ligne de code. les noix.
InformationsquelleAutor Jonathon Reinhart
15

Aller pour ce que c'est plus lisible et facilement maintenable. Juste parce que vous pouvez l'écrire en une seule ligne ne signifie pas que vous devriez. Votre solution existante est proche de ce que je voudrais utiliser d'autres que je ne l'utilisateur iteritems pour ignorer la valeur de recherche, et je déteste imbriquée fi si je peux les éviter:
```
for key, val in d.iteritems():
    if filter_string not in key:
        continue
    # do something
```
Toutefois, si vous realllly voulez quelque chose pour vous permettre de parcourir une filtré dict puis je ne voudrais pas faire les deux étapes de la construction de l'filtré dict et puis en itérant à travers elle, mais au lieu d'utiliser un générateur, parce que ce qui est plus pythonic (et génial) qu'un générateur?

D'abord, nous créons notre générateur, et une bonne conception de la dicte que nous faisons, il est suffisamment abstrait pour être réutilisable:
```
# The implementation of my generator may look vaguely familiar, no?
def filter_dict(d, filter_string):
    for key, val in d.iteritems():
        if filter_string not in key:
            continue
        yield key, val
```
Et ensuite, nous pouvons utiliser le générateur pour résoudre votre problème, agréable et propre avec de simples, compréhensibles code:
```
for key, val in filter_dict(d, some_string):
    # do something
```
En bref: les générateurs sont génial.

InformationsquelleAutor Brendan F
8
```
input = {"A":"a", "B":"b", "C":"c"}
output = {k:v for (k,v) in input.items() if key_satifies_condition(k)}
```
- Ma méthode à l'aide de iteritems() va être plus efficace que items().
- Reinhart je ne savait pas à ce sujet. Merci.
- Sur Python 2.7 seulement. En Python 3, il est que items(), qui agit comme le Python 2.7 est iteritems.
- La question est explicitement pour python 2.7
InformationsquelleAutor jspurim
7

Jonathon vous a donné une approche à l'aide dict interprétations dans sa réponse. Ici, c'est une approche qui s'applique à votre faire quelque chose partie.

Si vous voulez faire quelque chose avec les valeurs du dictionnaire, vous n'avez pas besoin d'un dictionnaire de la compréhension à tous:

Je suis en utilisant iteritems() depuis que vous avez attaché votre question python 2.7
```
results = map(some_function, [(k,v) for k,v in a_dict.iteritems() if 'foo' in k])
```
Maintenant le résultat sera une liste avec some_function appliquée à chaque paire clé/valeur du dictionnaire, qui a foo dans sa clé.

Si vous voulez juste de traiter avec les valeurs et ignorer les touches, il suffit de changer la compréhension de liste:
```
results = map(some_function, [v for k,v in a_dict.iteritems() if 'foo' in k])
```
some_function peut être appelable, de sorte qu'un lambda fonctionnerait ainsi:
```
results = map(lambda x: x*2, [v for k,v in a_dict.iteritems() if 'foo' in k])
```
L'intérieur de la liste est en fait pas nécessaire, comme vous pouvez vous en passer un générateur d'expression à la carte ainsi:
```
>>> map(lambda a: a[0]*a[1], ((k,v) for k,v in {2:2, 3:2}.iteritems() if k == 2))
[4]
```
- intéressant. comment le une_fonction être défini? dans le premier cas (k,v), est-il juste prendre deux paramètres? première clé, puis de la valeur?
- Oui, juste un appelable. Donc map(lambda a: a[0]*a[1], ((k,v) for k,v in {2:2, 3:2}.iteritems() if k == 2)) - cela vous permettra de [4].
- C'est correct, mais plus pythonic que d'utiliser map est une compréhension de liste. [f(v) for k, v in d.iteritems() if substring in k] Je pense que c'est beaucoup plus lisible, et plus efficace.
- Il ne serait pas prendre deux paramètres, il faudrait un seul paramètre, avec deux éléments. Il y a aussi starmap qui va décompresser en deux arguments, cependant, c'est un paresseux itérateur (doit être réitéré avant qu'il s'exécute, c'est à dire results = list(starmap(...)) ou for result in starmap(...): ...).
InformationsquelleAutor Burhan Khalid
6

Vous pouvez utiliser le haut- fonction de filtre pour filtrer les dictionnaires, listes, etc. basés sur des conditions spécifiques.
```
filtered_dict = dict(filter(lambda item: filter_str in item[0], d.items()))
```
L'avantage est que vous pouvez l'utiliser pour différentes structures de données.
- Notez que items: devrait être item: dans le lambda définition.
- Merci @bkribbs pour souligner l'erreur. J'ai corrigé maintenant.
InformationsquelleAutor Pulkit

Vous devez vous connecter pour publier un commentaire.