Ist es möglich, einem Python-Wörterbuch nach seiner Erstellung einen Schlüssel hinzuzufügen?

Es scheint keine .add()Methode zu haben .

d = {'key': 'value'}
print(d)
# {'key': 'value'}
d['mynewkey'] = 'mynewvalue'
print(d)
# {'key': 'value', 'mynewkey': 'mynewvalue'}

Verwenden Sie Folgendes, um mehrere Schlüssel gleichzeitig hinzuzufügen dict.update():

>>> x = {1:2}
>>> print(x)
{1: 2}

>>> d = {3:4, 5:6, 7:8}
>>> x.update(d)
>>> print(x)
{1: 2, 3: 4, 5: 6, 7: 8}

Zum Hinzufügen eines einzelnen Schlüssels hat die akzeptierte Antwort weniger Rechenaufwand.

Ich möchte Informationen über Python-Wörterbücher konsolidieren:

Ein leeres Wörterbuch erstellen

data = {}
# OR
data = dict()

Erstellen eines Wörterbuchs mit Anfangswerten

data = {'a': 1, 'b': 2, 'c': 3}
# OR
data = dict(a=1, b=2, c=3)
# OR
data = {k: v for k, v in (('a', 1), ('b',2), ('c',3))}

Einfügen / Aktualisieren eines einzelnen Wertes

data['a'] = 1  # Updates if 'a' exists, else adds 'a'
# OR
data.update({'a': 1})
# OR
data.update(dict(a=1))
# OR
data.update(a=1)

Einfügen / Aktualisieren mehrerer Werte

data.update({'c':3,'d':4})  # Updates 'c' and adds 'd'

Erstellen eines zusammengeführten Wörterbuchs ohne Änderung der Originale

data3 = {}
data3.update(data)  # Modifies data3, not data
data3.update(data2)  # Modifies data3, not data2

Elemente im Wörterbuch löschen

del data[key]  # Removes specific element in a dictionary
data.pop(key)  # Removes the key & returns the value
data.clear()  # Clears entire dictionary

Überprüfen Sie, ob sich bereits ein Schlüssel im Wörterbuch befindet

key in data

Durch Paare in einem Wörterbuch iterieren

for key in data: # Iterates just through the keys, ignoring the values
for key, value in d.items(): # Iterates through the pairs
for key in d.keys(): # Iterates just through key, ignoring the values
for value in d.values(): # Iterates just through value, ignoring the keys

Erstellen Sie ein Wörterbuch aus zwei Listen

data = dict(zip(list_with_keys, list_with_values))

Neu in Python 3.5

Erstellen eines zusammengeführten Wörterbuchs ohne Änderung der Originale:

Dies verwendet eine neue Funktion namens Dictionary Unpacking .

data = {**data1, **data2, **data3}

Neu in Python 3.9

Aktualisieren oder fügen Sie Werte für ein vorhandenes Wörterbuch hinzu

Der Update-Operator arbeitet |= jetzt für Wörterbücher:

data |= {'c':3,'d':4}

Erstellen eines zusammengeführten Wörterbuchs ohne Änderung der Originale

Der Zusammenführungsoperator arbeitet | jetzt für Wörterbücher:

data = data1 | {'c':3,'d':4}

Fühlen Sie sich frei, mehr hinzuzufügen!

"Ist es möglich, einem Python-Wörterbuch nach seiner Erstellung einen Schlüssel hinzuzufügen? Es scheint keine .add () -Methode zu haben."

Ja, es ist möglich und es gibt eine Methode, die dies implementiert, aber Sie möchten sie nicht direkt verwenden.

Um zu demonstrieren, wie und wie man es nicht verwendet, erstellen wir ein leeres Diktat mit dem Diktatliteral {}:

my_dict = {}

Best Practice 1: Indexnotation

Um dieses Diktat mit einem einzigen neuen Schlüssel und Wert zu aktualisieren, können Sie die tiefgestellte Notation (siehe Zuordnungen hier) verwenden , die die Elementzuweisung vorsieht:

my_dict['new key'] = 'new value'

my_dict ist jetzt:

{'new key': 'new value'}

