Có thể thêm khóa vào từ điển Python sau khi được tạo không?

Nó dường như không có một .add()phương pháp.

d = {'key': 'value'}
print(d)
# {'key': 'value'}
d['mynewkey'] = 'mynewvalue'
print(d)
# {'key': 'value', 'mynewkey': 'mynewvalue'}

Để thêm nhiều khóa cùng lúc, sử dụng 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}

Để thêm một khóa duy nhất, câu trả lời được chấp nhận có ít chi phí tính toán hơn.

Tôi cảm thấy như hợp nhất thông tin về từ điển Python:

Tạo một từ điển trống

data = {}
# OR
data = dict()

Tạo một từ điển với các giá trị ban đầu

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

Chèn / Cập nhật một giá trị

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)

Chèn / Cập nhật nhiều giá trị

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

Tạo một từ điển hợp nhất mà không sửa đổi bản gốc

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

Xóa các mục trong từ điển

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

Kiểm tra xem một khóa đã có trong từ điển

key in data

Lặp lại qua các cặp trong từ điển

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

Tạo một từ điển từ hai danh sách

data = dict(zip(list_with_keys, list_with_values))

Mới dùng Python 3.5

Tạo một từ điển hợp nhất mà không sửa đổi bản gốc:

Điều này sử dụng một featrue mới được gọi là giải nén từ điển .

data = {**data1, **data2, **data3}

Mới đối với Python 3.9

Cập nhật hoặc thêm giá trị cho một từ điển hiện có

Các nhà điều hành bản cập nhật |= hiện đang làm việc cho các từ điển:

data |= {'c':3,'d':4}

Tạo một từ điển hợp nhất mà không sửa đổi bản gốc

Các nhà điều hành hợp nhất | hiện đang làm việc cho các từ điển:

data = data1 | {'c':3,'d':4}

Cư thoải mai thêm vao nưa!

"Có thể thêm khóa vào từ điển Python sau khi nó được tạo không? Nó dường như không có phương thức .add ()."

Vâng, điều đó là có thể, và nó có một phương pháp thực hiện điều này, nhưng bạn không muốn sử dụng nó trực tiếp.

Để giải thích cách thức và cách không sử dụng nó, chúng ta hãy tạo ra một chính tả trống rỗng với nghĩa đen , {}:

my_dict = {}

Thực hành tốt nhất 1: Ký hiệu đăng ký

Để cập nhật dict này với một khóa và giá trị mới duy nhất, bạn có thể sử dụng ký hiệu đăng ký (xem Ánh xạ ở đây) cung cấp cho việc gán vật phẩm:

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

my_dict Hiện tại là:

{'new key': 'new value'}

Cách thực hành tốt nhất 2: updatePhương pháp - 2 cách

Chúng tôi cũng có thể cập nhật dict với nhiều giá trị một cách hiệu quả cũng sử dụng các updatephương pháp . Chúng tôi có thể không cần thiết phải tạo thêm dictở đây, vì vậy chúng tôi hy vọng chúng tôi dictđã được tạo và đến từ hoặc được sử dụng cho mục đích khác:

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

my_dict Hiện tại là:

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

Một cách hiệu quả khác để thực hiện điều này với phương thức cập nhật là với các đối số từ khóa, nhưng vì chúng phải là các từ python hợp pháp, bạn không thể có khoảng trắng hoặc ký hiệu đặc biệt hoặc bắt đầu tên bằng một số, nhưng nhiều người coi đây là cách dễ đọc hơn để tạo khóa cho một lệnh, và ở đây chúng tôi chắc chắn tránh tạo thêm một thứ không cần thiết dict:

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

và my_dictbây giờ là:

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

Vì vậy, bây giờ chúng tôi đã đề cập đến ba cách cập nhật của Pythonic a dict.

Phương pháp ma thuật __setitem__, và tại sao nên tránh

Có một cách khác để cập nhật một cách dictmà bạn không nên sử dụng, đó là sử dụng __setitem__phương pháp này. Dưới đây là một ví dụ về cách người ta có thể sử dụng __setitem__phương thức để thêm cặp khóa-giá trị vào a dictvà minh họa cho hiệu suất sử dụng kém:

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

Vì vậy, chúng tôi thấy rằng việc sử dụng ký hiệu đăng ký thực sự nhanh hơn nhiều so với sử dụng __setitem__. Làm điều Pythonic, nghĩa là sử dụng ngôn ngữ theo cách nó được sử dụng, thường là dễ đọc hơn và hiệu quả tính toán.

dictionary[key] = value

Nếu bạn muốn thêm một từ điển trong một từ điển, bạn có thể làm theo cách này.

Ví dụ: Thêm một mục mới vào từ điển & từ điển phụ của bạn

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)

Đầu ra:

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

LƯU Ý: Python yêu cầu bạn trước tiên thêm phụ

dictionary["dictionary_within_a_dictionary"] = {}

trước khi thêm mục.

Cú pháp chính thống là d[key] = value, nhưng nếu bàn phím của bạn thiếu các phím ngoặc vuông bạn có thể làm:

d.__setitem__(key, value)

