Löschen Sie ein Element aus einem Wörterbuch

Gibt es eine Möglichkeit, ein Element in Python aus einem Wörterbuch zu löschen?

Wie kann ich außerdem ein Element aus einem Wörterbuch löschen, um eine Kopie zurückzugeben (dh das Original nicht zu ändern)?

Die delAnweisung entfernt ein Element:

del d[key]

Dies mutiert jedoch das vorhandene Wörterbuch, sodass sich der Inhalt des Wörterbuchs für alle anderen Personen ändert, die auf dieselbe Instanz verweisen. Um ein neues Wörterbuch zurückzugeben, erstellen Sie eine Kopie des Wörterbuchs:

def removekey(d, key):
    r = dict(d)
    del r[key]
    return r

Der dict()Konstruktor erstellt eine flache Kopie . Informationen zum Erstellen einer tiefen Kopie finden Sie im copyModul .

Beachten Sie, dass Sie für jedes Diktat del/ jede Aufgabe / etc. Eine Kopie erstellen . bedeutet, dass Sie von der konstanten Zeit zur linearen Zeit wechseln und auch den linearen Raum verwenden. Für kleine Diktate ist dies kein Problem. Wenn Sie jedoch viele Kopien großer Diktate erstellen möchten, möchten Sie wahrscheinlich eine andere Datenstruktur wie ein HAMT (wie in dieser Antwort beschrieben ).

pop mutiert das Wörterbuch.

 >>> lol = {"hello": "gdbye"}
 >>> lol.pop("hello")
     'gdbye'
 >>> lol
     {}

Wenn Sie das Original behalten möchten, können Sie es einfach kopieren.

Ich denke, Ihre Lösung ist der beste Weg, dies zu tun. Wenn Sie jedoch eine andere Lösung wünschen, können Sie ein neues Wörterbuch erstellen, indem Sie die Schlüssel aus dem alten Wörterbuch verwenden, ohne den angegebenen Schlüssel einzuschließen.

>>> a
{0: 'zero', 1: 'one', 2: 'two', 3: 'three'}
>>> {i:a[i] for i in a if i!=0}
{1: 'one', 2: 'two', 3: 'three'}

Die del-Anweisung ist genau das, wonach Sie suchen. Wenn Sie ein Wörterbuch namens foo mit einem Schlüssel namens "bar" haben, können Sie "bar" wie folgt aus foo löschen:

del foo['bar']

Beachten Sie, dass dadurch das Wörterbuch, mit dem gearbeitet wird, dauerhaft geändert wird. Wenn Sie das Originalwörterbuch behalten möchten, müssen Sie zuvor eine Kopie erstellen:

>>> foo = {'bar': 'baz'}
>>> fu = dict(foo)
>>> del foo['bar']
>>> print foo
{}
>>> print fu
{'bar': 'baz'}

Der dictAnruf erstellt eine flache Kopie. Wenn Sie eine tiefe Kopie wünschen, verwenden Sie copy.deepcopy.

Hier ist eine Methode, die Sie kopieren und einfügen können:

def minus_key(key, dictionary):
    shallow_copy = dict(dictionary)
    del shallow_copy[key]
    return shallow_copy

Es gibt viele nette Antworten, aber ich möchte eines hervorheben.

Sie können sowohl eine dict.pop()Methode als auch eine allgemeinere delAnweisung verwenden , um Elemente aus einem Wörterbuch zu entfernen. Beide mutieren das ursprüngliche Wörterbuch, sodass Sie eine Kopie erstellen müssen (siehe Details unten).

Und beide lösen ein aus, KeyErrorwenn der Schlüssel, den Sie ihnen zur Verfügung stellen, nicht im Wörterbuch vorhanden ist:

key_to_remove = "c"
d = {"a": 1, "b": 2}
del d[key_to_remove]  # Raises `KeyError: 'c'`

und

key_to_remove = "c"
d = {"a": 1, "b": 2}
d.pop(key_to_remove)  # Raises `KeyError: 'c'`

Sie müssen sich darum kümmern:

durch Erfassen der Ausnahme:

