Supprimer plusieurs clés d'un dictionnaire en toute sécurité

Je sais que pour supprimer une entrée, «clé» de mon dictionnaire d, en toute sécurité, vous faites:

if d.has_key('key'):
    del d['key']

Cependant, je dois supprimer plusieurs entrées du dictionnaire en toute sécurité. Je pensais définir les entrées dans un tuple car je devrai le faire plus d'une fois.

entitiesToREmove = ('a', 'b', 'c')
for x in entitiesToRemove:
    if d.has_key(x):
        del d[x]

Cependant, je me demandais s'il existe un moyen plus intelligent de le faire?

Pourquoi pas comme ça:

entries = ('a', 'b', 'c')
the_dict = {'b': 'foo'}

def entries_to_remove(entries, the_dict):
    for key in entries:
        if key in the_dict:
            del the_dict[key]

Une version plus compacte a été fournie par mattbornski en utilisant dict.pop ()

d = {'some':'data'}
entriesToRemove = ('any', 'iterable')
for k in entriesToRemove:
    d.pop(k, None)

Utilisation de Dict Comprehensions

final_dict = {key: t[key] for key in t if key not in [key1, key2]}

où key1 et key2 doivent être supprimés.

Dans l'exemple ci-dessous, les clés "b" et "c" doivent être supprimées et elles sont conservées dans une liste de clés.

>>> a
{'a': 1, 'c': 3, 'b': 2, 'd': 4}
>>> keys = ["b", "c"]
>>> print {key: a[key] for key in a if key not in keys}
{'a': 1, 'd': 4}
>>> 

une solution utilise mapet filterfonctionne

python 2

d={"a":1,"b":2,"c":3}
l=("a","b","d")
map(d.__delitem__, filter(d.__contains__,l))
print(d)

python 3

d={"a":1,"b":2,"c":3}
l=("a","b","d")
list(map(d.__delitem__, filter(d.__contains__,l)))
print(d)

vous obtenez:

{'c': 3}

Si vous aviez également besoin de récupérer les valeurs des clés que vous supprimez, ce serait un très bon moyen de le faire:

valuesRemoved = [d.pop(k, None) for k in entitiesToRemove]

Vous pouvez bien sûr toujours le faire juste pour supprimer les clés de d, mais vous créeriez inutilement la liste de valeurs avec la compréhension de liste. Il est également peu clair d'utiliser une compréhension de liste uniquement pour l'effet secondaire de la fonction.

J'ai trouvé une solution avec popetmap

d = {'a': 'valueA', 'b': 'valueB', 'c': 'valueC', 'd': 'valueD'}
keys = ['a', 'b', 'c']
list(map(d.pop, keys))
print(d)

La sortie de ceci:

{'d': 'valueD'}

J'ai répondu à cette question si tard simplement parce que je pense que cela aidera à l'avenir si quelqu'un cherche la même chose. Et cela pourrait aider.

Mettre à jour

Le code ci-dessus lancera une erreur si une clé n'existe pas dans le dict.

DICTIONARY = {'a': 'valueA', 'b': 'valueB', 'c': 'valueC', 'd': 'valueD'}
keys = ['a', 'l', 'c']

def remove_keys(key):
    try:
        DICTIONARY.pop(key, None)
    except:
        pass  # or do any action

list(map(remove_key, keys))
print(DICTIONARY)

production:

DICTIONARY = {'b': 'valueB', 'd': 'valueD'}

Je n'ai aucun problème avec aucune des réponses existantes, mais j'ai été surpris de ne pas trouver cette solution:

keys_to_remove = ['a', 'b', 'c']
my_dict = {k: v for k, v in zip("a b c d e f g".split(' '), [0, 1, 2, 3, 4, 5, 6])}

for k in keys_to_remove:
    try:
        del my_dict[k]
    except KeyError:
        pass

assert my_dict == {'d': 3, 'e': 4, 'f': 5, 'g': 6}

Remarque: je suis tombé sur cette question venant d' ici . Et ma réponse est liée à cette réponse .

Pourquoi pas:

entriestoremove = (2,5,1)
for e in entriestoremove:
    if d.has_key(e):
        del d[e]

Je ne sais pas ce que vous entendez par «manière plus intelligente». Il existe sûrement d'autres moyens, peut-être avec la compréhension du dictionnaire:

