Mehrere Schlüssel sicher aus einem Wörterbuch entfernen

Ich weiß, dass ich einen Eintrag, 'Schlüssel' d, sicher aus meinem Wörterbuch entfernen muss.

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

Ich muss jedoch mehrere Einträge sicher aus dem Wörterbuch entfernen. Ich habe darüber nachgedacht, die Einträge in einem Tupel zu definieren, da ich dies mehr als einmal tun muss.

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

Ich habe mich jedoch gefragt, ob es einen intelligenteren Weg gibt, dies zu tun.

Warum nicht so:

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]

Eine kompaktere Version wurde von mattbornski mit dict.pop () bereitgestellt

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

Verwenden von Diktatverständnissen

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

wo Schlüssel1 und Schlüssel2 entfernt werden sollen.

Im folgenden Beispiel müssen die Schlüssel "b" und "c" entfernt und in einer Schlüsselliste gespeichert werden.

>>> 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}
>>> 

Eine Lösung verwendet mapundfilter funktioniert

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)

du erhältst:

{'c': 3}

Wenn Sie auch die Werte für die Schlüssel abrufen müssen, die Sie entfernen, ist dies ein guter Weg, dies zu tun:

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

Sie könnten dies natürlich immer noch nur zum Entfernen der Schlüssel aus tun d, aber Sie würden unnötigerweise die Werteliste mit dem Listenverständnis erstellen. Es ist auch ein wenig unklar, ein Listenverständnis nur für die Nebenwirkung der Funktion zu verwenden.

Mit popund eine Lösung gefundenmap

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

Die Ausgabe davon:

{'d': 'valueD'}

Ich habe diese Frage so spät beantwortet, nur weil ich denke, dass es in Zukunft helfen wird, wenn jemand dasselbe sucht. Und das könnte helfen.

Aktualisieren

Der obige Code löst einen Fehler aus, wenn im Diktat kein Schlüssel vorhanden ist.

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)

Ausgabe:

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

Ich habe kein Problem mit einer der vorhandenen Antworten, aber ich war überrascht, diese Lösung nicht zu finden:

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}

Hinweis: Ich bin auf diese Frage gestoßen, die von hier kommt . Und meine Antwort bezieht sich auf diese Antwort .

Warum nicht:

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

Ich weiß nicht, was du mit "klügerer Weg" meinst. Sicher gibt es andere Möglichkeiten, vielleicht mit Wörterbuchverständnis:

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

in der Reihe

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'}

Einige Timing-Tests für cpython 3 zeigen, dass eine einfache for-Schleife der schnellste Weg ist und gut lesbar ist. Das Hinzufügen einer Funktion verursacht auch nicht viel Overhead:

Timeit-Ergebnisse (10.000 Iterationen):

• 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]

Bei kleinen Iterationen war dies aufgrund des Overheads des Funktionsaufrufs etwas schneller. Aber del_allist fusselsicher, wiederverwendbar und schneller als alle Python-Verständnis- und Mapping-Konstrukte.

Ich denke, die Tatsache, dass die Schlüssel als Set behandelt werden können, ist der schönste Weg, wenn Sie mit Python 3 arbeiten:

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))

Beispiel:

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

Es wäre schön, volle Unterstützung für festgelegte Methoden für Wörterbücher zu haben (und nicht für das unheilige Durcheinander, das wir mit Python 3.9 bekommen), damit Sie einfach einen Satz von Schlüsseln "entfernen" können. Solange dies jedoch nicht der Fall ist und Sie ein großes Wörterbuch mit möglicherweise einer großen Anzahl von Schlüsseln zum Entfernen haben, möchten Sie möglicherweise Informationen zur Leistung erhalten. Also habe ich einen Code erstellt, der etwas erstellt, das groß genug für aussagekräftige Vergleiche ist: eine 100.000 x 1000-Matrix, also insgesamt 10.000,00 Elemente.

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 Millionen Artikel oder mehr sind in einigen Einstellungen nicht ungewöhnlich. Beim Vergleich der beiden Methoden auf meinem lokalen Computer sehe ich eine leichte Verbesserung bei der Verwendung mapund popvermutlich aufgrund weniger Funktionsaufrufe, aber beide dauern auf meinem Computer ungefähr 2,5 Sekunden. Dies verblasst jedoch im Vergleich zu der Zeit, die erforderlich ist, um das Wörterbuch überhaupt zu erstellen (55 Sekunden) oder Überprüfungen in die Schleife einzubeziehen. Wenn dies wahrscheinlich ist, erstellen Sie am besten eine Menge, die eine Schnittstelle zwischen den Wörterbuchschlüsseln und Ihrem Filter darstellt:

keys = cells.keys() & keys

Zusammenfassend: delist bereits stark optimiert, machen Sie sich also keine Sorgen über die Verwendung.

Ich bin zu spät zu dieser Diskussion, aber für alle anderen. Eine Lösung kann darin bestehen, eine Liste von Schlüsseln als solche zu erstellen.

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

Verwenden Sie dann pop () in einem Listenverständnis oder eine for-Schleife, um die Tasten zu durchlaufen und einzeln als solche zu popen.

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

Das 'n / a' ist, falls der Schlüssel nicht existiert, muss ein Standardwert zurückgegeben werden.