Best Practice 2: Die updateMethode - 2 Möglichkeiten

Mit der updateMethode können wir das Diktat auch effizient mit mehreren Werten aktualisieren . Wir können hier unnötigerweise ein Extra erstellen dict, also hoffen wir, dass unser dictbereits erstellt wurde und von einem anderen Zweck stammt oder für einen anderen Zweck verwendet wurde:

my_dict.update({'key 2': 'value 2', 'key 3': 'value 3'})

my_dict ist jetzt:

{'key 2': 'value 2', 'key 3': 'value 3', 'new key': 'new value'}

Eine andere effiziente Möglichkeit, dies mit der Aktualisierungsmethode zu tun, sind Schlüsselwortargumente. Da es sich jedoch um legitime Python-Wörter handeln muss, können Sie keine Leerzeichen oder speziellen Symbole verwenden oder den Namen mit einer Zahl beginnen. Viele halten dies jedoch für lesbarer um Schlüssel für ein Diktat zu erstellen, und hier vermeiden wir sicherlich das Erstellen eines zusätzlichen unnötigen dict:

my_dict.update(foo='bar', foo2='baz')

und my_dictist jetzt:

{'key 2': 'value 2', 'key 3': 'value 3', 'new key': 'new value', 
 'foo': 'bar', 'foo2': 'baz'}

Jetzt haben wir drei pythonische Möglichkeiten zur Aktualisierung von a behandelt dict.

Magische Methode, __setitem__und warum sollte es vermieden werden

Es gibt eine andere Möglichkeit, eine zu aktualisieren dict, die Sie nicht verwenden sollten, nämlich die __setitem__Methode. Hier ist ein Beispiel, wie man die __setitem__Methode verwenden kann, um einem ein Schlüssel-Wert-Paar hinzuzufügen dict, und eine Demonstration der schlechten Leistung bei der Verwendung:

>>> d = {}
>>> d.__setitem__('foo', 'bar')
>>> d
{'foo': 'bar'}


>>> def f():
...     d = {}
...     for i in xrange(100):
...         d['foo'] = i
... 
>>> def g():
...     d = {}
...     for i in xrange(100):
...         d.__setitem__('foo', i)
... 
>>> import timeit
>>> number = 100
>>> min(timeit.repeat(f, number=number))
0.0020880699157714844
>>> min(timeit.repeat(g, number=number))
0.005071878433227539

Wir sehen also, dass die Verwendung der tiefgestellten Notation tatsächlich viel schneller ist als die Verwendung __setitem__. Das Pythonische zu tun, dh die Sprache so zu verwenden, wie sie verwendet werden sollte, ist normalerweise sowohl lesbarer als auch rechnerisch effizienter.

dictionary[key] = value

Wenn Sie ein Wörterbuch zu einem Wörterbuch hinzufügen möchten, können Sie dies auf diese Weise tun.

Beispiel: Fügen Sie Ihrem Wörterbuch und Unterwörterbuch einen neuen Eintrag hinzu

dictionary = {}
dictionary["new key"] = "some new entry" # add new dictionary entry
dictionary["dictionary_within_a_dictionary"] = {} # this is required by python
dictionary["dictionary_within_a_dictionary"]["sub_dict"] = {"other" : "dictionary"}
print (dictionary)

Ausgabe:

{'new key': 'some new entry', 'dictionary_within_a_dictionary': {'sub_dict': {'other': 'dictionarly'}}}

HINWEIS: Für Python müssen Sie zuerst ein Sub hinzufügen

dictionary["dictionary_within_a_dictionary"] = {}

vor dem Hinzufügen von Einträgen.

Die orthodoxe Syntax lautet d[key] = value, aber wenn auf Ihrer Tastatur die eckigen Klammern fehlen, können Sie Folgendes tun:

d.__setitem__(key, value)

Durch Definieren __getitem__und __setitem__Methoden können Sie festlegen, dass Ihre eigene Klasse die Syntax in eckigen Klammern unterstützt. Siehe https://python.developpez.com/cours/DiveIntoPython/php/endiveintopython/object_oriented_framework/special_class_methods.php

Sie können eine erstellen:

class myDict(dict):

    def __init__(self):
        self = dict()

    def add(self, key, value):
        self[key] = value

## example

myd = myDict()
myd.add('apples',6)
myd.add('bananas',3)
print(myd)

Gibt:

>>> 
{'apples': 6, 'bananas': 3}

Diese beliebte Frage befasst sich mit funktionalen Methoden zum Zusammenführen von Wörterbüchern aund b.

Hier sind einige der einfacheren Methoden (getestet in Python 3) ...

c = dict( a, **b ) ## see also https://stackoverflow.com/q/2255878
c = dict( list(a.items()) + list(b.items()) )
c = dict( i for d in [a,b] for i in d.items() )

Hinweis: Die erste Methode oben funktioniert nur, wenn die Schlüssel bZeichenfolgen sind.

Um ein einzelnes Element hinzuzufügen oder zu ändern , enthält das bWörterbuch nur dieses eine Element ...

c = dict( a, **{'d':'dog'} ) ## returns a dictionary based on 'a'

Dies entspricht ...

def functional_dict_add( dictionary, key, value ):
   temp = dictionary.copy()
   temp[key] = value
   return temp

c = functional_dict_add( a, 'd', 'dog' )

Stellen wir uns vor, Sie möchten in der unveränderlichen Welt leben und das Original NICHT ändern, sondern ein neues erstellen dict, das das Ergebnis des Hinzufügens eines neuen Schlüssels zum Original ist.

In Python 3.5+ können Sie Folgendes tun:

params = {'a': 1, 'b': 2}
new_params = {**params, **{'c': 3}}

Das Python 2-Äquivalent lautet:

params = {'a': 1, 'b': 2}
new_params = dict(params, **{'c': 3})

Nach einem dieser Punkte:

params ist immer noch gleich {'a': 1, 'b': 2}

und

new_params entspricht {'a': 1, 'b': 2, 'c': 3}

Es wird Zeiten geben, in denen Sie das Original nicht ändern möchten (Sie möchten nur das Ergebnis des Hinzufügens zum Original). Ich finde das eine erfrischende Alternative zu Folgendem:

params = {'a': 1, 'b': 2}
new_params = params.copy()
new_params['c'] = 3

oder

params = {'a': 1, 'b': 2}
new_params = params.copy()
new_params.update({'c': 3})

Referenz: https://stackoverflow.com/a/2255892/514866

So viele Antworten und trotzdem vergaßen alle die seltsam benannten, seltsam benommenen und dennoch handlichen dict.setdefault()

Diese

value = my_dict.setdefault(key, default)

macht im Grunde nur das:

try:
    value = my_dict[key]
except KeyError: # key not found
    value = my_dict[key] = default

z.B

>>> mydict = {'a':1, 'b':2, 'c':3}
>>> mydict.setdefault('d', 4)
4 # returns new value at mydict['d']
>>> print(mydict)
{'a':1, 'b':2, 'c':3, 'd':4} # a new key/value pair was indeed added
# but see what happens when trying it on an existing key...
>>> mydict.setdefault('a', 111)
1 # old value was returned
>>> print(mydict)
{'a':1, 'b':2, 'c':3, 'd':4} # existing key was ignored

Wenn Sie nicht zwei Wörterbücher verbinden, sondern einem Wörterbuch neue Schlüssel-Wert-Paare hinzufügen, ist die Verwendung der tiefgestellten Notation der beste Weg.

import timeit

timeit.timeit('dictionary = {"karga": 1, "darga": 2}; dictionary.update({"aaa": 123123, "asd": 233})')
>> 0.49582505226135254

timeit.timeit('dictionary = {"karga": 1, "darga": 2}; dictionary["aaa"] = 123123; dictionary["asd"] = 233;')
>> 0.20782899856567383

Wenn Sie jedoch beispielsweise Tausende neuer Schlüssel-Wert-Paare hinzufügen möchten, sollten Sie die Verwendung der update()Methode in Betracht ziehen .

Ich denke, es wäre auch nützlich, auf Pythons collectionsModul hinzuweisen, das aus vielen nützlichen Wörterbuchunterklassen und Wrappern besteht, die das Hinzufügen und Ändern von Datentypen in einem Wörterbuch vereinfachen , insbesondere defaultdict:

