Как мне добавить новые ключи в словарь?

avatar
lfaraone
21 июня 2009 в 22:07
4398867
23
3093

Можно ли добавить ключ в словарь Python после его создания?

Похоже, здесь нет метода .add().

Источник
cs95
19 декабря 2018 в 13:17
48

Если вы здесь пытаетесь выяснить, как добавить ключ и вернуть новый словарь , вы можете сделать это на python3.5 +: {**mydict, 'new_key': new_val}.

Ol' Dawg
7 января 2020 в 19:32
0

Либо используйте принятый ответ: d ['mynewkey'] = 'mynewvalue', либо вы можете использовать val = d.setdefault ('mynewkey', 'mynewvalue')

Jyotirmay Kumar Jha
30 декабря 2020 в 05:23
2

Если вы просто используете <dictionary> [<key>] = <value> и если ключ не существует, он будет добавлен автоматически.

Ответы (23)

avatar
Paolo Bergantino
21 июня 2009 в 22:09
3954

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

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

d['mynewkey'] = 'mynewvalue'

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

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

hegash
16 января 2019 в 19:14
19

В чем разница между этим методом и методом .update()? Что лучше когда?

bgusach
13 февраля 2019 в 08:38
23

@hegash синтаксис d[key]=val, поскольку он короче и может обрабатывать любой объект в качестве ключа (пока он хешируемый) и устанавливает только одно значение, тогда как .update(key1=val1, key2=val2) лучше, если вы хотите установить несколько значений одновременно , пока ключи являются строками (поскольку kwargs преобразуются в строки). dict.update также может использовать другой словарь, но я лично предпочитаю не создавать новый словарь явно для обновления другого.

Juan-Kabbali
28 апреля 2020 в 12:55
0

как я могу добавить элемент во вложенный dict. Как php $foo[ ] = [ . . . . ]

Selfcontrol7
1 февраля 2021 в 10:26
0

Пожалуйста, кто-нибудь может объяснить разницу между этим ответом и append () i.n: a dict ["a"]. Append ("привет")

Kots
25 февраля 2021 в 09:19
1

Основываясь на If it exists, the current value it points to is overwritten., как я могу элегантно проверить, существует ли уже ключ, на который я пытаюсь добавить информацию, а затем вызвать исключение?

Łukasz Kwieciński
1 августа 2021 в 20:41
0

@ Selfcontrol7 append - это не метод dict, это метод для списков, он добавляет значение в конец списка.

avatar
Shlok Sharma
23 января 2022 в 21:08
1

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

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

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

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

my_dictionary["key1"] = "value1_revised"
avatar
Franz Kurt
28 декабря 2021 в 21:12
3

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

Учитывая:

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

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

dictionary['newkey'] = 'newvalue'

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

dictionary.update({'newkey':'newvalue'})
avatar
cs95
2 октября 2021 в 02:27
8

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

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

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

.

питон >= 3,5

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

питон <3.5

new_dict = dict(mydict, new_key=new_val)

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

avatar
Pobaranchuk
31 августа 2021 в 13:20
14

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

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

    my_dict = {}
    my_dict['key'] = 'value'
    
  2. Используйте метод update()

    my_dict = {}
    my_dict.update({'key': 'value'})
    
avatar
Abhimanyu Sharma
16 апреля 2021 в 05:18
3

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

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

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

my_another_dict = {"key": "value"}
my_dict = {}
my_dict.update(my_another_dict)
avatar
Odiljon Djamalov
18 января 2021 в 20:34
1
your_dict = {}

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

  1. your_dict[key]=value

  2. your_dict.update(key=value)

avatar
Irfan wani
13 января 2021 в 11:16
3

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

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

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

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

Boris
12 февраля 2021 в 09:13
3

это сработало и в 2001 году!

Irfan wani
12 февраля 2021 в 09:40
0

Просто хотел прояснить, что время от времени многое меняется, особенно в программировании.

WestCoastProjects
24 февраля 2021 в 15:54
0

Ирфан, вы идете против условностей, заявляя «в 2021 году»: в SOF принято говорить это только в том случае, если все действительно отличается от прошлого.

Irfan wani
24 февраля 2021 в 16:11
0

Убрал строчку. И извините за это.

avatar
Susan
4 февраля 2020 в 01:47
2

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

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)
avatar
ingyhere
19 ноября 2019 в 04:57
6

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

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

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

avatar
m_____z
27 августа 2019 в 21:21
3

Я думаю, что было бы также полезно указать на модуль 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]})

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

avatar
Agus Mathew
25 марта 2019 в 13:01
4

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

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

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

avatar
Burak Özdemir
11 октября 2018 в 08:57
7

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

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

avatar
campeterson
12 января 2018 в 19:31
23

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

campeterson
30 января 2018 в 17:05
3

