13 Pytanie: Dodaj nowe klucze do słownika?

pytanie utworzone w Fri, May 3, 2019 12:00 AM

Czy możliwe jest dodanie klucza do słownika Pythona po jego utworzeniu? Wydaje się, że nie ma metody .add().

    
2293
  1. Jeśli próbujesz dowiedzieć się, jak dodać klucz i zwróć nowy słownik, możesz zrób to w python3.5 +: {**mydict, 'new_key': new_val}.
    2018-12-19 13: 17: 10Z
13 odpowiedzi                              13                         
 
d = {'key':'value'}
print(d)
# {'key': 'value'}
d['mynewkey'] = 'mynewvalue'
print(d)
# {'mynewkey': 'mynewvalue', 'key': 'value'}
    
3009
2019-01-04 13: 44: 21Z
  1. Wyjaśnienie jest następujące: tworzysz nową parę kluczy w słowniku, przypisując wartość do tego klucza. Jeśli klucz nie istnieje, jest dodawany i wskazuje tę wartość. Jeśli istnieje, bieżąca wartość, na którą wskazuje, jest nadpisywana.
    2018-05-31 01: 22: 07Z
  2. Jaka jest różnica między tą a metodą .update()? Co jest lepsze, gdy?
    2019-01-16 19: 14: 17Z
  3. @ unieważnij składnię d[key]=val, ponieważ jest krótsza i może obsłużyć dowolny obiekt jako klucz (tak długo, jak jest to możliwe) i ustawia tylko jedną wartość, podczas gdy .update(key1=val1, key2=val2) jest ładniejszy jeśli chcesz ustawić wiele wartości w tym samym czasie, o ile klucze są łańcuchami (ponieważ kwargs są konwertowane na łańcuchy). dict.update może również pobrać inny słownik, ale osobiście wolę nie tworzyć jawnie nowego słownika, aby zaktualizować inny.
    2019-02-13 08: 38: 56Z

Aby dodać wiele kluczy jednocześnie:

 
>>> 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}

Aby dodać pojedynczy klucz, zaakceptowana odpowiedź ma mniejszy narzut obliczeniowy.

    
947
2019-04-26 19: 47: 22Z
  1. to jest tak nieefektywne, aby utworzyć słownik, aby zaktualizować jeden klucz. Zrób to tylko wtedy, gdy masz więcej niż 1 klucz (może istnieć próg, powyżej którego lepiej jest utworzyć dict)
    2018-08-01 21: 42: 49Z
  2. @ Jean-FrançoisFabre To jest przykładowy kod. Naprawdę nie powinieneś traktować odpowiedzi jako obejmujących wszystkie przypadki.
    2019-03-27 05: 59: 04Z
  3. daje złe wrażenie, że jest to preferowany sposób dodania jednego klucza.
    2019-03-27 06: 14: 36Z

Mam ochotę konsolidować informacje o słownikach Pythona:

Tworzenie pustego słownika

 
data = {}
# OR
data = dict()

Tworzenie słownika z wartościami początkowymi

 
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))}

Wstawianie /aktualizowanie pojedynczej wartości

 
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)

Wstawianie /aktualizowanie wielu wartości

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

Tworzenie połączonego słownika bez modyfikowania oryginałów

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

Usuwanie elementów w słowniku

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

Sprawdź, czy klucz jest już w słowniku

 
key in data

Iteruj przez pary w słowniku

 
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

Utwórz słownik z 2 list

 
data = dict(zip(list_with_keys, list_with_values))

Możesz dodać więcej!

    
800
2018-05-11 19: 28: 30Z
  1. Z python 3.5 możesz również utworzyć połączony słownik w następujący sposób: data3 = {**data1, **data2}.
    2019-02-12 10: 41: 43Z
  

"Czy możliwe jest dodanie klucza do słownika Pythona po jego utworzeniu? Wydaje się, że nie ma on metody .add ()."