dikt Unterklasse, die eine Factory-Funktion aufruft, um fehlende Werte zu liefern

Dies ist besonders nützlich, wenn Sie mit Wörterbüchern arbeiten, die immer aus denselben Datentypen oder Strukturen bestehen, z. B. einem Listenwörterbuch.

>>> from collections import defaultdict
>>> example = defaultdict(int)
>>> example['key'] += 1
>>> example['key']
defaultdict(<class 'int'>, {'key': 1})

Wenn der Schlüssel noch nicht vorhanden ist, defaultdictweist 10er dem Wörterbuch den angegebenen Wert (in unserem Fall ) als Anfangswert zu (häufig in Schleifen verwendet). Diese Operation führt daher zwei Dinge aus: Sie fügt einem Wörterbuch einen neuen Schlüssel hinzu (gemäß Frage) und weist den Wert zu, wenn der Schlüssel noch nicht vorhanden ist. Beim Standardwörterbuch hätte dies einen Fehler ausgelöst, da die +=Operation versucht, auf einen Wert zuzugreifen, der noch nicht vorhanden ist:

>>> example = dict()
>>> example['key'] += 1
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'key'

Ohne die Verwendung von wäre defaultdictdie Menge an Code zum Hinzufügen eines neuen Elements viel größer und sieht möglicherweise ungefähr so ​​aus:

# This type of code would often be inside a loop
if 'key' not in example:
    example['key'] = 0  # add key and initial value to dict; could also be a list
example['key'] += 1  # this is implementing a counter

defaultdictkann auch mit komplexen Datentypen wie listund verwendet werden set:

>>> example = defaultdict(list)
>>> example['key'].append(1)
>>> example
defaultdict(<class 'list'>, {'key': [1]})

Durch Hinzufügen eines Elements wird die Liste automatisch initialisiert.

Hier ist ein anderer Weg, den ich hier nicht gesehen habe:

>>> foo = dict(a=1,b=2)
>>> foo
{'a': 1, 'b': 2}
>>> goo = dict(c=3,**foo)
>>> goo
{'c': 3, 'a': 1, 'b': 2}

Sie können den Wörterbuchkonstruktor und die implizite Erweiterung verwenden, um ein Wörterbuch zu rekonstruieren. Interessanterweise kann diese Methode außerdem verwendet werden, um die Positionsreihenfolge während der Wörterbuchkonstruktion zu steuern ( nach Python 3.6 ). Tatsächlich ist die Einfügereihenfolge für Python 3.7 und höher garantiert!

>>> foo = dict(a=1,b=2,c=3,d=4)
>>> new_dict = {k: v for k, v in list(foo.items())[:2]}
>>> new_dict
{'a': 1, 'b': 2}
>>> new_dict.update(newvalue=99)
>>> new_dict
{'a': 1, 'b': 2, 'newvalue': 99}
>>> new_dict.update({k: v for k, v in list(foo.items())[2:]})
>>> new_dict
{'a': 1, 'b': 2, 'newvalue': 99, 'c': 3, 'd': 4}
>>> 

Das obige verwendet das Wörterbuchverständnis.

Überprüfen Sie zunächst, ob der Schlüssel bereits vorhanden ist

a={1:2,3:4}
a.get(1)
2
a.get(5)
None

Dann können Sie den neuen Schlüssel und Wert hinzufügen

Wörterbuchschlüssel, Wertklasse hinzufügen.

class myDict(dict):

    def __init__(self):
        self = dict()

    def add(self, key, value):
        #self[key] = value # add new key and value overwriting any exiting same key
        if self.get(key)!=None:
            print('key', key, 'already used') # report if key already used
        self.setdefault(key, value) # if key exit do nothing


## example

myd = myDict()
name = "fred"

myd.add('apples',6)
print('\n', myd)
myd.add('bananas',3)
print('\n', myd)
myd.add('jack', 7)
print('\n', myd)
myd.add(name, myd)
print('\n', myd)
myd.add('apples', 23)
print('\n', myd)
myd.add(name, 2)
print(myd)