адресов этот популярный вопрос функциональные методы слияния словарей a и b.

Вот некоторые из наиболее простых методов (протестированных в 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() )

Примечание. Первый метод, описанный выше, работает, только если ключи в b являются строками.

Чтобы добавить или изменить один элемент , словарь b будет содержать только этот один элемент ...

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

Это эквивалентно ...

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

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

Так много ответов, и все еще забыли о странном имени, странном поведении, и все же под рукой dict.setdefault()

Этот

value = my_dict.setdefault(key, default)

В основном просто делает это:

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

Например

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

Если вы не объединяете два словаря, а добавляете новые пары ключ-значение в словарь, то использование записи нижнего индекса кажется наилучшим способом.

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

Однако, если вы хотите добавить, например, тысячи новых пар ключ-значение, вам следует рассмотреть возможность использования метода update().

Я чувствую, что собираю информацию о словарях Python:

Создание пустого словаря

data = {}
# OR
data = dict()

Создание словаря с начальными значениями

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

Вставка / Обновление одного значения

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)

Вставка / Обновление нескольких значений

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

Создание объединенного словаря без изменения оригиналов

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

Удаление элементов в словаре

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

Проверьте, есть ли ключ в словаре

key in data

Итерация по парам в словаре

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

Создать словарь из двух списков

data = dict(zip(list_with_keys, list_with_values))

Новое в Python 3

Создание объединенного словаря без изменения оригиналов

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

Не стесняйтесь добавлять больше!

Вы можете создать один:

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)

Дает :

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

Добавить ключ словаря, значение класса.

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)

Если вы хотите добавить словарь в словарь, вы можете сделать это следующим образом.

Пример: добавление новой записи в ваш словарь и под словарь

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

ПРИМЕЧАНИЕ. Python требует, чтобы вы сначала добавили подпункт

dictionary["dictionary_within_a_dictionary"] = {}

Перед добавлением записей.

Сначала проверить, существует ли ключ

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

Затем вы можете добавить новый ключ и значение

dict = {'key1':'geeks', 'key2':'for'} 
print("Current Dict is: ", dict) 

# adding key3 
dict.update({'key3':'geeks'}) 
print("Updated Dict is: ", dict) 

# adding dict1 (key4 and key5) to dict 
dict1 = {'key4':'is', 'key5':'fabulous'} 
dict.update(dict1) 
print(dict) 

# by assigning 
dict.update(newkey1 ='portal') 
print(dict) 

Чтобы добавить несколько ключей одновременно, используйте 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}

Для добавления одного ключа принятый ответ имеет меньше вычислительных затрат.

Вот еще один способ, который я не видел здесь:

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

Вы можете использовать конструктор словаря и неявное расширение, чтобы восстановить словарь. Более того, интересно, что этот метод может использоваться для управления позиционным порядком во время создания словаря (опубликовать Python 3.6). Фактически, порядок вставки гарантирован для Python 3.7 и выше!

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

Я думаю, что было бы также полезно указать на Python: collections , который состоит из множества полезных подклассов и оболочек словаря, которые упрощают добавление и изменение типов данных в словаре , в частности defaultdict :

подкласс dict, который вызывает фабричную функцию для предоставления пропущенных значений

Это особенно полезно, если вы работаете со словарями, которые всегда состоят из одних и тех же типов данных или структур, например словаря списков.

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

Если ключ еще не существует, defaultdict присваивает данное значение (в нашем случае 10) как начальное значение словарю (часто используется внутри циклов). Поэтому эта операция выполняет две вещи: она добавляет новый ключ в словарь (в соответствии с вопросом), и присваивает значение, если ключ еще не существует. С помощью стандартный словарь, это вызвало бы ошибку, поскольку операция += пытается получить доступ к значению, которое еще не существует:

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

Без использования defaultdict объем кода для добавления нового элемента был бы намного больше и, возможно, выглядит примерно так:

# 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 также можно использовать со сложными типами данных, такими как list и set:

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

Добавление элемента автоматически инициализирует список.

Давайте представим, что вы хотите жить в неизменном мире и НЕ хотите изменять оригинал, но хотите создать новый dict, который является результатом добавления нового ключа к оригиналу.

В Python 3.5+ вы можете делать:

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

Эквивалент Python 2:

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

После любого из них:

params по-прежнему равен {'a': 1, 'b': 2}

И

new_params равен {'a': 1, 'b': 2, 'c': 3}

Будут времена, когда вы не захотите изменять оригинал (вам нужен только результат добавления к оригиналу). Я считаю, что это отличная альтернатива следующему:

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

Или

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

Ссылка: https://stackoverflow.com/a/2255892/514866

Ортодоксальный синтаксис: d[key] = value, но если на вашей клавиатуре отсутствуют клавиши в квадратных скобках, вы можете сделать следующее:

d.__setitem__(key, value)

Фактически, определяя методы __getitem__ и __setitem__, вы можете заставить свой собственный класс поддерживать синтаксис в квадратных скобках. См. https://python.developpez.com/cours/DiveInP PHP / endiveintopython / object_oriented_framework / special_class_methods.php

«Можно ли добавить ключ в словарь Python после того, как он был создан? Кажется, у него нет метода .add ()».

Да, это возможно, и у него есть метод, который реализует это, но вы не хотите использовать его напрямую.

Чтобы продемонстрировать, как и как его не использовать, давайте создадим пустой dict с литералом dict {}:

my_dict = {}

Лучшая практика 1: индексная запись

Чтобы обновить этот диктовку одним новым ключом и значением, вы можете использовать запись с нижним индексом (см. Сопоставления здесь), которая предусматривает назначение элементов:

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

my_dict сейчас:

{'new key': 'new value'}

Лучшая практика 2: метод update - 2 способа

Мы также можем эффективно обновить dict несколькими значениями, используя метод update . Возможно, мы излишне создаем здесь дополнительный dict, поэтому мы надеемся, что наш dict уже был создан и получен или использовался для других целей:

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

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

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

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

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