Вы создаете новую пару ключ / значение в словаре, присваивая значение этому ключу.

d = {'key': 'value'}
print(d)  # {'key': 'value'}

d['mynewkey'] = 'mynewvalue'

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

Если ключ не существует, он добавляется и указывает на это значение. Если он существует, текущее значение, на которое он указывает, перезаписывается.

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

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

Я хочу объединить информацию о словарях 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'

Python 3.9+:

оператор обновления |= теперь работает для словарей:

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

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

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

Python 3.5+:

При этом используется новая функция под названием распаковка словаря.

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

Python 3.9+:

оператор слияния | теперь работает для словарей:

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

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

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 после его создания? Похоже, у него нет метода .add ().

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

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

my_dict = {}

Лучшая практика 1. Обозначение нижнего индекса

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

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

my_dict сейчас:

{'new key': 'new value'}

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

Мы также можем эффективно обновить словарь несколькими значениями, используя метод 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

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

Пример: добавить новую запись в словарь и дополнительный словарь

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"] = {}

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

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

d.__setitem__(key, value)

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

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

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}

Этот популярный вопрос касается функциональные методы объединения словарей 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, который является результатом добавления нового ключа к оригиналу.

В 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

or

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

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

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

Этот

value = my_dict.setdefault(key, default)

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

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

e.g.

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

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

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

Вы можете использовать конструктор словаря и неявное расширение для восстановления словаря. Более того, что интересно, этот метод можно использовать для управления позиционным порядком во время построения словаря (post 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}
>>> 

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

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

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

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

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

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

# 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

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