webentwicklung-frage-antwort-db.com.de

Mehrere Schlüssel sicher aus einem Wörterbuch entfernen

Um einen Eintrag, "Schlüssel" aus meinem Wörterbuch d zu entfernen, können Sie sicher Folgendes tun:

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 Tuple 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?

88
dublintech

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

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

Dict-Verstehen verwenden

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

wobei key1 und key2 entfernt werden sollen.

Im folgenden Beispiel sollen die Schlüssel "b" und "c" entfernt und in einer Schlüsselliste aufbewahrt 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}
>>> 
72

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

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

Sie können dies natürlich immer noch tun, um die Schlüssel aus d zu entfernen, aber Sie würden die Liste der Werte mit dem Listenverständnis unnötig erstellen. Es ist auch etwas unklar, ein Listenverständnis nur für die Nebenwirkung der Funktion zu verwenden.

17
Andrew Clark

eine Lösung verwendet map- und filter-Funktionen

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 kriegst:

{'c': 3}

Ich habe keine Probleme mit den 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 über diese Frage gestolpert, die aus hier stammt. Und meine Antwort bezieht sich auf diese Antwort .

4
Doug R.

Warum nicht:

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

Ich weiß nicht, was Sie mit "intelligenter Art" meinen. Sicher gibt es andere Möglichkeiten, vielleicht mit Wörterbuchverstehen:

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

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'}
1
chuang wang

Lösung mit pop und map gefunden

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 für die Zukunft hilfreich ist, wenn jemand dasselbe sucht. Und das könnte helfen.

1

Hier ist eine weitere einzeilige Lösung ohne Konvertierung von Liste zu Liste:

d = {'a': 1, 'b': 2, 'c': 3}
entities_to_remove = {'a', 'c'}

all(d.pop(x, None) for x in entities_to_remove)
0
Denis Busalaev

Ich denke, die Tatsache, dass die Schlüssel als Set behandelt werden können, ist der beste 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}
0
Reut Sharabani

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

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

Verwenden Sie dann pop () in einem Listenverständnis oder für eine Schleife, um die Tasten zu durchlaufen und nacheinander als solche zu platzieren.

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

Wenn der Schlüssel nicht vorhanden ist, muss ein Standardwert zurückgegeben werden.

0