key_to_remove = "c"
d = {"a": 1, "b": 2}
try:
    del d[key_to_remove]
except KeyError as ex:
    print("No such key: '%s'" % ex.message)

und

key_to_remove = "c"
d = {"a": 1, "b": 2}
try:
    d.pop(key_to_remove)
except KeyError as ex:
    print("No such key: '%s'" % ex.message)

durch eine Prüfung:

key_to_remove = "c"
d = {"a": 1, "b": 2}
if key_to_remove in d:
    del d[key_to_remove]

und

key_to_remove = "c"
d = {"a": 1, "b": 2}
if key_to_remove in d:
    d.pop(key_to_remove)

aber mit pop() es gibt auch eine viel präzisere Möglichkeit - geben Sie den Standardrückgabewert an:

key_to_remove = "c"
d = {"a": 1, "b": 2}
d.pop(key_to_remove, None)  # No `KeyError` here

Sofern Sie pop()nicht den Wert eines zu entfernenden Schlüssels ermitteln, können Sie alles angeben, was nicht erforderlich ist None. Es kann jedoch sein, dass die Verwendung delmit inCheck etwas schneller ist, da es sich pop()um eine Funktion mit eigenen Komplikationen handelt, die Overhead verursachen. Normalerweise ist dies nicht der Fall, daher ist der pop()Standardwert gut genug.

Bei der Hauptfrage müssen Sie eine Kopie Ihres Wörterbuchs erstellen, um das ursprüngliche Wörterbuch zu speichern und ein neues zu erstellen, ohne dass der Schlüssel entfernt wird.

Einige andere Leute hier schlagen vor, eine vollständige (tiefe) Kopie mit zu copy.deepcopy()erstellen, was ein Overkill sein könnte, eine "normale" (flache) Kopie mit copy.copy()oder dict.copy()könnte ausreichen. Das Wörterbuch enthält einen Verweis auf das Objekt als Wert für einen Schlüssel. Wenn Sie also einen Schlüssel aus einem Wörterbuch entfernen, wird diese Referenz entfernt und nicht das Objekt, auf das verwiesen wird. Das Objekt selbst kann später vom Garbage Collector automatisch entfernt werden, wenn keine anderen Referenzen im Speicher vorhanden sind. Das Erstellen einer tiefen Kopie erfordert im Vergleich zu einer flachen Kopie mehr Berechnungen. Daher wird die Codeleistung verringert, indem die Kopie erstellt, Speicher verschwendet und dem GC mehr Arbeit zur Verfügung gestellt wird. Manchmal reicht eine flache Kopie aus.

Wenn Sie jedoch veränderbare Objekte als Wörterbuchwerte haben und diese später im zurückgegebenen Wörterbuch ohne den Schlüssel ändern möchten, müssen Sie eine tiefe Kopie erstellen.

Mit flacher Kopie:

def get_dict_wo_key(dictionary, key):
    """Returns a **shallow** copy of the dictionary without a key."""
    _dict = dictionary.copy()
    _dict.pop(key, None)
    return _dict


d = {"a": [1, 2, 3], "b": 2, "c": 3}
key_to_remove = "c"

new_d = get_dict_wo_key(d, key_to_remove)
print(d)  # {"a": [1, 2, 3], "b": 2, "c": 3}
print(new_d)  # {"a": [1, 2, 3], "b": 2}
new_d["a"].append(100)
print(d)  # {"a": [1, 2, 3, 100], "b": 2, "c": 3}
print(new_d)  # {"a": [1, 2, 3, 100], "b": 2}
new_d["b"] = 2222
print(d)  # {"a": [1, 2, 3, 100], "b": 2, "c": 3}
print(new_d)  # {"a": [1, 2, 3, 100], "b": 2222}

Mit tiefer Kopie:

from copy import deepcopy


def get_dict_wo_key(dictionary, key):
    """Returns a **deep** copy of the dictionary without a key."""
    _dict = deepcopy(dictionary)
    _dict.pop(key, None)
    return _dict


d = {"a": [1, 2, 3], "b": 2, "c": 3}
key_to_remove = "c"

