Вы можете создать новую пару "ключ-значение" следующим образом:

my_dictionary = {"key1" : "value1"}
my_dictionary["key2"] = "value2"

Чтобы изменить "ключ1" или "значение2", вы можете сделать то же самое, например:

my_dictionary = {"key1" : "value1"}
my_dictionary["key2"] = "value2"

my_dictionary["key1"] = "value1_revised"

В классе dict существует метод обновления, который должен вам подойти.

Учитывая:

# dictionary = {"key":"value"}

Но без какого-либо метода вы можете добавить ключ, просто создав новое значение, как в строке ниже:

dictionary['newkey'] = 'newvalue'

или используя обновление https://www.python.org/dev/peps/pep-0584/#dict-update

dictionary.update({'newkey':'newvalue'})

На этот вопрос уже был дан ответ до отвращения, но так как мой комментарий набрал обороты, вот как ответ:

Добавление новых ключей без обновления существующего словаря

Если вы здесь пытаетесь выяснить, как добавить ключ и вернуть новый словарь (без изменения существующего), вы можете сделать это, используя приведенные ниже методы

питон >= 3,5

new_dict = {**mydict, 'new_key': new_val}

питон <3.5

new_dict = dict(mydict, new_key=new_val)

Обратите внимание, что при таком подходе ваш ключ должен будет соответствовать правилам действительных имен идентификаторов в python.

Существует два способа обновления словаря:

1. Используйте обозначение в квадратных скобках ([])

   my_dict = {}
   my_dict['key'] = 'value'
   

2. Используйте метод update()

   my_dict = {}
   my_dict.update({'key': 'value'})
   

Можно использовать квадратные скобки:

my_dict = {}
my_dict["key"] = "value"

Или вы можете использовать метод .update () :

my_another_dict = {"key": "value"}
my_dict = {}
my_dict.update(my_another_dict)

your_dict = {}

Чтобы добавить новый ключ:

1. your_dict[key]=value

2. your_dict.update(key=value)

Вот простой способ!

your_dict = {}
your_dict['someKey'] = 'someValue'

Это добавит новую пару key: value в словарь your_dict с key = someKey и value = somevalue

Вы также можете использовать этот способ для обновления значения ключа somekey, если он уже существует в your_dict.

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

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)

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

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

Вышеупомянутое использует понимание словаря.

Я думаю, что было бы также полезно указать на модуль Python collections , который состоит из множества полезных подклассов словаря и оберток, которые упрощают <392176087895 типы в словаре , в частности 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]})

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

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

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

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

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

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

Давайте представим, что вы хотите жить в неизменном мире и не хотите изменить оригинал, а хотите создать новый 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})

Ссылка: Что означает `**` в выражении `dict (d1, ** d2)`?

Есть также странное название, странное поведение, но все же удобный 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

«Можно ли добавить ключ в словарь 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'})

my_dict сейчас:

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

Еще один эффективный способ сделать это с помощью метода обновления - использовать аргументы ключевого слова, но поскольку они должны быть законными словами Python, у вас не может быть пробелов или специальных символов или начинать имя с числа, но многие считают это более читаемый способ создания ключей для dict, и здесь мы, конечно, избегаем создания лишних ненужных dict:

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

и my_dict сейчас:

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

Итак, теперь мы рассмотрели три питонических способа обновления dict.

Магический метод, __setitem__, и почему его следует избегать

Есть другой способ обновления dict, который вам не следует использовать, который использует метод __setitem__. Вот пример того, как можно использовать метод __setitem__ для добавления пары ключ-значение к dict, и демонстрация низкой производительности его использования:

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

Итак, мы видим, что использование нижнего индекса на самом деле намного быстрее, чем использование __setitem__. Выполнение вещей Pythonic, то есть использование языка так, как он был предназначен для использования, обычно является более читаемым и более эффективным с точки зрения вычислений.

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

Вот некоторые из наиболее простых методов (протестированных в Python 3) ...

c = dict( a, **b ) ## see also https://coderhelper.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' )

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

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}

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

d.__setitem__(key, value)

Фактически, определение методов __getitem__ и __setitem__ - это то, как вы можете заставить ваш собственный класс поддерживать синтаксис квадратных скобок. См. Dive Into Python, 5.6. Методы специального класса .

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

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

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

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

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

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

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

dictionary[key] = value