Apakah mungkin untuk menambahkan kunci ke kamus Python setelah dibuat?

Tampaknya tidak memiliki .add()metode.

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

Untuk menambahkan beberapa tombol secara bersamaan, gunakan 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}

Untuk menambahkan satu kunci, jawaban yang diterima memiliki overhead komputasi yang lebih sedikit.

Saya merasa ingin menggabungkan info tentang kamus Python:

Membuat kamus kosong

data = {}
# OR
data = dict()

Membuat kamus dengan nilai awal

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

Memasukkan / Memperbarui nilai tunggal

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)

Memasukkan / Memperbarui beberapa nilai

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

Membuat kamus yang digabungkan tanpa mengubah yang asli

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

Menghapus item dalam kamus

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

Periksa apakah kunci sudah ada dalam kamus

key in data

Ulangi pasangan dalam kamus

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

Buat kamus dari dua daftar

data = dict(zip(list_with_keys, list_with_values))

Baru menggunakan Python 3.5

Membuat kamus yang digabungkan tanpa mengubah yang asli:

Ini menggunakan fitur baru yang disebut kamus membongkar .

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

Baru menggunakan Python 3.9

Perbarui atau tambahkan nilai untuk kamus yang ada

The Operator pembaruan |= sekarang bekerja untuk kamus:

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

Membuat kamus yang digabungkan tanpa mengubah yang asli

The Operator merge | sekarang bekerja untuk kamus:

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

Jangan ragu untuk menambahkan lebih banyak!

"Apakah mungkin untuk menambahkan kunci ke kamus Python setelah dibuat? Tampaknya tidak memiliki metode .add ()."

Ya itu mungkin, dan memang ada metode yang mengimplementasikan ini, tetapi Anda tidak ingin menggunakannya secara langsung.

Untuk menunjukkan bagaimana dan bagaimana untuk tidak menggunakannya, mari kita membuat dict kosong dengan literal dict, {}:

my_dict = {}

Praktik Terbaik 1: Notasi subskrip

Untuk memperbarui dict ini dengan satu kunci dan nilai baru, Anda dapat menggunakan notasi subskrip (lihat Pemetaan di sini) yang menyediakan penugasan item:

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

my_dict sekarang:

{'new key': 'new value'}

Praktik Terbaik 2: updateMetode - 2 cara

Kami juga dapat memperbarui dict dengan beberapa nilai efisien serta menggunakan yang updatemetode . Kami mungkin tidak perlu membuat ekstra di dictsini, jadi kami berharap kami dicttelah dibuat dan berasal dari atau digunakan untuk tujuan lain:

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

my_dict sekarang:

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

Cara efisien lain untuk melakukan ini dengan metode pembaruan adalah dengan argumen kata kunci, tetapi karena kata-kata itu harus kata python yang sah, Anda tidak dapat memiliki spasi atau simbol khusus atau memulai nama dengan angka, tetapi banyak yang menganggap ini cara yang lebih mudah dibaca untuk membuat kunci untuk dict, dan di sini kita tentu saja menghindari membuat yang tidak perlu dict:

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

dan my_dictsekarang:

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

Jadi sekarang kita telah membahas tiga cara Pythonic untuk memperbarui dict.

Metode ajaib __setitem__,, dan mengapa itu harus dihindari

Ada cara lain untuk memperbarui dictyang tidak boleh Anda gunakan, yang menggunakan __setitem__metode ini. Berikut adalah contoh bagaimana seseorang dapat menggunakan __setitem__metode ini untuk menambahkan pasangan nilai kunci ke a dict, dan demonstrasi dari buruknya kinerja menggunakannya:

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

Jadi kita melihat bahwa menggunakan notasi subskrip sebenarnya jauh lebih cepat daripada menggunakan __setitem__. Melakukan hal Pythonic, yaitu, menggunakan bahasa seperti yang dimaksudkan untuk digunakan, biasanya keduanya lebih mudah dibaca dan efisien secara komputasi.

dictionary[key] = value

Jika Anda ingin menambahkan kamus di dalam kamus, Anda dapat melakukannya dengan cara ini.

Contoh: Tambahkan entri baru ke kamus & sub kamus Anda

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)

Keluaran:

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

CATATAN: Python mengharuskan Anda pertama kali menambahkan sub

dictionary["dictionary_within_a_dictionary"] = {}

