Löschen Sie ein Element aus einem Wörterbuch

1394

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

Richzilla
quelle
13
Warum benötigen Sie eine Funktion, die ein Wörterbuch zurückgibt, wenn Sie das Wörterbuch einfach direkt ändern können?
Amillerrhodes
5
Die Wörterbuch - popMethode ändert das Wörterbuch in-place . Daher ändert es den Verweis auf das Wörterbuch, das vom Aufrufer an die "Hilfsfunktion" übergeben wurde. Die "Hilfsfunktion" muss also nichts zurückgeben, da der ursprüngliche Verweis auf das Wörterbuch im Aufrufer bereits geändert wird. Weisen Sie die Rückgabe von dict.pop()nichts zu, wenn Sie sie nicht benötigen. EG : do stuff with my_dict; my_dict.pop(my_key, None); do more stuff with my_dict # now doesn't have my_key. Verwenden Sie, deepcopy(my_dict)wenn nötig.
Mark Mikofski
1
Da der ursprüngliche Titel nicht mit den Details übereinstimmte und die offensichtliche Lösung ausdrücklich ausschloss d.pop(), habe ich den Titel korrigiert, um die in den Details angegebene Frage zu stellen.
smci
1
Wir sollten eine Einschränkung hinzufügen, in der Sie gefragt werden, ob Sie dies wirklich tun möchten, als ob Sie es N-mal in einem Wörterbuch mit E-Elementen tun würden. Sie werden O (N * E) -Speicher mit all den tiefen Kopien verlieren (/ verwenden). Wenn Sie nur eine schreibgeschützte (flache Kopie) möchten, tun Sie dies d.pop(key). Wenn jedoch jemals etwas die flache Kopie ändert, haben Sie ein bekanntes Problem mit dem Aliasing . Es hilft, wenn Sie uns den weiteren Kontext mitteilen. (Ändert irgendetwas anderes jemals die Diktatwerte? Versuchen Sie, eine Liste destruktiv zu durchlaufen? Wenn nicht, was?)
smci
5
"Warum brauchen Sie eine Funktion, die ein Wörterbuch zurückgibt, wenn Sie das Wörterbuch einfach direkt ändern können?" Vielleicht, weil Sie reine Funktionen schreiben möchten, deren Parameter nicht geändert werden?
Gene Callahan

Antworten:

1728

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

Greg Hewgill
quelle
15
Das ist ein großartiger Punkt in Bezug auf die Veränderbarkeit von Wörterbüchern +1 - obwohl ich mir keine Zeit vorstellen kann, in der ich Kopien des Wörterbuchs haben wollte, habe ich mich immer darauf verlassen, dass alle Kopien gleich sind. toller Punkt.
tMC
30
@tMC Wenn Sie das bearbeiten, dictwährend Sie es durchlaufen, wird es Ihnen einen Fehler geben:RuntimeError: dictionary changed size during iteration
VertigoRay
15
Was ist mit der popMethode, die tatsächlich dasselbe tut? Ist es nicht pythonischer? (ist die Methode des Diktats, kein spezielles reserviertes Wort)?
Serge
21
Diese Antwort hat eine Schwäche, sie könnte irreführend sein. Leser können falsch verstehen, dass Diktat (d) ihnen eine Kopie mit 'd' geben kann. Aber es ist eine unvollständige Kopie. Wenn Sie nur Del-Keys ausführen, ist das in Ordnung. Wenn Sie jedoch einem verschachtelten Diktat etwas anderes hinzufügen möchten, kann das Ändern von 'r' mithilfe dieser Kopiermethode zu einer Änderung des ursprünglichen 'd' führen. Um eine authentische Kopie zu erhalten, benötigen Sie zuerst 'Kopie importieren' und dann 'r = copy.deepcopy (d)'.
Zen
10
@ Zen: Fair genug, ich habe eine Notiz über flache vs. tiefe Kopien hinzugefügt.
Greg Hewgill
264

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.