new_d = get_dict_wo_key(d, key_to_remove)
print(d)  # {"a": [1, 2, 3], "b": 2, "c": 3}
print(new_d)  # {"a": [1, 2, 3], "b": 2}
new_d["a"].append(100)
print(d)  # {"a": [1, 2, 3], "b": 2, "c": 3}
print(new_d)  # {"a": [1, 2, 3, 100], "b": 2}
new_d["b"] = 2222
print(d)  # {"a": [1, 2, 3], "b": 2, "c": 3}
print(new_d)  # {"a": [1, 2, 3, 100], "b": 2222}

… Wie kann ich ein Element aus einem Wörterbuch löschen, um eine Kopie zurückzugeben (dh das Original nicht zu ändern)?

A dictist die falsche Datenstruktur.

Sicher, das Kopieren des Diktats und das Herausspringen aus der Kopie funktionieren ebenso wie das Erstellen eines neuen Diktats mit einem Verständnis, aber all das Kopieren braucht Zeit - Sie haben eine Operation mit konstanter Zeit durch eine Operation mit linearer Zeit ersetzt. Und all diese Kopien, die gleichzeitig lebendig sind, nehmen Platz ein - linearer Raum pro Kopie.

Andere Datenstrukturen, wie z. B. Versuche mit Hash-Array-Zuordnung , sind genau für diesen Anwendungsfall konzipiert: Durch Hinzufügen oder Entfernen eines Elements wird eine Kopie in logarithmischer Zeit zurückgegeben, wobei der größte Teil des Speichers mit dem Original geteilt wird .¹

Natürlich gibt es einige Nachteile. Die Leistung ist eher logarithmisch als konstant (obwohl mit einer großen Basis, normalerweise 32-128). Und während Sie die nicht mutierende API mit identisch machen können, dictunterscheidet sich die "mutierende" API offensichtlich. Und vor allem sind in Python keine HAMT-Batterien enthalten. ²

Die pyrsistentBibliothek ist eine ziemlich solide Implementierung von HAMT-basierten Dikt-Ersetzungen (und verschiedenen anderen Typen) für Python. Es hat sogar eine raffinierte Evolver-API, um vorhandenen Mutationscode so reibungslos wie möglich auf persistenten Code zu portieren. Wenn Sie jedoch explizit Kopien zurückgeben möchten, anstatt sie zu mutieren, verwenden Sie sie einfach wie folgt:

>>> from pyrsistent import m
>>> d1 = m(a=1, b=2)
>>> d2 = d1.set('c', 3)
>>> d3 = d1.remove('a')
>>> d1
pmap({'a': 1, 'b': 2})
>>> d2
pmap({'c': 3, 'a': 1, 'b': 2})
>>> d3
pmap({'b': 2})

Das d3 = d1.remove('a')ist genau das, was die Frage ist zu fragen.

Wenn Sie veränderbare Datenstrukturen wie dictund listeingebettet in haben, pmaptreten immer noch Aliasing-Probleme auf. Sie können dies nur beheben, indem Sie unveränderlich nach unten gehen und pmaps und pvectors einbetten .

_{1. HAMTs sind auch in Sprachen wie Scala, Clojure, Haskell populär geworden, weil sie sehr gut mit sperrfreier Programmierung und Software-Transaktionsspeicher spielen, aber keine davon ist in Python sehr relevant.}

_{2. Tatsächlich gibt es in der stdlib ein HAMT, das bei der Implementierung von verwendet wird contextvars. Das früher zurückgezogene PEP erklärt warum. Dies ist jedoch ein verstecktes Implementierungsdetail der Bibliothek, kein öffentlicher Sammlungstyp.}

d = {1: 2, '2': 3, 5: 7}
del d[5]
print 'd = ', d

Ergebnis: d = {1: 2, '2': 3}

Rufen Sie einfach del d ['key'] auf.

In der Produktion ist es jedoch immer eine gute Praxis, zu überprüfen, ob in d 'Schlüssel' vorhanden ist.

if 'key' in d:
    del d['key']

Nein, es gibt keinen anderen Weg als

def dictMinus(dct, val):
   copy = dct.copy()
   del copy[val]
   return copy

