Is het mogelijk om een sleutel toe te voegen aan een Python-woordenboek nadat het is gemaakt?
Het lijkt geen .add() methode te hebben.
Antwoord 1, autoriteit 100%
U maakt een nieuw sleutel/waarde-paar in een woordenboek door een waarde aan die sleutel toe te kennen
d = {'key': 'value'}
print(d) # {'key': 'value'}
d['mynewkey'] = 'mynewvalue'
print(d) # {'key': 'value', 'mynewkey': 'mynewvalue'}
Als de sleutel niet bestaat, wordt deze toegevoegd en verwijst naar die waarde. Als het bestaat, wordt de huidige waarde waarnaar het verwijst overschreven.
Antwoord 2, autoriteit 29%
Als u meerdere sleutels tegelijk wilt toevoegen, gebruikt u 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}
Voor het toevoegen van een enkele sleutel heeft het geaccepteerde antwoord minder rekenkundige overhead.
Antwoord 3, autoriteit 29%
Ik heb zin om informatie over Python-woordenboeken te consolideren:
Een leeg woordenboek maken
data = {}
# OR
data = dict()
Een woordenboek maken met beginwaarden
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))}
Een enkele waarde invoegen/bijwerken
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)
Meerdere waarden invoegen/bijwerken
data.update({'c':3,'d':4}) # Updates 'c' and adds 'd'
Python 3.9+:
De update-operator |= werkt nu voor woordenboeken:
data |= {'c':3,'d':4}
Een samengevoegd woordenboek maken zonder de originelen te wijzigen
data3 = {}
data3.update(data) # Modifies data3, not data
data3.update(data2) # Modifies data3, not data2
Python 3.5+:
Dit gebruikt een nieuwe functie genaamd woordenboek uitpakken.
data = {**data1, **data2, **data3}
Python 3.9+:
De samenvoegoperator | werkt nu voor woordenboeken:
data = data1 | {'c':3,'d':4}
Items in woordenboek verwijderen
del data[key] # Removes specific element in a dictionary
data.pop(key) # Removes the key & returns the value
data.clear() # Clears entire dictionary
Controleer of een sleutel al in het woordenboek staat
key in data
Herhaal door paren in een woordenboek
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
Maak een woordenboek van twee lijsten
data = dict(zip(list_with_keys, list_with_values))
Antwoord 4, autoriteit 4%
"Is het mogelijk om een sleutel toe te voegen aan een Python-woordenboek nadat het is gemaakt? Het lijkt geen .add() methode te hebben."
Ja, het is mogelijk, en het heeft een methode die dit implementeert, maar je wilt het niet direct gebruiken.
Om te demonstreren hoe en hoe het niet te gebruiken, laten we een leeg dictaat maken met het letterlijke dict, {}:
my_dict = {}
Best Practice 1: Subscriptnotatie
Als je dit dictaat wilt bijwerken met een enkele nieuwe sleutel en waarde, kun je de subscriptnotatie (zie Mappings hier) die voorziet in itemtoewijzing:
my_dict['new key'] = 'new value'
my_dict is nu:
{'new key': 'new value'}
Best Practice 2: De update-methode – 2 manieren
We kunnen het dictaat ook efficiënt bijwerken met meerdere waarden met behulp van de update methode. Mogelijk maken we hier onnodig een extra dict aan, dus we hopen dat ons dict al is gemaakt en afkomstig is van of is gebruikt voor een ander doel:
my_dict.update({'key 2': 'value 2', 'key 3': 'value 3'})
my_dict is nu:
{'key 2': 'value 2', 'key 3': 'value 3', 'new key': 'new value'}
Een andere efficiënte manier om dit te doen met de update-methode is met trefwoordargumenten, maar aangezien het legitieme pythonwoorden moeten zijn, mag je geen spaties of speciale symbolen gebruiken of de naam beginnen met een nummer, maar velen beschouwen dit als een leesbare manier om sleutels voor een dictaat te maken, en hier vermijden we zeker het maken van een extra onnodig dict:
my_dict.update(foo='bar', foo2='baz')
en my_dict is nu:
{'key 2': 'value 2', 'key 3': 'value 3', 'new key': 'new value',
'foo': 'bar', 'foo2': 'baz'}
Dus nu hebben we drie Pythonische manieren besproken om een dict bij te werken.
Magische methode, __setitem__, en waarom deze moet worden vermeden
Er is een andere manier om een dict bij te werken die u niet zou moeten gebruiken, en die gebruikt de __setitem__ methode. Hier is een voorbeeld van hoe men de __setitem__ methode zou kunnen gebruiken om een sleutel-waardepaar toe te voegen aan een dict, en een demonstratie van de slechte prestaties van het gebruik ervan:
>>> 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
We zien dus dat het gebruik van de subscript-notatie eigenlijk veel sneller is dan het gebruik van __setitem__. Het Pythonic-ding doen, dat wil zeggen, de taal gebruiken op de manier waarop het bedoeld was om te worden gebruikt, is meestal zowel leesbaarder als rekenkundig efficiënter.
Antwoord 5, autoriteit 3%
dictionary[key] = value
Antwoord 6, autoriteit 2%
Als u een woordenboek aan een woordenboek wilt toevoegen, kunt u dat op deze manier doen.
Voorbeeld: voeg een nieuw item toe aan uw woordenboek & subwoordenboek
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)
Uitvoer:
{'new key': 'some new entry', 'dictionary_within_a_dictionary': {'sub_dict': {'other': 'dictionarly'}}}
OPMERKING: Python vereist dat je eerst een sub toevoegt
dictionary["dictionary_within_a_dictionary"] = {}
voordat u items toevoegt.
Antwoord 7
De conventionele syntaxis is d[key] = value, maar als uw toetsenbord de vierkante haakjestoetsen mist, kunt u ook het volgende doen:
d.__setitem__(key, value)
In feite is het definiëren van de methoden __getitem__ en __setitem__ hoe u ervoor kunt zorgen dat uw eigen klasse de syntaxis van vierkante haakjes ondersteunt. Zie Dive Into Python, 5.6. Speciale lesmethoden.
Antwoord 8
U kunt er een maken:
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)
Geeft:
>>>
{'apples': 6, 'bananas': 3}
Antwoord 9
Deze populaire vraag adresseert functionele methoden voor het samenvoegen van woordenboeken a en b.
Hier zijn enkele van de meer rechttoe rechtaan methoden (getest 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() )
Opmerking: de eerste methode hierboven werkt alleen als de toetsen in b strings zijn.
Als u een enkel element wilt toevoegen of wijzigen, zou het woordenboek b alleen dat ene element bevatten…
c = dict( a, **{'d':'dog'} ) ## returns a dictionary based on 'a'
Dit komt overeen met…
def functional_dict_add( dictionary, key, value ):
temp = dictionary.copy()
temp[key] = value
return temp
c = functional_dict_add( a, 'd', 'dog' )
Antwoord 10
Laten we doen alsof u in de onveranderlijke wereld wilt leven en niet het origineel wilt wijzigen, maar een nieuw dict wilt maken dat het resultaat is van het toevoegen van een nieuwe sleutel tot het origineel.
In Python 3.5+ kun je het volgende doen:
params = {'a': 1, 'b': 2}
new_params = {**params, **{'c': 3}}
Het equivalent van Python 2 is:
params = {'a': 1, 'b': 2}
new_params = dict(params, **{'c': 3})
Na een van deze:
params is nog steeds gelijk aan {'a': 1, 'b': 2}
en
new_params is gelijk aan {'a': 1, 'b': 2, 'c': 3}
Er zullen momenten zijn waarop u het origineel niet wilt wijzigen (u wilt alleen het resultaat van het toevoegen aan het origineel). Ik vind dit een verfrissend alternatief voor het volgende:
params = {'a': 1, 'b': 2}
new_params = params.copy()
new_params['c'] = 3
of
params = {'a': 1, 'b': 2}
new_params = params.copy()
new_params.update({'c': 3})
Referentie: Wat betekent `* *` betekenen in de uitdrukking `dict(d1, **d2)`?
Antwoord 11
Er is ook de vreemd genoemde, vreemd gedragen en toch handige dict.setdefault().
Dit
value = my_dict.setdefault(key, default)
doet eigenlijk gewoon dit:
try:
value = my_dict[key]
except KeyError: # key not found
value = my_dict[key] = default
Bijvoorbeeld,
>>> 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
Antwoord 12
Als u niet twee woordenboeken samenvoegt, maar nieuwe sleutel-waardeparen aan een woordenboek toevoegt, lijkt het gebruik van de subscriptnotatie de beste manier.
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
Als u echter bijvoorbeeld duizenden nieuwe sleutel-waardeparen wilt toevoegen, kunt u overwegen de methode update() te gebruiken.
Antwoord 13
Hier is nog een manier die ik hier niet heb gezien:
>>> foo = dict(a=1,b=2)
>>> foo
{'a': 1, 'b': 2}
>>> goo = dict(c=3,**foo)
>>> goo
{'c': 3, 'a': 1, 'b': 2}
U kunt de woordenboekconstructor en impliciete uitbreiding gebruiken om een woordenboek te reconstrueren. Bovendien is het interessant dat deze methode kan worden gebruikt om de positievolgorde te bepalen tijdens het bouwen van woordenboeken (post Python 3.6). In feite is de invoegvolgorde gegarandeerd voor Python 3.7 en hoger!
>>> 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}
>>>
Het bovenstaande maakt gebruik van woordenboekbegrip.
Antwoord 14
Eerst controleren of de sleutel al bestaat:
a={1:2,3:4}
a.get(1)
2
a.get(5)
None
Vervolgens kunt u de nieuwe sleutel en waarde toevoegen.
Antwoord 15
Ik denk dat het ook nuttig zou zijn om te wijzen op de collections module die bestaat uit veel handige woordenboeksubklassen en wrappers die het toevoegen en wijzigen van gegevenstypen in een woordenboek vereenvoudigen, met name defaultdict:
dict subklasse die een fabrieksfunctie aanroept om ontbrekende waarden op te geven
Dit is vooral handig als u werkt met woordenboeken die altijd uit dezelfde gegevenstypen of structuren bestaan, bijvoorbeeld een woordenboek met lijsten.
>>> from collections import defaultdict
>>> example = defaultdict(int)
>>> example['key'] += 1
>>> example['key']
defaultdict(<class 'int'>, {'key': 1})
Als de sleutel nog niet bestaat, wijst defaultdict de gegeven waarde (in ons geval 10) toe als de beginwaarde aan het woordenboek (vaak gebruikt in lussen). Deze bewerking doet dus twee dingen: het voegt een nieuwe sleutel toe aan een woordenboek (volgens vraag), en wijst de waarde toe als de sleutel nog niet bestaat. Met de standaardwoordenboek, zou dit een fout hebben opgeleverd omdat de bewerking += probeert toegang te krijgen tot een waarde die nog niet bestaat:
>>> example = dict()
>>> example['key'] += 1
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: 'key'
Zonder het gebruik van defaultdict, zou de hoeveelheid code om een nieuw element toe te voegen veel groter zijn en er misschien ongeveer zo uitzien:
# 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 kan ook worden gebruikt met complexe gegevenstypen zoals list en set:
>>> example = defaultdict(list)
>>> example['key'].append(1)
>>> example
defaultdict(<class 'list'>, {'key': [1]})
Als je een element toevoegt, wordt de lijst automatisch geïnitialiseerd.
Antwoord 16
Hier is een gemakkelijke manier!
your_dict = {}
your_dict['someKey'] = 'someValue'
Hierdoor wordt een nieuw key: value-paar toegevoegd aan het your_dict-woordenboek met key = someKey en value = somevalue
Je kunt deze manier ook gebruiken om de waarde van de sleutel somekey bij te werken als die al bestaat in de your_dict.
Antwoord 17
Voeg een woordenboek (key,value) klasse toe.
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)
Antwoord 18
U kunt vierkante haken gebruiken:
my_dict = {}
my_dict["key"] = "value"
Of je kunt de .update() methode gebruiken:
my_another_dict = {"key": "value"}
my_dict = {}
my_dict.update(my_another_dict)
Antwoord 19
your_dict = {}
Een nieuwe sleutel toevoegen:
-
your_dict[key]=value -
your_dict.update(key=value)