Kristall
quelle
29
"del" ist in Ordnung, aber "pop" scheint meiner Meinung nach eher "Pythonic" zu sein.
ivanleoncz
1
@ivanleoncz warum?
Kevr
3
popGibt den Wert zurück, der 'popped' war, sodass Sie diesen Wert aus irgendeinem weiteren Grund verwenden können. Wenn es nicht mehr "Pythonic" ist, würde ich sagen, das scheint sicher besser zu sein :). Es ist kein Diktat, aber es funktioniert für beide gleich: github.com/ivanlmj/python-prototypes/blob/master/3.4/…
ivanleoncz
2
@ivanleoncz Es ist auch aus einem weiteren Grund besser, popkann mit einem Standardwert versehen werden, der zurückgegeben wird, wenn ein Schlüssel in dict fehlt. Es ist gut, wenn Sie einige Schlüssel entfernen müssen, aber einige davon fehlen möglicherweise. delwürde KeyErrorin einem solchen Fall werfen .
Itachi
80

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'}
utdemir
quelle
2
Wirklich cool. Ich mag die schnelle Methode, ein Wörterbuch zu filtern, ohne eine neue Funktion zu definieren.
Joe J
6
Für diejenigen, die mit dem Verständnis nicht vertraut sind, können Sie auch Folgendes tun: {i:a[i] for i in a if i not in [0, 1, 2]}Wenn Sie mehrere Elemente entfernen möchten.
kmatheny
9
Besser wäre {k:v for k,v in a.items() if k != 0}ich denke.
Rlbond
1
Die beste Lösung, um ein Element per Schlüssel zu entfernen und das Ergebnis des neuen Diktats in derselben Zeile zurückzugeben. Zum Beispiel , wenn Sie benötigen ein ein bereits aufgebaut dict ohne einen einzigen Artikel zu verwenden , wie **kwargs,some_function(**{k:v for k,v in some_dict.items() if k not 'some_key'})
Cole
Beste Lösung hier. Ein Liner und es mutiert nicht das ursprüngliche Wörterbuch.
Andrew Winterbotham
55

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
arussell84
quelle
1
@ pythonian29033, eigentlich nein . Die akzeptierte Antwort funktioniert wie erwartet - sie gibt das Diktat ohne einen Schlüssel zurück. Der Ansatz aus dieser Antwort mutiert das ursprüngliche Diktat;) Es gibt einen signifikanten Unterschied
maxkoryukov
1
@ arussell84, warum >>>wird in den Python-Beispielen oft verwendet? Ja, Python-Doc enthält viele solcher Dinge. Ein solcher Code ist jedoch für die Kopierpaste nicht geeignet . Ich bin verwirrt ...
maxkoryukov
@maxkoryukov yup es tut! Diese Funktion und diese Antwort sind jedoch genau gleich, mit der Ausnahme, dass sich diese Antwort innerhalb einer Funktion befindet. und Sie müssen eine Weile nicht in Python codiert haben, die>>> ahmt die
Hörnotation
2
@ pythonian29033 über >>>. Ja, es ist im REPL-Stil, aber lassen Sie uns ehrlich sprechen: Der einzige Mann hatte dieses Beispiel geschrieben, und 1000 haben es gelesen. Ich denke, es wäre großartig, Beispiele so zu schreiben, dass sie einfach kopiert und ausgeführt werden können. Ich möchte diese spitzen Klammern nicht von Hand entfernen. Oder Zeile für Zeile kopieren. Also verstehe ich nicht: warum diese Winkel noch da sind))) Vielleicht weiß ich etwas nicht?
Maxkoryukov
3
Ich habe eine Funktion hinzugefügt, die zur Vereinfachung kopiert / eingefügt werden kann.
Arussell84
48

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}
Nikita
quelle
21

… 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 .1

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. 2

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.

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

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

Satelliten
quelle
14

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']
Khanh Hua
quelle
7
Hmm, nein, in der Produktion ist es besser, der EAFP- Ideologie zu folgen . Entfernen Sie einfach den Schlüssel im try-exceptBlock. Zumindest wird dies eine atomare Operation sein;)
Maxkoryukov
1
Und wenn Sie d.pop('key', None)präzise sein möchten, verwenden Sie es als Oneliner. Die eigentliche Frage war jedoch, das Wörterbuch ohne einen Schlüssel zu erhalten und nicht das Diktat zu ändern. Also Verständnis - ist hier eine gute Wahl;)
Maxkoryukov
7

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.

Phihag
quelle
7
# mutate/remove with a default
ret_val = body.pop('key', 5)
# no mutation with a default
ret_val = body.get('key', 5)
daino3
quelle
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

tMC
quelle
10
Wie unterscheidet sich Ihre Methode von nur del test_dict[key]?
Mad Physicist
5

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!

Atlas
quelle
3

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}
Mayur Agarwal
quelle
2

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

BigBlueHat
quelle
1
Wenn Sie eine jahrelange Frage beantworten möchten, die bereits eine einfache, angemessene und akzeptierte Antwort enthält, stellen Sie zumindest sicher, dass Ihre Antwort richtig ist. Dies macht nicht das, was das OP verlangt hat.
user2357112 unterstützt Monica
Ich überprüfe im Allgemeinen keine Daten für Fragen, bei denen meiner Meinung nach wertvolle Informationen hinzugefügt werden könnten. Zusätzlich laut einem der Kommentare zu der Frage, auf die ich verlinkt habe: "Normalerweise ist dies genau das, was jemand will und wahrscheinlich das, was das OP benötigt, aber es ist nicht das, wonach das OP gefragt hat" stackoverflow.com/questions/12118695/… I. wusste, dass es keine direkte Antwort auf die Frage war; eher eine Erweiterung der Optionen.
BigBlueHat
3
Diese Antwort ist zwar nicht vollständig, lässt uns jedoch lernen, dass wir Elemente auch unter if-Bedingungen entfernen können. nur ändern, if vum if k is not 'a'die op zu beantworten. Aber ich denke nicht, dass dies ein effizienter Weg ist. Dadurch wird das Element in O (n) und nicht in O (log n) entfernt, wie dies bei Pop oder Del der Fall ist.
Holgac
0
    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)
Sameeresque
quelle