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:
data = {}
# OR
data = dict()
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))}
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)
data.update({'c':3,'d':4}) # Updates 'c' and adds 'd'
data3 = {}
data3.update(data) # Modifies data3, not data
data3.update(data2) # Modifies data3, not data2
del data[key] # Removes specific element in a dictionary
data.pop(key) # Removes the key & returns the value
data.clear() # Clears entire dictionary
key in data
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
data = dict(Zip(list_with_keys, list_with_values))
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 = {}
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'}
update
Methode - 2 MöglichkeitenWir 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.
__setitem__
und warum es vermieden werden sollteEs 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.