Tak, jest to możliwe i ma metodę, która to implementuje, ale nie chcesz go używać bezpośrednio.

Aby zademonstrować, jak i jak z niego nie korzystać, utwórzmy pusty dyktat z literałem Dict, {}:

 
my_dict = {}

Najlepsza praktyka 1: notacja indeksu

Aby zaktualizować ten dykt za pomocą jednego nowego klucza i wartości, możesz użyć notacja indeksu (patrz tutaj Mapowania) , która zapewnia przypisanie pozycji:

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

my_dict jest teraz:

 
{'new key': 'new value'}

Najlepsza praktyka 2: Metoda update - 2 sposoby

Możemy również zaktualizować dyktat z wieloma wartościami efektywnie, używając metody update . Możemy niepotrzebnie tworzyć dodatkowe dict tutaj, więc mamy nadzieję, że nasz dict został już utworzony i pochodzi z lub został użyty w innym celu:

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

my_dict jest teraz:

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

Innym skutecznym sposobem na zrobienie tego za pomocą metody aktualizacji jest użycie argumentów słów kluczowych, ale ponieważ muszą to być prawdziwe słowa Pythona, nie możesz mieć spacji ani specjalnych symboli ani zaczynać nazwy od liczby, ale wielu uważa to za bardziej czytelny sposób tworzenia kluczy dla dyktatu, a tutaj na pewno unikniemy tworzenia niepotrzebnego dict:

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

i my_dict to teraz:

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

Więc teraz omówiliśmy trzy Pythonicowe sposoby aktualizacji dict.


Metoda magiczna, __setitem__ i dlaczego należy jej unikać

Jest inny sposób aktualizacji dict, którego nie powinieneś używać, który używa metody __setitem__. Oto przykład, w jaki sposób można użyć metody __setitem__, aby dodać parę klucz-wartość do dict i wykazać słabą wydajność jej używania:

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

Widzimy więc, że użycie notacji indeksu jest znacznie szybsze niż użycie __setitem__. Wykonywanie rzeczy w Pythonie, czyli używanie języka w taki sposób, w jaki był przeznaczony, jest zwykle bardziej czytelne i wydajne obliczeniowo.

    
127
2016-06-17 11: 28: 41Z
 
dictionary[key] = value
    
82
2009-06-21 22: 08: 57Z

Jeśli chcesz dodać słownik w słowniku, możesz to zrobić w ten sposób.

Przykład: dodaj nowy wpis do słownika i amp; sub-słownik

 
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)

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

UWAGA: Python wymaga dodania subskrypcji

 
dictionary["dictionary_within_a_dictionary"] = {}

przed dodaniem wpisów.

    
51
2017-11-10 20: 38: 16Z
  1. to jest tak samo nieistotne dla pytania, jak większość komentarzy na stronach podręcznika php.net ...
    2012-06-01 21: 05: 40Z
  2. Nic, co powstrzyma cię przed zrobieniem tego w jednej linii: dictionary = {"dictionary_within_a_dictionary": {"sub_dict": {"other" : "dictionary"}}} (lub jeśli dictionary jest już dyktatem, dictionary["dictionary_within_a_dictionary"] = {"sub_dict": {"other" : "dictionary"}})
    2017-12-27 16: 07: 22Z

Ortodoksyjna składnia to d[key] = value, ale jeśli na klawiaturze brakuje kwadratowych klawiszy nawiasów, możesz to zrobić:

 
d.__setitem__(key, value)