В длительном разговоре с моим коллегой по функциональному программированию был поднят хороший момент. Одним из недостатков описанного выше подхода является то, что если кто-то, читающий код, не знаком с ** в Python (многие не знакомы), тогда не будет очевидно, что происходит. Бывают случаи, когда вы предпочитаете менее функциональный подход для лучшей читаемости.

Gabriel
7 марта 2018 в 20:56
6

Мы не можем предвидеть, какое подмножество языка Python знают наши читатели, поэтому справедливо предположить, что они знают весь язык и ищут в документации части, которых не знают.

avatar
Michael Ekoka
23 октября 2017 в 14:03
21

Есть также странное название, странное поведение, но все же удобный 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
avatar
Aaron Hall
29 ноября 2014 в 23:57
161

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

holdenweb
5 февраля 2020 в 13:41
1

В 2020 году разница будет гораздо менее заметной (на моей машине нижние индексы 1,35 мс против 2 мс для d.__setitem__), хотя вывод (и особенно последнее предложение) остается верным. Выведение поиска имени метода из цикла сократило время примерно до 1,65 мс; остающаяся разница, вероятно, в значительной степени связана с неизбежными накладными расходами на механизм вызова Python.

avatar
Brent Bradburn
17 августа 2013 в 23:04
33

Этот популярный вопрос касается функциональных методов объединения словарей 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' )
Brent Bradburn
17 августа 2013 в 23:09
8

Интересный комментарий о первом методе из Python BDFL (здесь).

holdenweb
5 февраля 2020 в 13:51
1

c = dict( a, **{'d':'dog'} ) лучше было бы записать как c = dict(a, d='dog'), если ключи известны и не вычисляются.

avatar
kiriloff
25 мая 2013 в 13:33
40

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

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}
avatar
Colonel Panic
14 апреля 2013 в 00:58
53

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

d.__setitem__(key, value)

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

Bobort
27 октября 2016 в 14:10
22

Мне было бы чрезвычайно сложно программировать на python без клавиш-скобок на клавиатуре.

chris stevens
18 мая 2018 в 13:29
2

Это был единственный способ установить значения словаря в понимании списка. Спасибо

Jeremy Logan
13 сентября 2018 в 22:45
3

@chrisstevens, если вы хотите установить значение в понимании, я использовал хак [a for a in my_dict if my_dict.update({'a': 1}) is None].

Aleister Tanek Javas Mraz
13 августа 2019 в 16:47
0

Любопытно ... это обычное явление (например, отсутствие квадратных скобок)?

ingyhere
20 января 2020 в 16:22
0

@chrisstevens @JeremyLogan Зачем использовать понимание списка, если вы можете использовать понимание dict? {v: k for k, v in my_dict.items() if <some_conditional_check>}

avatar
Asher
26 апреля 2012 в 19:04
60

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

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

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

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

Erik Kaplun
1 июня 2012 в 21:05
15

это не имеет отношения к заданному вопросу, как и большинство комментариев на страницах руководства php.net ...

Chris
27 декабря 2017 в 16:07
2

Ничто не мешает вам сделать это в одной строке: dictionary = {"dictionary_within_a_dictionary": {"sub_dict": {"other" : "dictionary"}}} (или, если dictionary уже является dict, dictionary["dictionary_within_a_dictionary"] = {"sub_dict": {"other" : "dictionary"}})

avatar
Yugal Jindle
5 декабря 2011 в 06:07
1140

Я хочу собрать информацию о словарях 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))
WestCoastProjects
24 февраля 2021 в 15:56
0

Оператор «ИЛИ» | в 3.9, по-видимому, решает мою проблему с dicts python, не имеющими шаблона построителя.

kdb
28 июля 2021 в 07:55
0

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

avatar
user142911
22 июля 2009 в 14:48
1162

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

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

Jean-François Fabre♦
1 августа 2018 в 21:42
18

это оооочень неэффективно создавать словарь только для обновления одного ключа. Делайте это, только если у вас более 1 ключа (может быть порог, выше которого лучше создать dict)

Robert Brisita
27 марта 2019 в 05:59
17

@ Jean-FrançoisFabre Это пример кода. Вы действительно не должны рассматривать ответы как охватывающие все случаи.

Jean-François Fabre♦
27 марта 2019 в 06:14
1

это создает неправильное впечатление, что это предпочтительный способ добавления одного ключа.

ingyhere
20 января 2020 в 16:10
0

@ Jean-FrançoisFabre Поскольку порядок диктовок гарантирован в Python 3.7+ (и предоставляется в 3.6+), это вполне может быть предпочтительным способом добавления одного ключа, когда порядок важен .

Jean-François Fabre♦
20 января 2020 в 16:26
0

если вы создадите другой ключ, например x[-1] = 44, значение -1 тоже будет в конце. В любом случае ответ отредактирован и теперь намного лучше. Обновление с помощью словаря хорошо, когда вероятно, что он содержит много элементов.

avatar
Jason Creighton
21 июня 2009 в 22:08
108
dictionary[key] = value