sebelum menambahkan entri.

Sintaks ortodoksnya adalah d[key] = value, tetapi jika keyboard Anda tidak memiliki kunci braket persegi yang dapat Anda lakukan:

d.__setitem__(key, value)

Sebenarnya, mendefinisikan __getitem__dan __setitem__metode adalah bagaimana Anda dapat membuat kelas Anda sendiri mendukung sintaks braket persegi. Lihat https://python.developpez.com/cours/DiveIntoPython/php/endiveintopython/object_oriented_framework/special_class_methods.php

Anda dapat membuatnya:

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)

Memberi:

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

Pertanyaan populer ini membahas metode fungsional penggabungan kamus adan b.

Berikut adalah beberapa metode yang lebih mudah (diuji dengan 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() )

Catatan: Metode pertama di atas hanya berfungsi jika kunci di dalam badalah string.

Untuk menambah atau memodifikasi satu elemen , bkamus hanya akan memuat satu elemen ...

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

Ini setara dengan ...

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

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

Mari kita berpura-pura ingin hidup di dunia yang abadi dan TIDAK ingin memodifikasi yang asli tetapi ingin membuat yang baru dictadalah hasil menambahkan kunci baru ke yang asli.

Dengan Python 3.5+ Anda dapat melakukan:

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

Setara dengan Python 2 adalah:

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

Setelah salah satu dari ini:

params masih sama dengan {'a': 1, 'b': 2}

dan

new_params adalah sama dengan {'a': 1, 'b': 2, 'c': 3}

Akan ada saat-saat ketika Anda tidak ingin memodifikasi yang asli (Anda hanya ingin hasil dari penambahan yang asli). Saya menemukan ini alternatif yang menyegarkan untuk yang berikut:

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

atau

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

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

Begitu banyak jawaban dan masih semua orang lupa tentang nama yang aneh, berperilaku aneh, namun masih berguna dict.setdefault()

Ini

value = my_dict.setdefault(key, default)

pada dasarnya lakukan ini:

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

misalnya

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

Jika Anda tidak bergabung dengan dua kamus, tetapi menambahkan pasangan nilai kunci baru ke kamus, maka menggunakan notasi subskrip sepertinya cara terbaik.

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

Namun, jika Anda ingin menambahkan, misalnya, ribuan pasangan nilai kunci baru, Anda harus mempertimbangkan untuk menggunakan update()metode ini.

Saya pikir itu juga akan berguna untuk menunjukkan collectionsmodul Python yang terdiri dari banyak subkelas kamus yang berguna dan pembungkus yang menyederhanakan penambahan dan modifikasi tipe data dalam kamus , khususnya defaultdict:

subclass dict yang memanggil fungsi pabrik untuk memasok nilai yang hilang

Ini sangat berguna jika Anda bekerja dengan kamus yang selalu terdiri dari tipe atau struktur data yang sama, misalnya kamus daftar.

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

Jika kunci belum ada, defaultdicttetapkan nilai yang diberikan (dalam kasus kami 10) sebagai nilai awal ke kamus (sering digunakan di dalam loop). Oleh karena itu operasi ini melakukan dua hal: menambahkan kunci baru ke kamus (sesuai pertanyaan), dan memberikan nilai jika kunci belum ada. Dengan kamus standar, ini akan menimbulkan kesalahan karena +=operasi mencoba mengakses nilai yang belum ada:

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

Tanpa menggunakan defaultdict, jumlah kode untuk menambahkan elemen baru akan jauh lebih besar dan mungkin terlihat seperti:

# 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

defaultdictjuga dapat digunakan dengan tipe data yang kompleks seperti listdan set:

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

Menambahkan elemen secara otomatis menginisialisasi daftar.

Berikut cara lain yang tidak saya lihat di sini:

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

Anda dapat menggunakan kamus konstruktor dan perluasan implisit untuk merekonstruksi kamus. Selain itu, yang menarik, metode ini dapat digunakan untuk mengontrol urutan posisi selama konstruksi kamus ( post Python 3.6 ). Bahkan, pesanan penyisipan dijamin untuk Python 3.7 ke atas!

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

Di atas menggunakan pemahaman kamus.

pertama untuk memeriksa apakah kunci sudah ada

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

maka Anda dapat menambahkan kunci dan nilai baru

tambahkan kunci kamus, kelas nilai.

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)