W rzeczywistości definiowanie metod __getitem__ i __setitem__ polega na tym, jak możesz stworzyć własną klasę obsługującą składnię nawiasów kwadratowych. Zobacz https://python.developpez.com/cours/DiveIntoPython/php/endiveintopython/object_oriented_framework/special_class_methods.php

    
36
2019-06-02 09: 01: 03Z
  1. Bardzo trudno byłoby mi programować za pomocą Pythona bez klawiszy na mojej klawiaturze.
    2016-10-27 14: 10: 02Z
  2. Lub większość języków programowania, gdy mamy do czynienia z tablicami ...
    2017-12-08 03: 33: 31Z
  3. To był jedyny sposób, aby znaleźć wartości słownika w rozumieniu listy. Dzięki
    2018-05-18 13: 29: 31Z
  4. @ chrisstevens, jeśli chcesz ustawić wartość w zrozumieniu, użyty przeze mnie hack to [a for a in my_dict if my_dict.update({'a': 1}) is None].
    2018-09-13 22: 45: 39Z

możesz go utworzyć

 
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)

daje

 
>>> 
{'apples': 6, 'bananas': 3}
    
30
2013-05-25 13: 33: 35Z

To popularne pytanie adresuje funkcjonalne metody łączenia słowników a i b.

Oto niektóre z bardziej prostych metod (testowanych w Pythonie 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() )

Uwaga: Pierwsza z powyższych metod działa tylko wtedy, gdy klucze b są łańcuchami.

Aby dodać lub zmodyfikować pojedynczy element , słownik b będzie zawierał tylko jeden element ...

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

To jest równoważne ...

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

c = functional_dict_add( a, 'd', 'dog' )
    
30
2017-05-23 11: 55: 01Z
  1. Ciekawe komentarze na temat pierwszej metody z BDFL Pythona ( tutaj ).
    2013-08-17 23: 09: 03Z

Załóżmy, że chcesz żyć w niezmiennym świecie i NIE chcesz modyfikować oryginału, ale chcesz utworzyć nowy dict, który jest wynikiem dodania nowego klucza do oryginału.

W Pythonie 3.5+ możesz:

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

Odpowiednikiem Pythona 2 jest:

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

Po jednej z tych opcji:

params jest wciąż równe {'a': 1, 'b': 2}

i

new_params jest równe {'a': 1, 'b': 2, 'c': 3}

Będą chwile, kiedy nie chcesz modyfikować oryginału (chcesz tylko wynik dodania do oryginału). Uważam to za odświeżającą alternatywę dla następujących rzeczy:

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

lub

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

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

    
18
2018-01-12 19: 31: 53Z
  1. W długiej rozmowie z moim pro-funkcjonalnym kolegą programistycznym podniesiono dobry punkt. Jedynym minusem powyższego podejścia jest to, że jeśli ktoś czytający kod nie jest zaznajomiony z ** w Pythonie (wielu nie jest), to nie będzie oczywiste, co się dzieje. Są chwile, kiedy preferujesz mniej funkcjonalne podejście do lepszej czytelności.
    2018-01-30 17: 05: 21Z
  2. Nie możemy przewidzieć, który podzbiór języka Python nasi czytelnicy kteraz, więc uczciwie jest założyć, że znają cały język, więc przeszukują dokumenty w poszukiwaniu części, których nie mają.
    2018-03-07 20: 56: 41Z

Tak wiele odpowiedzi i wciąż wszyscy zapomnieli o dziwnie nazwanym, dziwnie zachowanym, a jednak wciąż przydatnym dict.setdefault()

To

 
value = my_dict.setdefault(key, default)

po prostu to robi:

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

np.

 
>>> 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
    
12
2017-10-23 14: 03: 24Z

Jeśli nie łączysz dwóch słowników, ale dodajesz nowe pary klucz-wartość do słownika, wtedy użycie notacji subskrypcyjnej wydaje się najlepszym sposobem.

 
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

Jeśli jednak chcesz dodać na przykład tysiące nowych par klucz-wartość, powinieneś rozważyć użycie metody update().

    
3
2018-10-11 09: 03: 32Z

najpierw, aby sprawdzić, czy klucz już istnieje

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

możesz wtedy dodać nowy klucz i wartość

    
0
2019-03-25 13: 01: 25Z
źródło umieszczone tutaj