Hinzufügen neuer Schlüssel zu einem Wörterbuch?
Ist es möglich, einem Python Wörterbuch einen Schlüssel hinzuzufügen, nachdem es erstellt wurde? Es scheint keine .add() -Methode zu haben.
d = {'key':'value'}
print(d)
# {'key': 'value'}
d['mynewkey'] = 'mynewvalue'
print(d)
# {'mynewkey': 'mynewvalue', 'key': 'value'}
So fügen Sie mehrere Schlüssel gleichzeitig hinzu:
>>> 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}
Beim Hinzufügen eines einzelnen Schlüssels ist der Rechenaufwand für die akzeptierte Antwort geringer.
Ich möchte Informationen zu Python Wörterbüchern 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 ein Schlüssel bereits im Wörterbuch vorhanden ist
key in data
Durchlaufen Sie Paare in einem Wörterbuch
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 2 Listen
data = dict(Zip(list_with_keys, list_with_values))
Neu in Python3
Erstellen eines zusammengeführten Wörterbuchs ohne Änderung der Originale
data = {**data1, **data2, **data3}
Fühlen Sie sich frei, um mehr hinzuzufügen!
Ja, das ist ziemlich einfach. Mach einfach folgendes:
dict["key"] = "value"
"Ist es möglich, einem Python - Wörterbuch einen Schlüssel hinzuzufügen, nachdem es erstellt wurde? Es scheint keine .add () - Methode zu haben."
Ja, es ist möglich und es gibt eine Methode, die dies implementiert, aber Sie möchten es nicht direkt verwenden.
Erstellen wir ein leeres Diktat mit dem Diktatliteral {}, um zu demonstrieren, wie und wie es nicht verwendet wird:
my_dict = {}
Best Practice 1: Indexnotation
Um dieses Diktat mit einem einzelnen 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 update Methode - 2 Möglichkeiten
Wir können das Diktat auch effizient mit mehreren Werten aktualisieren, indem wir die update -Methode verwenden. Möglicherweise erstellen wir hier unnötigerweise ein zusätzliches dict, daher hoffen wir, dass unser dict bereits erstellt wurde und aus einem anderen Grund 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'}
Ein anderer effizienter Weg, dies mit der update-Methode zu tun, sind Schlüsselwortargumente. Da es sich jedoch um legitime python Wörter handeln muss, können Sie keine Leerzeichen oder Sonderzeichen verwenden oder den Namen mit einer Zahl beginnen, aber mit vielen Betrachten Sie dies als eine besser lesbare Methode zum Erstellen von Schlüsseln für ein Diktat, und vermeiden Sie hier auf jeden Fall das Erstellen eines zusätzlichen unnötigen dict:
my_dict.update(foo='bar', foo2='baz')
und my_dict ist 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 eines dict behandelt.
Magische Methode, __setitem__ und warum es vermieden werden sollte
Es gibt eine andere Möglichkeit, ein dict zu aktualisieren, das Sie nicht verwenden sollten. Dabei wird die __setitem__ -Methode verwendet. Hier ist ein Beispiel dafür, wie man mit der __setitem__ -Methode ein Schlüssel-Wert-Paar zu einem dict hinzufügt, 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 von __setitem__. Das Pythonische zu tun, dh die Sprache so zu verwenden, wie sie verwendet werden sollte, ist in der Regel 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 & 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: Python erfordert, dass 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 Klammertasten fehlen, können Sie Folgendes tun:
d.__setitem__(key, value)
In der Tat können Sie durch Definieren der Methoden __getitem__ und __setitem__ festlegen, dass Ihre eigene Klasse die eckige Klammersyntax 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 adressiert funktionale Methoden zum Zusammenführen von Wörterbüchern a und 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 obige erste Methode funktioniert nur, wenn die Schlüssel in b Zeichenfolgen sind.
Um ein einzelnes Element hinzuzufügen oder zu ändern , würde das b -Lexikon nur dieses eine Element enthalten ...
c = dict( a, **{'d':'dog'} ) ## returns a dictionary based on 'a'
Dies ist gleichbedeutend mit ...
def functional_dict_add( dictionary, key, value ):
temp = dictionary.copy()
temp[key] = value
return temp
c = functional_dict_add( a, 'd', 'dog' )
Angenommen, Sie möchten in der unveränderlichen Welt leben und das Original NICHT ändern, sondern ein neues dict erstellen, 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 ist:
params = {'a': 1, 'b': 2}
new_params = dict(params, **{'c': 3})
Nach diesen beiden:
params ist immer noch gleich {'a': 1, 'b': 2}
und
new_params ist gleich {'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 dies eine erfrischende Alternative zu den folgenden:
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})
So viele Antworten und trotzdem vergaßen alle die seltsam benannten, seltsam benommenen und doch immer noch nützlichen dict.setdefault()
Diese
value = my_dict.setdefault(key, default)
im Grunde macht das einfach:
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
Sie können mit dict.update(Iterable_Sequence of key:value)
Beispiel:
wordFreqDic.update( {'before' : 23} )
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 Methode update() verwenden.
ü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
Ich denke, es wäre auch nützlich, auf Pythons collections Modul hinzuweisen, das aus vielen nützlichen Wörterbuch-Unterklassen und Wrappern besteht, die das vereinfachen Hinzufügen und Ändern von Datentypen in einem Wörterbuch , insbesondere defaultdict :
dict-Unterklasse, die eine Factory-Funktion aufruft, um fehlende Werte bereitzustellen
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, weist defaultdict den angegebenen Wert (in unserem Fall 10) als Anfangswert dem Wörterbuch 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 dies nicht tut existiert noch nicht. Mit dem Standardwörterbuch hätte dies einen Fehler ausgelöst, da die += -Operation versucht, auf einen Wert zuzugreifen, der noch nicht existiert:
>>> example = dict()
>>> example['key'] += 1
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: 'key'
Ohne die Verwendung von defaultdict wäre die Menge an Code zum Hinzufügen eines neuen Elements viel größer und sieht möglicherweise wie folgt 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
defaultdict kann auch mit komplexen Datentypen wie list und set verwendet werden:
>>> example = defaultdict(list)
>>> example['key'].append(1)
>>> example
defaultdict(<class 'list'>, {'key': [1]})
Durch das Hinzufügen eines Elements wird die Liste automatisch initialisiert.