Wie kann ich einem Wörterbuch neue Schlüssel hinzufügen?

2622

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

Es scheint keine .add()Methode zu haben .

lfaraone
quelle
25
Wenn Sie hier herausfinden möchten , wie Sie einen Schlüssel hinzufügen und ein neues Wörterbuch zurückgeben können, können Sie dies unter python3.5 + tun : {**mydict, 'new_key': new_val}.
CS95
Verwenden Sie entweder die akzeptierte Antwort: d ['mynewkey'] = 'mynewvalue' oder Sie können val = d.setdefault ('mynewkey', 'mynewvalue') verwenden
Ol 'Dawg

Antworten:

3403
d = {'key': 'value'}
print(d)
# {'key': 'value'}
d['mynewkey'] = 'mynewvalue'
print(d)
# {'key': 'value', 'mynewkey': 'mynewvalue'}
Paolo Bergantino
quelle
108
Die Erklärung lautet: Sie erstellen ein neues Schlüssel-Wert-Paar in einem Wörterbuch, indem Sie diesem Schlüssel einen Wert zuweisen. Wenn der Schlüssel nicht vorhanden ist, wird er hinzugefügt und zeigt auf diesen Wert. Wenn es existiert, wird der aktuelle Wert, auf den es zeigt, überschrieben.
R. Navega
9
Was ist der Unterschied zwischen dieser und der .update()Methode? Welches ist besser wann?
Hegash
14
@hegash die d[key]=valSyntax, da sie kürzer ist und jedes Objekt als Schlüssel behandeln kann (solange es hashbar ist) und nur einen Wert festlegt, während dies besser .update(key1=val1, key2=val2)ist, wenn Sie mehrere Werte gleichzeitig festlegen möchten, solange die Schlüssel vorhanden sind sind Strings (da kwargs in Strings konvertiert werden). dict.updatekann auch ein anderes Wörterbuch verwenden, aber ich persönlich bevorzuge es, nicht explizit ein neues Wörterbuch zu erstellen, um ein anderes zu aktualisieren.
Bgusach
Probieren Sie
Sma Ma
Wie kann ich einem verschachtelten Diktat ein Element hinzufügen? Wie PHP$foo[ ] = [ . . . . ]
Juan-Kabbali
1043

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.

Peter Mortensen
quelle
13
Dies ist soooo ineffizient, um ein Wörterbuch zu erstellen, nur um einen Schlüssel zu aktualisieren. Tun Sie dies nur, wenn Sie mehr als 1 Schlüssel haben (es kann einen Schwellenwert geben, über dem es besser ist, ein Diktat zu erstellen)
Jean-François Fabre
10
@ Jean-FrançoisFabre Dies ist ein Beispielcode. Sie sollten Antworten wirklich nicht so behandeln, dass sie alle Fälle abdecken.
Robert Brisita
1
Es entsteht der falsche Eindruck, dass dies der bevorzugte Weg ist, einen Schlüssel hinzuzufügen.
Jean-François Fabre
@ Jean-FrançoisFabre Da die Reihenfolge der Diktate in Python 3.7+ (und in 3.6+) garantiert ist , ist dies möglicherweise eine bevorzugte Methode, um einen einzelnen Schlüssel hinzuzufügen, wenn die Reihenfolge wichtig ist .
Ingyhere
Wenn Sie einen anderen Schlüssel erstellen, ist x[-1] = 44der -1Wert auch am Ende. Wie auch immer, die Antwort wurde bearbeitet und ist jetzt viel besser. Das Aktualisieren mit einem Wörterbuch ist gut, wenn es wahrscheinlich viele Elemente enthält.
Jean-François Fabre
928

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!

Yugal Jindle
quelle
145

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

Aaron Hall
quelle
1
Der Unterschied ist im Jahr 2020 eher weniger ausgeprägt (auf meinem Computer 1,35 ms Abonnement gegenüber 2 ms für d.__setitem__), obwohl die Schlussfolgerung (und insbesondere der letzte Satz) stichhaltig bleibt. Durch das Herausheben der Methodennamensuche aus der Schleife wurde die Zeit auf ca. 1,65 ms reduziert. Der verbleibende Unterschied ist wahrscheinlich größtenteils auf den unvermeidbaren Overhead des Python-Aufrufmechanismus zurückzuführen.
Holdenweb
96
dictionary[key] = value
Jason Creighton
quelle
58

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.

Asher
quelle
13
Dies ist für die gestellte Frage ebenso irrelevant wie die meisten Kommentare auf den Handbuchseiten von php.net ...
Erik Kaplun
2
Nichts hindert Sie daran, dies in einer Zeile zu tun: dictionary = {"dictionary_within_a_dictionary": {"sub_dict": {"other" : "dictionary"}}}(oder wenn dictionaryes bereits ein Diktat ist dictionary["dictionary_within_a_dictionary"] = {"sub_dict": {"other" : "dictionary"}})
Chris
43

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

Oberst Panik
quelle
16
Ich würde es extrem schwierig finden, mit Python ohne die Klammertasten auf meiner Tastatur zu programmieren.
Bobort
2
Dies war die einzige Möglichkeit, Wörterbuchwerte innerhalb eines Listenverständnisses festzulegen. Danke
Chris Stevens
3
@chrisstevens Wenn Sie einen Wert in einem Verständnis festlegen möchten, ist ein Hack, den ich verwendet habe [a for a in my_dict if my_dict.update({'a': 1}) is None].
Jeremy Logan
Neugierig ... ist dies (dh fehlende eckige Klammern) üblich?
Aleister Tanek Javas Mraz
@chrisstevens @JeremyLogan Warum ein Listenverständnis verwenden, wenn Sie ein Diktatverständnis verwenden können? {v: k for k, v in my_dict.items() if <some_conditional_check>}
Ingyhere
36

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}
kiriloff
quelle
31

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' )
kein Balken
quelle
8
Interessanter Kommentar zur ersten Methode aus Pythons BDFL ( hier ).
Nobar
c = dict( a, **{'d':'dog'} )wäre besser geschrieben als c = dict(a, d='dog'), solange Schlüssel bekannt und nicht berechnet sind.
Holdenweb
21

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

Campeterson
quelle
2
In einem langen Gespräch mit einem meiner pro-funktionalen Programmierkollegen wurde ein guter Punkt angesprochen. Ein Nachteil des obigen Ansatzes ist, dass, wenn jemand, der den Code liest, mit **Python nicht vertraut ist (viele nicht), es nicht offensichtlich ist, was los ist. Es gibt Zeiten, in denen Sie einen weniger funktionalen Ansatz für eine bessere Lesbarkeit bevorzugen.
Campeterson
5
Wir können nicht vorhersehen, welche Teilmenge der Python-Sprache unsere Leser kennen. Es ist daher fair anzunehmen, dass sie die gesamte Sprache kennen, sodass sie in den Dokumenten nach den Teilen suchen, die sie nicht kennen.
Gabriel
17

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
Michael Ekoka
quelle
5

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 .

Burak Özdemir
quelle
3

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.

m_____z
quelle
3

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.

ingyhere
quelle
2

Ü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

Agus Mathew
quelle
0

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