Bir Python sözlüğüne oluşturulduktan sonra bir anahtar eklemek mümkün müdür?

Bir .add()yöntemi yok gibi görünüyor .

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

Aynı anda birden fazla anahtar eklemek için şunu kullanın 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}

Tek bir anahtar eklemek için, kabul edilen cevabın daha az hesaplama yükü vardır.

Python sözlükleri hakkındaki bilgileri pekiştirmek istiyorum:

Boş bir sözlük oluşturma

data = {}
# OR
data = dict()

Başlangıç ​​değerleriyle sözlük oluşturma

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

Tek bir değer Ekleme / Güncelleme

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)

Birden çok değer ekleme / güncelleme

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

Orijinalleri değiştirmeden birleştirilmiş sözlük oluşturma

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

Sözlükteki öğeleri silme

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

Bir anahtarın sözlükte olup olmadığını kontrol edin

key in data

Sözlükteki çiftler arasında yineleme

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

İki listeden sözlük oluşturma

data = dict(zip(list_with_keys, list_with_values))

Python 3.5'te yeni

Orijinalleri değiştirmeden birleştirilmiş sözlük oluşturma:

Bu, sözlük açma denen yeni bir özellik kullanır .

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

Python 3.9 sürümündeki yenilikler

Mevcut bir sözlüğün değerlerini güncelleme veya ekleme

Güncelleştirme operatör |= şimdi sözlüklere çalışır:

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

Orijinalleri değiştirmeden birleştirilmiş sözlük oluşturma

Birleştirme operatörü | şimdi sözlüklere çalışır:

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

Daha fazlasını eklemek için çekinmeyin!

"Bir Python sözlüğüne oluşturulduktan sonra anahtar eklemek mümkün mü? .Add () yöntemi yok gibi görünüyor."

Evet mümkündür ve bunu uygulayan bir yöntemi vardır, ancak doğrudan kullanmak istemezsiniz.

Nasıl ve nasıl kullanılacağını göstermek için, dikte değişmeziyle boş bir diksiyon oluşturalım {}:

my_dict = {}

En İyi Uygulama 1: Alt simge gösterimi

Bu dikdörtgeni tek bir yeni anahtar ve değerle güncellemek için, öğe atamasını sağlayan alt simge gösterimini (bkz. Burada Eşlemeler) kullanabilirsiniz:

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

my_dict şimdi:

{'new key': 'new value'}

En İyi Uygulama 2: updateYöntem - 2 yol

Yöntemi kullanarak daupdate dikteyi birden çok değerle verimli bir şekilde güncelleyebiliriz . Gereksiz yere dictburada fazladan bir şeyler yaratıyor olabiliriz , bu yüzden umarım dictdaha önce yaratılmış ve başka bir amaçla kullanılmış veya başka bir amaçla kullanılmıştır:

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

my_dict şimdi:

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

Bunu güncelleme yöntemiyle yapmanın bir başka etkili yolu anahtar kelime argümanlarıdır, ancak meşru python kelimeleri olması gerektiğinden, boşluklara veya özel sembollere sahip olamaz veya adı bir sayı ile başlatamazsınız, ancak birçoğu bunu daha okunabilir bir yol olarak düşünemezsiniz. bir diksiyon için anahtarlar oluşturmak için ve burada kesinlikle gereksiz bir şey yaratmaktan kaçınırız dict:

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

ve my_dictşimdi:

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

Bu yüzden şimdi a'yı güncellemenin üç Pitonik yolunu ele aldık dict.

Sihirli yöntem __setitem__ve neden kaçınılması gerektiği

Kullanmamanız gereken bir yöntemi güncellemenin başka bir yolu var dict, bu da __setitem__yöntemi kullanıyor . Aşağıda, __setitem__bir anahtar / değer çiftini bir anahtar / değer çiftini eklemek için nasıl kullanabileceğinin bir örneği ve dictbunu kullanmanın düşük performansının bir örneği verilmiştir :

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

Dolayısıyla, alt simge notasyonunu kullanmanın aslında kullanmaktan çok daha hızlı olduğunu görüyoruz __setitem__. Pitonik şeyi yapmak, yani dili kullanılması amaçlanan şekilde kullanmak, genellikle hem daha okunabilir hem de hesaplama açısından etkilidir.

dictionary[key] = value

Bir sözlük içine sözlük eklemek isterseniz, bunu sözlükte yapabilirsiniz.

Örnek: Sözlüğünüze ve alt sözlüğünüze yeni bir giriş ekleyin

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)

Çıktı:

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

Not: Python önce bir alt eklemek gerekir

