Comment filtrer un dictionnaire conformément à l'arbitraire d'un état de fonctionner?

J'ai un dictionnaire de points, par exemple:

>>> points={'a':(3,4), 'b':(1,2), 'c':(5,5), 'd':(3,3)}

Je veux créer un nouveau dictionnaire avec tous les points dont la valeur x et y est plus petit que 5, c'est à dire des points 'a', 'b' et 'd'.

Selon la le livre, chaque dictionnaire a la items() fonction qui retourne une liste de (key, pair) tuple:

>>> points.items()
[('a', (3, 4)), ('c', (5, 5)), ('b', (1, 2)), ('d', (3, 3))]

J'ai donc écrit ceci:

>>> for item in [i for i in points.items() if i[1][0]<5 and i[1][1]<5]:
...     points_small[item[0]]=item[1]
...
>>> points_small
{'a': (3, 4), 'b': (1, 2), 'd': (3, 3)}

Est-il un moyen plus élégant? Je m'attendais à Python d'avoir quelques super-génial dictionary.filter(f) fonction...

stackoverflow.com/questions/3420122/...

InformationsquelleAutor Adam Matan | 2010-05-16

388

De nos jours, dans Python 2.7 et le haut, vous pouvez utiliser un dict compréhension:
```
{k: v for k, v in points.iteritems() if v[0] < 5 and v[1] < 5}
```
Et en Python 3:
```
{k: v for k, v in points.items() if v[0] < 5 and v[1] < 5}
```
- Upvote! C'est plus de deux fois plus rapide que Martellis approche plus générale. Notez que vous pouvez utiliser des points de vue (comme iteitems, ils ne sont PAS une copie de la dict éléments): {k: v k, v dans les points.viewitems() si v[0] < 5 et v[1] < 5}
- Et voici une bonne explication de l'appel de la fonction dict() est plus lent que le constructeur/la syntaxe littérale {} doughellmann.com/2012/11/...
- Gardez à l'esprit que iteritems a été supprimé en Python 3. Mais vous pouvez utiliser items à la place. Il se comporte de la façon iteritems œuvres dans les anciennes versions.
- Merci, édité que dans.
- Hé, mon pote, je sais que c'est vieux, mais peut-on utiliser dict compréhension pour exécuter chaîne partielle correspond dans la colonne " x " contre dict clés?
- Je suis sûr que l'on pouvait. On pourrait aussi ouvrir une nouvelle question avec suffisamment de détails pour avoir une réponse utile 😉
- On a ouvert une question avec des réponses limitées, donc on a eu recours à la lecture, comme de nombreuses questions que l'on peut obtenir une meilleure compréhension. On a vu un de plus compétent et donc, a continué de choisir ceux cerveaux 😉 mon Q : stackoverflow.com/questions/50104127/...
InformationsquelleAutor Thomas
108
```
dict((k, v) for k, v in points.items() if all(x < 5 for x in v))
```
Vous pourriez choisir d'appeler .iteritems() au lieu de .items() si vous êtes en Python 2 et points peut avoir un beaucoup d'entrées.

all(x < 5 for x in v) peut-être exagéré si vous savez que chaque point sera toujours en 2D seulement (dans ce cas, vous pourriez exprimer la même contrainte avec un and), mais il fonctionne parfaitement;-).

InformationsquelleAutor Alex Martelli
20
```
points_small = dict(filter(lambda (a,(b,c)): b<5 and c < 5, points.items()))
```
- En Python 2 utilisez iteritems() à la place des items()
- En python 3.5, cela renvoie une erreur: points_small = dict(filter(lambda (a, b,c)): b<5 et c < 5, points.items())) ^ SyntaxError: invalid syntaxe `
- Je pense qu'il n'est pas pris en charge dans python 3
InformationsquelleAutor sizzzzlerz
14
```
>>> points = {'a': (3, 4), 'c': (5, 5), 'b': (1, 2), 'd': (3, 3)}
>>> dict(filter(lambda x: (x[1][0], x[1][1]) < (5, 5), points.items()))

{'a': (3, 4), 'b': (1, 2), 'd': (3, 3)}
```
- super ! la peine de mentionner que c'est Py3, que le lambda ne peut plus déballez le tuple argument (voir PEP 3113)
- Vous comparez les tuples de manière lexicographique, ce qui n'est pas ce que l'OP nécessaire. Dans votre cas, le point (3, 10) va passer le test: (3, 10) < (5, 5) est Vrai, mais c'est faux (y devrait être inférieure à 5 ainsi).
InformationsquelleAutor benguesmia farid

dict((k, v) for (k, v) in points.iteritems() if v[0] < 5 and v[1] < 5)

InformationsquelleAutor nosklo

7

Je pense que Alex Martelli la réponse est certainement la façon la plus élégante de le faire, mais je voulais juste ajouter un moyen de satisfaire votre envie pour une super génial dictionary.filter(f) méthode dans un Pythonic sorte de passage:
```
class FilterDict(dict):
    def __init__(self, input_dict):
        for key, value in input_dict.iteritems():
            self[key] = value
    def filter(self, criteria):
        for key, value in self.items():
            if (criteria(value)):
                self.pop(key)

my_dict = FilterDict( {'a':(3,4), 'b':(1,2), 'c':(5,5), 'd':(3,3)} )
my_dict.filter(lambda x: x[0] < 5 and x[1] < 5)
```
En gros, nous avons créer une classe qui hérite de dict, mais ajoute de la méthode de filtrage. Nous avons besoin d'utiliser .items() pour le filtrage, puisque l'utilisation de .iteritems() tout de façon destructrice de l'itération va raise exception.
- +1 Merci, le code élégant. Je pense vraiment qu'il devrait être une partie de la norme dictionnaire.
InformationsquelleAutor qwwqwwq

dict((k, v) for (k, v) in points.iteritems() if v[0] < 5 and v[1] < 5)

InformationsquelleAutor Ignacio Vazquez-Abrams

Vous devez vous connecter pour publier un commentaire.