entriestoremove = (2,5,1)
newdict = {x for x in d if x not in entriestoremove}

en ligne

import functools

#: not key(c) in d
d = {"a": "avalue", "b": "bvalue", "d": "dvalue"}

entitiesToREmove = ('a', 'b', 'c')

#: python2
map(lambda x: functools.partial(d.pop, x, None)(), entitiesToREmove)

#: python3

list(map(lambda x: functools.partial(d.pop, x, None)(), entitiesToREmove))

print(d)
# output: {'d': 'dvalue'}

Certains tests de synchronisation pour cpython 3 montrent qu'une simple boucle for est le moyen le plus rapide, et il est assez lisible. L'ajout d'une fonction n'entraîne pas non plus beaucoup de surcharge:

résultats timeit (10k itérations):

• all(x.pop(v) for v in r) # 0.85
• all(map(x.pop, r)) # 0.60
• list(map(x.pop, r)) # 0.70
• all(map(x.__delitem__, r)) # 0.44
• del_all(x, r) # 0.40
• <inline for loop>(x, r) # 0.35

def del_all(mapping, to_remove):
      """Remove list of elements from mapping."""
      for key in to_remove:
          del mapping[key]

Pour les petites itérations, faire cela «en ligne» était un peu plus rapide, à cause de la surcharge de l'appel de fonction. Mais il del_allest sûr, réutilisable et plus rapide que toutes les constructions de compréhension et de mappage python.

Je pense que l'utilisation du fait que les clés peuvent être traitées comme un ensemble est la meilleure façon si vous êtes sur python 3:

def remove_keys(d, keys):
    to_remove = set(keys)
    filtered_keys = d.keys() - to_remove
    filtered_values = map(d.get, filtered_keys)
    return dict(zip(filtered_keys, filtered_values))

Exemple:

>>> remove_keys({'k1': 1, 'k3': 3}, ['k1', 'k2'])
{'k3': 3}

Ce serait bien d'avoir un support complet pour les méthodes set pour les dictionnaires (et non le désordre impie que nous obtenons avec Python 3.9) afin que vous puissiez simplement "supprimer" un ensemble de clés. Cependant, tant que ce n'est pas le cas et que vous disposez d'un dictionnaire volumineux avec potentiellement un grand nombre de clés à supprimer, vous voudrez peut-être en savoir plus sur les performances. J'ai donc créé du code qui crée quelque chose d'assez grand pour des comparaisons significatives: une matrice de 100 000 x 1000, donc 10 000,00 éléments au total.

from itertools import product
from time import perf_counter

# make a complete worksheet 100000 * 1000
start = perf_counter()
prod = product(range(1, 100000), range(1, 1000))
cells = {(x,y):x for x,y in prod}
print(len(cells))

print(f"Create time {perf_counter()-start:.2f}s")
clock = perf_counter()
# remove everything above row 50,000

keys = product(range(50000, 100000), range(1, 100))

# for x,y in keys:
#     del cells[x, y]

for n in map(cells.pop, keys):
    pass

print(len(cells))
stop = perf_counter()
print(f"Removal time {stop-clock:.2f}s")

10 millions d'articles ou plus n'est pas inhabituel dans certains contextes. En comparant les deux méthodes sur ma machine locale, je constate une légère amélioration lors de l'utilisation mapet pop, probablement à cause du moins grand nombre d'appels de fonction, mais les deux prennent environ 2,5 secondes sur ma machine. Mais cela ne fait rien par rapport au temps nécessaire pour créer le dictionnaire en premier lieu (55 s), ou en incluant des vérifications dans la boucle. Si cela est probable, il est préférable de créer un ensemble qui est une intersection des clés du dictionnaire et de votre filtre:

keys = cells.keys() & keys

En résumé: delest déjà fortement optimisé, alors ne vous inquiétez pas de l'utiliser.

Je suis en retard à cette discussion mais pour n'importe qui d'autre. Une solution peut être de créer une liste de clés en tant que telle.

k = ['a','b','c','d']

Ensuite, utilisez pop () dans une liste de compréhension, ou une boucle for, pour parcourir les touches et les pop une par une.

new_dictionary = [dictionary.pop(x, 'n/a') for x in k]

Le «n / a» est au cas où la clé n'existe pas, une valeur par défaut doit être retournée.