Das Erstellen von Kopien nur geringfügig veränderter Wörterbücher ist jedoch wahrscheinlich keine gute Idee, da dies zu einem vergleichsweise hohen Speicherbedarf führt. In der Regel ist es besser, das alte Wörterbuch zu protokollieren (falls erforderlich) und es dann zu ändern.

# mutate/remove with a default
ret_val = body.pop('key', 5)
# no mutation with a default
ret_val = body.get('key', 5)

>>> def delete_key(dict, key):
...     del dict[key]
...     return dict
... 
>>> test_dict = {'one': 1, 'two' : 2}
>>> print delete_key(test_dict, 'two')
{'one': 1}
>>>

Dies führt zu keiner Fehlerbehandlung. Es wird davon ausgegangen, dass sich der Schlüssel im Diktat befindet. Möglicherweise möchten Sie dies zuerst überprüfen, und raisewenn dies nicht der Fall ist

Hier ein Top-Level-Design-Ansatz:

def eraseElement(d,k):
    if isinstance(d, dict):
        if k in d:
            d.pop(k)
            print(d)
        else:
            print("Cannot find matching key")
    else:
        print("Not able to delete")


exp = {'A':34, 'B':55, 'C':87}
eraseElement(exp, 'C')

Ich übergebe das Wörterbuch und den gewünschten Schlüssel in meine Funktion, überprüfe, ob es sich um ein Wörterbuch handelt und ob der Schlüssel in Ordnung ist. Wenn beide vorhanden sind, wird der Wert aus dem Wörterbuch entfernt und die Reste ausgedruckt.

Ausgabe: {'B': 55, 'A': 34}

Ich hoffe, das hilft!

Das folgende Code-Snippet wird Ihnen definitiv helfen. Ich habe in jeder Zeile Kommentare hinzugefügt, die Ihnen beim Verständnis des Codes helfen.

def execute():
   dic = {'a':1,'b':2}
   dic2 = remove_key_from_dict(dic, 'b')  
   print(dict2)           # {'a': 1}
   print(dict)            # {'a':1,'b':2}

def remove_key_from_dict(dictionary_to_use, key_to_delete):
   copy_of_dict = dict(dictionary_to_use)     # creating clone/copy of the dictionary
   if key_to_delete in copy_of_dict :         # checking given key is present in the dictionary
       del copy_of_dict [key_to_delete]       # deleting the key from the dictionary 
   return copy_of_dict                        # returning the final dictionary

oder Sie können auch dict.pop () verwenden

d = {"a": 1, "b": 2}

res = d.pop("c")  # No `KeyError` here
print (res)       # this line will not execute

oder der bessere Ansatz ist

res = d.pop("c", "key not found")
print (res)   # key not found
print (d)     # {"a": 1, "b": 2}

res = d.pop("b", "key not found")
print (res)   # 2
print (d)     # {"a": 1}

Hier ist eine weitere Variante, die das Listenverständnis verwendet:

original_d = {'a': None, 'b': 'Some'}
d = dict((k,v) for k, v in original_d.iteritems() if v)
# result should be {'b': 'Some'}

Der Ansatz basiert auf einer Antwort aus diesem Beitrag: Effiziente Methode zum Entfernen von Schlüsseln mit leeren Zeichenfolgen aus einem Diktat

    species = {'HI': {'1': (1215.671, 0.41600000000000004),
  '10': (919.351, 0.0012),
  '1025': (1025.722, 0.0791),
  '11': (918.129, 0.0009199999999999999),
  '12': (917.181, 0.000723),
  '1215': (1215.671, 0.41600000000000004),
  '13': (916.429, 0.0005769999999999999),
  '14': (915.824, 0.000468),
  '15': (915.329, 0.00038500000000000003),
 'CII': {'1036': (1036.3367, 0.11900000000000001), '1334': (1334.532, 0.129)}}

Mit dem folgenden Code wird eine Kopie von Diktaten erstellt speciesund Elemente gelöscht, die nicht enthalten sindtrans_HI

trans_HI=['1025','1215']
for transition in species['HI'].copy().keys():
    if transition not in trans_HI:
        species['HI'].pop(transition)