dictionary["dictionary_within_a_dictionary"] = {}

giriş eklemeden önce.

Ortodoks sözdizimi d[key] = value, ancak klavyenizde köşeli ayraç tuşları yoksa şunları yapabilirsiniz:

d.__setitem__(key, value)

Aslında, tanımlama __getitem__ve __setitem__yöntemler kendi sınıfınızı köşeli parantez sözdizimini nasıl destekleyeceğinizdir. Bkz. Https://python.developpez.com/cours/DiveIntoPython/php/endiveintopython/object_oriented_framework/special_class_methods.php

Bir tane oluşturabilirsiniz:

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)

verir:

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

Bu popüler soru adresleri fonksiyonel sözlükleri birleştirme yöntemleri ave b.

İşte daha basit yöntemlerden bazıları (Python 3'te test edilmiştir) ...

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

Not: Yukarıdaki ilk yöntem yalnızca içindeki anahtarlar bdizgiyse çalışır.

Tek bir öğe eklemek veya değiştirmek için bsözlükte yalnızca bir öğe bulunur ...

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

Bu eşdeğerdir ...

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

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

Değişmez dünyada yaşamak istediğinizi ve orijinali değiştirmek istemediğinizi, ancak orijinaline dictyeni bir anahtar eklemenin sonucu olan yeni bir tane oluşturmak istediğinizi varsayalım .

Python 3.5+ ile şunları yapabilirsiniz:

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

Python 2 eşdeğeri:

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

Bunlardan herhangi birinden sonra:

params hala eşit {'a': 1, 'b': 2}

ve

new_params eşittir {'a': 1, 'b': 2, 'c': 3}

Orijinali değiştirmek istemediğiniz zamanlar olacaktır (yalnızca orijinaline eklemenin sonucunu istiyorsunuz). Bunu aşağıdakilere ferahlatıcı bir alternatif olarak görüyorum:

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

veya

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

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

Pek çok cevap ve hala herkes garip bir şekilde adlandırılmış, garip davranmış ve yine de kullanışlı dict.setdefault()

Bu

value = my_dict.setdefault(key, default)

temelde sadece bunu yapar:

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

Örneğin

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

İki sözlüğe katılmıyorsanız, ancak bir sözlüğe yeni anahtar / değer çiftleri ekliyorsanız, alt simge notasyonunu kullanmak en iyi yol gibi görünür.

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

Ancak, örneğin binlerce yeni anahtar / değer çifti eklemek istiyorsanız, update()yöntemi kullanmayı düşünmelisiniz .

Ayrıca , özellikle bir sözlükte veri türlerinin eklenmesini ve değiştirilmesinicollections basitleştiren birçok yararlı sözlük alt sınıfı ve paketleyiciden oluşan Python'un modülünü belirtmenin yararlı olacağını düşünüyorum :defaultdict

eksik değerleri sağlamak için fabrika işlevini çağıran dict alt sınıfı

Bu, her zaman aynı veri türlerinden veya yapılardan, örneğin bir liste sözlüğünden oluşan sözlüklerle çalışıyorsanız özellikle yararlıdır.

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

Anahtar henüz mevcut değilse, defaultdictverilen değeri (bizim durumumuzda 10) sözlüğe başlangıç ​​değeri olarak atar (genellikle döngülerin içinde kullanılır). Dolayısıyla bu işlem iki şey yapar: sözlüğe yeni bir anahtar ekler (soru başına) ve anahtar henüz yoksa değeri atar. Standart sözlükte, +=işlem henüz var olmayan bir değere erişmeye çalıştığından bu bir hataya neden olur:

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

Kullanılmadan, defaultdictyeni bir öğe eklemek için kod miktarı çok daha büyük olacaktır ve belki de şöyle görünecektir:

# 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

defaultdictlistve gibi karmaşık veri türleriyle de kullanılabilir set:

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

Bir eleman eklemek listeyi otomatik olarak başlatır.

İşte burada görmediğim başka bir yol:

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

Bir sözlüğü yeniden oluşturmak için sözlük yapıcısını ve örtülü genişletmeyi kullanabilirsiniz. Dahası, ilginç bir şekilde, bu yöntem sözlük oluşturma sırasında pozisyon sırasını kontrol etmek için kullanılabilir ( post Python 3.6 ). Aslında, Python 3.7 ve üstü için ekleme emri garanti edilir!

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

Yukarıdaki sözlük anlama kullanır.

önce anahtarın zaten var olup olmadığını kontrol edin

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

sonra yeni anahtarı ve değeri ekleyebilirsiniz

sözlük anahtarı, değer sınıfı ekle.

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)