Filtrer la dictée pour qu'elle ne contienne que certaines clés ?

Question

J'ai un dict qui a tout un tas d'entrées. Je ne suis intéressé que par quelques-unes d'entre elles. Existe-t-il un moyen simple d'élaguer toutes les autres ?

Answer 1

Construire un nouveau dict :

dict_you_want = { your_key: old_dict[your_key] for your_key in your_keys }

Utilise la compréhension du dictionnaire.

Si vous utilisez une version qui en est dépourvue (c'est-à-dire Python 2.6 et antérieur), faites en sorte qu'il soit dict((your_key, old_dict[your_key]) for ...) . C'est la même chose, mais en plus moche.

Notez que cette version, contrairement à celle de jnnnnn, a des performances stables (qui ne dépendent que du nombre de vos_clés) pour les éléments suivants old_dict de toute taille. Tant en termes de vitesse que de mémoire. Comme il s'agit d'une expression génératrice, elle ne traite qu'un seul élément à la fois, et n'examine pas tous les éléments de old_dict.

Enlever tout ce qui est en place :

unwanted = set(keys) - set(your_dict)
for unwanted_key in unwanted: del your_dict[unwanted_key]

Answer 2

Une compréhension de la dictée légèrement plus élégante :

foodict = {k: v for k, v in mydict.items() if k.startswith('foo')}

Answer 3

Voici un exemple en python 2.6 :

>>> a = {1:1, 2:2, 3:3}
>>> dict((key,value) for key, value in a.iteritems() if key == 1)
{1: 1}

La partie filtrage est la if déclaration.

Cette méthode est plus lente que la réponse de Delnan si vous ne voulez sélectionner que quelques touches parmi un très grand nombre.

Answer 4

Compte tenu de votre dictionnaire original orig et l'ensemble des entrées qui vous intéressent keys :

filtered = dict(zip(keys, [orig[k] for k in keys]))

qui n'est pas aussi agréable que la réponse de delnan, mais qui devrait fonctionner dans toutes les versions de Python qui nous intéressent. Elle est cependant fragile à chaque élément de keys existant dans votre dictionnaire d'origine.

Answer 5

Cette fonction fera l'affaire :

def include_keys(dictionary, keys):
    """Filters a dict by only including certain keys."""
    key_set = set(keys) & set(dictionary.keys())
    return {key: dictionary[key] for key in key_set}

Tout comme la version de delnan, celle-ci utilise la compréhension de dictionnaire et a des performances stables pour les grands dictionnaires (ne dépend que du nombre de clés autorisées, et non du nombre total de clés dans le dictionnaire).

Et tout comme la version de MyGGan, celle-ci permet à votre liste de clés d'inclure des clés qui peuvent ne pas exister dans le dictionnaire.

Et en bonus, voici l'inverse, où vous pouvez créer un dictionnaire en excluant certaines clés dans l'original :

def exclude_keys(dictionary, keys):
    """Filters a dict by excluding certain keys."""
    key_set = set(dictionary.keys()) - set(keys)
    return {key: dictionary[key] for key in key_set}

Notez que contrairement à la version de delnan, l'opération n'est pas faite en place, donc la performance est liée au nombre de clés dans le dictionnaire. Cependant, l'avantage est que la fonction ne modifiera pas le dictionnaire fourni.

Editar: Ajout d'une fonction distincte pour exclure certaines touches d'une dictée.