Trong thực tế, định nghĩa __getitem__và __setitem__các phương thức là cách bạn có thể làm cho lớp của riêng bạn hỗ trợ cú pháp dấu ngoặc vuông. Xem https://python.developpez.com/cours/DiveIntoPython/php/endiveintopython/object_oriented_framework/special_group_methods.php

Bạn có thể tạo một:

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)

Cung cấp:

>>> 
{'apples': 6, 'bananas': 3}

Câu hỏi phổ biến này giải quyết các phương pháp chức năng của việc hợp nhất từ ​​điển avà b.

Dưới đây là một số phương pháp đơn giản hơn (đã được thử nghiệm trong 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() )

Lưu ý: Phương pháp đầu tiên ở trên chỉ hoạt động nếu các phím trong blà chuỗi.

Để thêm hoặc sửa đổi một phần tử , btừ điển sẽ chỉ chứa một phần tử đó ...

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

Điều này tương đương với ...

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

c = functional_dict_add( a, 'd', 'dog' )

Hãy giả vờ rằng bạn muốn sống trong thế giới bất biến và KHÔNG muốn sửa đổi bản gốc mà muốn tạo một bản mới dict, đó là kết quả của việc thêm khóa mới vào bản gốc.

Trong Python 3.5+ bạn có thể làm:

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

Tương đương Python 2 là:

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

Sau một trong hai điều sau:

params vẫn bằng {'a': 1, 'b': 2}

và

new_params bằng {'a': 1, 'b': 2, 'c': 3}

Sẽ có lúc bạn không muốn sửa đổi bản gốc (bạn chỉ muốn kết quả của việc thêm vào bản gốc). Tôi thấy đây là một sự thay thế mới mẻ cho những điều sau đây:

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

hoặc là

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

Tham khảo: https://stackoverflow.com/a/2255892/514866

Rất nhiều câu trả lời và mọi người vẫn quên mất cái tên kỳ lạ, cư xử kỳ quặc, nhưng vẫn tiện dụng dict.setdefault()

Điều này

value = my_dict.setdefault(key, default)

về cơ bản chỉ làm điều này:

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

ví dụ

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

Nếu bạn không tham gia hai từ điển, nhưng thêm các cặp khóa-giá trị mới vào từ điển, thì sử dụng ký hiệu đăng ký có vẻ là cách tốt nhất.

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

Tuy nhiên, nếu bạn muốn thêm, ví dụ, hàng ngàn cặp khóa-giá trị mới, bạn nên xem xét sử dụng update()phương thức này.

Tôi nghĩ rằng cũng hữu ích khi chỉ ra collectionsmô-đun của Python bao gồm nhiều lớp con và trình bao bọc từ điển hữu ích giúp đơn giản hóa việc thêm và sửa đổi các loại dữ liệu trong từ điển , cụ thể defaultdict:

lớp con dict gọi hàm nhà máy để cung cấp các giá trị bị thiếu

Điều này đặc biệt hữu ích nếu bạn đang làm việc với các từ điển luôn bao gồm các kiểu dữ liệu hoặc cấu trúc giống nhau, ví dụ như một từ điển danh sách.

>>> from collections import defaultdict
>>> example = defaultdict(int)
>>> example['key'] += 1
>>> example['key']
defaultdict(<class 'int'>, {'key': 1})

Nếu khóa chưa tồn tại, defaultdictgán giá trị đã cho (trong trường hợp của chúng tôi 10) làm giá trị ban đầu cho từ điển (thường được sử dụng bên trong các vòng lặp). Do đó, thao tác này thực hiện hai điều: nó thêm khóa mới vào từ điển (theo câu hỏi) và gán giá trị nếu khóa chưa tồn tại. Với từ điển chuẩn, điều này sẽ gây ra lỗi khi +=hoạt động đang cố truy cập vào một giá trị chưa tồn tại:

>>> example = dict()
>>> example['key'] += 1
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'key'

Nếu không sử dụng defaultdict, số lượng mã để thêm một phần tử mới sẽ lớn hơn nhiều và có lẽ trông giống như:

# 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

defaultdictcũng có thể được sử dụng với các loại dữ liệu phức tạp như listvà set:

>>> example = defaultdict(list)
>>> example['key'].append(1)
>>> example
defaultdict(<class 'list'>, {'key': [1]})

Thêm một yếu tố tự động khởi tạo danh sách.

Đây là một cách khác mà tôi đã không thấy ở đây:

>>> foo = dict(a=1,b=2)
>>> foo
{'a': 1, 'b': 2}
>>> goo = dict(c=3,**foo)
>>> goo
{'c': 3, 'a': 1, 'b': 2}

Bạn có thể sử dụng hàm tạo từ điển và mở rộng ngầm để xây dựng lại một từ điển. Hơn nữa, thật thú vị, phương pháp này có thể được sử dụng để kiểm soát thứ tự vị trí trong quá trình xây dựng từ điển ( bài Python 3.6 ). Trong thực tế, thứ tự chèn được đảm bảo cho Python 3.7 trở lên!

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

Trên đây là sử dụng hiểu từ điển.

đầu tiên để kiểm tra xem khóa đã tồn tại chưa

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

sau đó bạn có thể thêm khóa và giá trị mới

thêm khóa từ điển, lớp giá trị.

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)