Python добавить в словарь: Добавление новых пар «ключ-значение» в словарь Python

словарь — Как добавить элемент в значение словаря Python?

Вопрос задан 1 год назад

Изменён 3 месяца назад

Просмотрен 2k раза

У меня есть словарь например

d = {'Машина': 'car', 'Мячик': 'ball'}

и я хочу добавить в ключ «Машина» еще одно значение через генератор словарей, чтоб получилось:

'Машина': 'car', 'machine'

• python
• словарь

Всё довольно просто. Тебе нужно вместо одного значения по ключу хранить список. В этом случае есть две ситуации. Когда мы должны только создать этот список и, когда можем уже добавить в него значение.

Выглядит это следующим образом:

if dict.get(key, False) is False:  # если в словаре нет такого ключа
    dict[key] = [value]  # добавляем его и помещает туда список с одним значением
else:  # если такой ключ уже есть
    dict[key].  uppend(value)  # добавляем значение в конец списка

.get — метод словаря, который возвращает значение по ключу, а если его нет, то False (по умолчанию None и это можно даже не указывать, здесь привёл просто для наглядности).

Эту конструкцию можно поместить в цикл, где как раз будут перебираться все значения.

Выше чел написал:

if dict.get(key, False) is False:  # если в словаре нет такого ключа
    dict[key] = [value]  # добавляем его и помещает туда список с одним значением
else:  # если такой ключ уже есть
    dict[key].uppend(value)  # добавляем значение в конец списка

Я проверил, работает код, если внести некоторые правки. Зарегистрировался специально, чтобы об этом написать, но репутации не хватает для того, чтобы прокомментировать его ответ, поэтому пишу свой ответ.

Во-первых, key и value должны быть строками, то есть, в кавычках. Во-вторых, команда, добавляющая элемент в список, append, а не uppend.

dict = {}
if dict.get('key', False) is False:
    dict['key'] = ['value']
else:
    dict['key']. append('value')
print(dict) # {'key': ['value']}
if dict.get('key', False) is False:
    dict['key'] = ['value']
else:
    dict['key'].append('value2')
print(dict) # {'key': ['value', 'value2']}

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

dict = {}
if 'key' not in dict:  # если в словаре нет такого ключа
    dict['key'] = ['value']  # добавляем его и помещает туда список с одним значением
else:  # если такой ключ уже есть
    dict['key'].append('value')  # добавляем значение в конец списка
print(dict) # {'key': ['value']}
if 'key' not in dict:  # если в словаре нет такого ключа
    dict['key'] = ['value']  # добавляем его и помещает туда список с одним значением
else:  # если такой ключ уже есть
    dict['key'].append('value2')  # добавляем значение в конец списка
print(dict)  # {'key': ['value', 'value2']}

1. Структура словаря: {ключ: значение}
2. Ключ в словаре всегда д/б уникален.
3. Если будет добавляться повторяющийся ключ, то старый затерется.
4. В значение можете что-угодно кинуть:

dict_temp = {}
dict2_temp = {1: 123, 2: '321'}
dict_temp['key_1'] = 'значение 1'
dict_temp['key_2'] = ['значение 1', 'значение 2']
dict_temp['key_3'] = (['значение 1', 'значение 2'], dict2_temp)
dict_temp['key_4'] = [key_data for key_data in dict2_temp.keys()]

for key, val in dict_temp.items():
    print( key, ':', val)

Выведет:

key_1 : значение 1
key_2 : ['значение 1', 'значение 2']
key_3 : (['значение 1', 'значение 2'], {1: 123, 2: '321'})
key_4 : [1, 2]

Зарегистрируйтесь или войдите

Отправить без регистрации

Необходима, но никому не показывается

Отправить без регистрации

Необходима, но никому не показывается

By clicking “Отправить ответ”, you agree to our terms of service and acknowledge that you have read and understand our privacy policy and code of conduct.

как работать с dict — гайд для новичков / Skillbox Media

• 6 июн 2023
• 0

Продолжаем осваивать «змеиный» язык. Сегодня поговорим о словарях — важном инструменте для хранения данных в Python.

Дмитрий Зверев

Любитель научной фантастики и технологического прогресса.

Нет, словари нужны не для того, чтобы переводить запутанный код программистов на человеческий. Их используют для того, чтобы удобно хранить данные и быстро получать к ним доступ по запросу. В этой статье подробно разберём, что такое словари и как с ними работать в Python.

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

• Что такое словари
• Как их создавать
• Основные операции

• Достаём значение
• Добавляем новый элемент
• Удаляем ключ
• Изменяем значение

• Методы для работы со словарями

• update()
• get()
• pop()
• keys()
• values()
• items()

• Шпаргалка по синтаксису и методам

Словарь в языках программирования — это что-то вроде телефонной книги, где под каждым номером скрывается какой-то человек.

Только на языке разработчиков номера называют ключами, а людей, которым они принадлежат, — значениями. Вот как это можно представить в виде таблицы:

При этом ключи в словарях уникальны, а значения могут повторяться. Условно говоря, дизайнеру Валере может принадлежать сколько угодно номеров — но у каждого номера может быть только один владелец.

Мы привели пример с телефонной книгой, но вы можете хранить в словаре всё что угодно: названия песен, имена покупателей, товары в интернет-магазине и так далее.

Ключами могут быть строки, числа (целые и дробные) и кортежи. Нельзя использовать списки, словари и другие изменяемые типы данных. В значения можно «положить» любые типы данных — и даже новые словари.

Например, давайте в качестве ключа укажем название книги, а значением сделаем её автора.

Теперь, если у нас есть название книги, мы можем быстро найти её автора. Этим словари и удобны: знаем ключ — моментально получаем значение.

👉 Словарь — это неупорядоченная структура данных. Это значит, что все пары «ключ — значение» хранятся в произвольном порядке. Идея в том, что нам неважно, где находится элемент: в начале, в серединие или в конце. Важно то, что он лежит где-то внутри и мы можем при случае его достать.

Пример упорядоченной структуры — это список. Там у всех элементов есть свои индексы, благодаря которым их можно отсортировать как душе угодно. Если хотите больше знать о списках, читайте другую нашу статью. А мы пойдём дальше — создадим наш первый словарь.

Словари в Python оформляются фигурными скобками. Внутри них находятся пары «ключ — значение». Первым пишется ключ, а затем, через двоеточие, — значение. Сами пары отделяются друг от друга запятыми.

dict = {
  'Гарри Поттер и философский камень' : 'Джоан Роулинг',
  'Убить пересмешника' : 'Харпер Ли'
}

По идее, можно вообще не указывать для ключей никаких значений: язык автоматически подставит вместо них значения None. Но словарь при этом всё равно будет работать.

dict = {
  'Гарри Поттер и философский камень',
  'Убить пересмешника'
}

Выведем на экран содержимое словаря с помощью функции print:

print(dict)
> {'Гарри Поттер и философский камень', 'Убить пересмешника'}

Показались только ключи. Теперь попробуем вывести полноценный словарь со значениями:

dict = {
  'Гарри Поттер и философский камень' : 'Джоан Роулинг',
  'Убить пересмешника' : 'Харпер Ли'
}
print(dict)
> {'Гарри Поттер и философский камень': 'Джоан Роулинг', 'Убить пересмешника': 'Харпер Ли'}

Бинго!

Мало просто создать словарь — иногда нам нужно взаимодействовать с отдельными его элементами. Разберёмся с базовыми операциями.

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

# Создаём словарь
dict = {
  'Гарри Поттер и философский камень' : 'Джоан Роулинг',
  'Убить пересмешника' : 'Харпер Ли'
}
# В квадратных скобках указываем значение
harryPotterAuthor = dict['Гарри Поттер и философский камень']
print(harryPotterAuthor)
# На выходе получаем значение
> Джоан Роулинг

Если указать неправильный ключ, мы получим ошибку:

harryPotterAuthor = dict['Гарри Поттер и драгоценный камень']
print(harryPotterAuthor)
> ERROR!
Traceback (most recent call last):
  File "<string>", line 6, in <module>
KeyError: 'Гарри Поттер и драгоценный камень'

Ошибка говорит нам, что по заданному ключу ничего не нашлось.

Теперь попробуем добавить в наш словарь с книгами ещё одну запись. Чтобы это сделать, в квадратных скобках указываем ключ, а потом, через знак равенства, добавляем значение.

dict['Преступление и наказание'] = 'Фёдор Достоевский'

Пробуем вывести содержимое словаря на экран — видим, что новая запись добавилась в самом конце.

print(dict)
> {'Гарри Поттер и философский камень': 'Джоан Роулинг', 'Убить пересмешника': 'Харпер Ли', 'Преступление и наказание': 'Фёдор Достоевский'}

Готово!

Чтобы удалить элемент из словаря, используют команду del. При этом нам достаточно ввести только ключ, а значение удалится вместе с ним.

del dict['Убить пересмешника']
print(dict)
> {'Гарри Поттер и философский камень': 'Джоан Роулинг'}

Синтаксис немного необычный: мы пишем команду del перед тем, как обратиться к словарю. Но всё прекрасно работает, мы проверили 🙂

Здесь всё просто: в квадратных скобках пишем уже существующий ключ, а через знак равенства указываем новое значение.

dict['Гарри Поттер и философский камень'] = 'Михаил Лермонтов'

Выводим в консоль — видим, что значение первой пары поменялось.

print(dict)
> {'Гарри Поттер и философский камень': 'Михаил Лермонтов', 'Убить пересмешника': 'Харпер Ли'}

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

dict['Барри Воттер и философский камень'] = 'Михаил Лермонтов'
print(dict)
> {'Гарри Поттер и философский камень': 'Джоан Роулинг', 'Убить пересмешника': 'Харпер Ли', 'Барри Воттер и философский камень': 'Михаил Лермонтов'}

Чтобы избежать таких ситуаций, можно использовать безопасный метод get(), о котором мы поговорим в следующем разделе.

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

Что делает: добавляет в словарь одну или сразу несколько пар «ключ — значение».

Как использовать: объявляем метод update(), внутри которого создаём новый словарь из элементов, которыми хотим дополнить существующий.

dict = {
  'Гарри Поттер и философский камень' : 'Джоан Роулинг',
  'Убить пересмешника' : 'Харпер Ли'
}
dict.update({
    'Преступление и наказание' : 'Фёдор Достоевский',
    'Чемодан' : 'Сергей Довлатов'
})
print(dict)
> {'Гарри Поттер и философский камень': 'Джоан Роулинг', 'Убить пересмешника': 'Харпер Ли', 'Преступление и наказание': 'Фёдор Достоевский', 'Чемодан': 'Сергей Довлатов'}

Что делает: возвращает значение из словаря по ключу — или None, если такого ключа не существует.

harryPotterAuthor = dict.get('Гарри Поттер и философский камень')
print(harryPotterAuthor)
> Джоан Роулинг

Попробуем передать ключ, которого нет в словаре:

harryPotterAuthor = dict. get('Гарри Поттер в путешествии по Золотому кольцу России')
print(harryPotterAuthor)
> None

👉 У этого метода есть тайный козырь в рукаве. Вместо сухого и формального None он может вывести любое значение, которое вы захотите, — например, сообщение об ошибке. Для этого надо прописать нужное значение вторым аргументом. Мы решили добавить строчку с ошибкой:

harryPotterAuthor = dict.get('Гарри Поттер в путешествии по Золотому кольцу России', 'Такого ключа нет')
print(harryPotterAuthor)
> Такого ключа нет

В этом состоит главное преимущество метода get() перед обычными квадратными скобками — для обработки ошибок можно не писать объёмные конструкции try/except, а ограничиться всего одной аккуратной строчкой.

Что делает: удаляет элемент из словаря по ключу.

harryPotterAuthor = dict.pop('Гарри Поттер и философский камень')
print(harryPotterAuthor)
> Джоан Роулинг
print(dict)
> {'Убить пересмешника': 'Харпер Ли'}

Что делает: возвращает все ключи из словаря — но без значений.

dictKeys = dict.keys()
print(dictKeys)
>  ['Гарри Поттер и философский камень', 'Убить пересмешника']

Что делает: возвращает все значения из словаря — но без ключей.

dictValues = dict.values()
print(dictValues)
> ['Джоан Роулинг', 'Харпер Ли'] 

Что делает: возвращает все пары «ключ — значение».

dictItems = dict.items()
print(dictItems)
> [('Гарри Поттер и философский камень', 'Джоан Роулинг'), ('Убить пересмешника', 'Харпер Ли')]

Лучше не заучивать голую теорию, а сразу отрабатывать знания на практике. Начать можно, например, с бесплатных упражнений на w3schools.com. А чтобы быстро находить нужный метод и не ходить каждый раз в гугл, можете сохранить себе шпаргалку по ссылке или таблицу ниже.

Метод	Что делает
clear()	Удаляет все элементы из словаря
copy()	Создаёт копию словаря
update()	Добавляет в словарь одну или несколько пар «ключ — значение»
pop()	Удаляет элемент из словаря по ключу
keys()	Возвращает список ключей из словаря
values()	Возвращает список значений из словаря
items()	Возвращает все пары «ключ — значение»
popitem()	Удаляет последнюю добавленную пару «ключ — значение»
get()	Возвращает значение из словаря по ключу — или None, если такого ключа не существует. Можно указать своё значение в качестве второго аргумента
setdefault()	Возвращает значение указанного ключа. Если ключа не существует, создаёт его и добавляет в словарь со значением None или тем, что вы добавите в качестве второго аргумента

Читайте также:

Нейросети вам помогут.

Анонс российских ПК «Бобёр» и «Ворон» на процессорах Intel 11 июл 2023

Медицинский чат‑бот Med‑PaLM 2 от Google запущен в тестирование 10 июл 2023

Google разрешил себе использовать любую информацию в интернете для обучения своего ИИ 07 июл 2023

Понравилась статья?

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

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

 d = {'ключ': 'значение'}
print(d) # {'ключ': 'значение'}
d['mynewkey'] = 'mynewvalue'
print(d) # {'key': 'value', 'mynewkey': 'mynewvalue'}
 

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

Мне хочется объединить информацию о словарях Python:

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

 data = {}
# ИЛИ
данные = дикт()
 

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

 data = {'a': 1, 'b': 2, 'c': 3}
# ИЛИ
данные = дикт (а = 1, б = 2, с = 3)
# ИЛИ
data = {k: v для k, v в (('a', 1), ('b', 2), ('c', 3))}
 

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

 data['a'] = 1 # Обновляет, если существует 'a', иначе добавляет 'a'
# ИЛИ
data.update({'a': 1})
# ИЛИ
data.update (дикт (а = 1))
# ИЛИ
данные.обновление(а=1)
 

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

 data.update({'c':3,'d':4}) # Обновляет 'c' и добавляет 'd'
 

Python 3.9+:

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

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

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

 data3 = {}
data3. update(data) # Изменяет data3, а не data
data3.update(data2) # Изменяет data3, а не data2
 

Python 3.5+:

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

 данные = {**данные1, **данные2, **данные3}
 

Python 3.9+:

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

 data = data1 | {'с':3,'д':4}
 

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

 del data[key] # Удаляет определенный элемент в словаре
data.pop(key) # Удаляет ключ и возвращает значение
data.clear() # Очищает весь словарь
 

Проверка наличия ключа в словаре

 введите данные
 

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

 для ключей в данных: # Итерация только по ключам, игнорируя значения
for key, value в d.items(): # Перебирает пары
for key в d.keys(): # Итерации только по ключу, игнорируя значения
для значения в d.values(): # Итерации только по значению, игнорируя ключи
 

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

 data = dict(zip(list_with_keys, list_with_values))
 

Чтобы добавить несколько ключей одновременно, используйте dict. update() :

 >>> x = {1:2}
>>> напечатать(х)
{1: 2}
>>> д = {3:4, 5:6, 7:8}
>>> х.обновление(г)
>>> напечатать(х)
{1:2, 3:4, 5:6, 7:8}
 

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

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

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

 my_dict = {}
 

Рекомендация 1: Нотация нижнего индекса

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

 my_dict['new key'] = ' новое значение'
 

my_dict теперь:

 {'новый ключ': 'новое значение'}
 

Передовая практика 2:

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

 my_dict.update({'key 2': 'value 2', 'ключ 3': 'значение 3'})
 

my_dict теперь:

 {'ключ 2': 'значение 2', 'ключ 3': 'значение 3', 'новый ключ': 'новое значение'}
 

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

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

и my_dict теперь:

 {'ключ 2': 'значение 2', 'ключ 3': 'значение 3', 'новый ключ': 'новое значение',
 'foo': 'бар', 'foo2': 'баз'}
 

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

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

 >>> d = {}
>>> d.__setitem__('foo', 'bar')
>>> д
{'foo': 'бар'}
>>> защита f():
... д = {}
... для i в xrange (100):
... д['фу'] = я
...
>>> определение g():
... д = {}
... для i в xrange (100):
... d.__setitem__('foo', i)
...
>>> время импорта
>>> число = 100
>>> мин(timeit.repeat(f, число=число))
0,0020880699157714844
>>> мин(timeit.repeat(г, число=число))
0,005071878433227539
 

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

 словарь[ключ] = значение
 

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

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

 словарь = {}
словарь["новый ключ"] = "какая-то новая запись" # добавить новую запись в словарь
словарь["dictionary_within_a_dictionary"] = {} # это требуется для Python
словарь["dictionary_within_a_dictionary"]["sub_dict"] = {"другое" : "словарь"}
распечатать (словарь)
 

Вывод:

 {'новый ключ': 'какая-то новая запись', 'dictionary_within_a_dictionary': {'sub_dict': {'other': 'dictionarly'}}}
 

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

["dictionary_within_a_dictionary"] = {}
 

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

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

 d. __setitem__(key, value)
 

Фактически, определение __getitem__ и __setitem__ — это то, как вы можете заставить свой собственный класс поддерживать синтаксис квадратных скобок. См. Погружение в Python, классы, действующие как словари .

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

 class myDict(dict):
    защита __init__(сам):
        я = дикт()
    def добавить (я, ключ, значение):
        self[ключ] = значение
## пример
myd = мойDict()
myd.add('яблоки',6)
myd.add('бананы',3)
печать (myd)
 

Дает:

 >>>
{'яблоки': 6, 'бананы': 3}
 

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

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

 c = dict( a, **b ) ## см. также https://stackoverflow.com/q/2255878
c = dict(список(a.items()) + список(b.items()))
c = dict( i для d в [a,b] для i в d. items() )
 

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

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

 c = dict( a, **{'d':'dog'} ) ## возвращает словарь на основе «а»
 

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

 def function_dict_add(словарь, ключ, значение):
   темп = словарь.копировать()
   темп[ключ] = значение
   обратная температура
c = function_dict_add(a, 'd', 'собака')
 

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

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

 params = {'a': 1, 'b': 2}
new_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()
новые_параметры['с'] = 3
 

или

 параметры = {'a': 1, 'b': 2}
new_params = params.copy()
new_params.update({'c': 3})
 

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

Есть также странно названный, странно себя ведущий, но все же удобный dict.setdefault() .

Это значение

 = my_dict.setdefault(key, default)
 

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

 попробуйте:
    значение = my_dict[ключ]
кроме KeyError: # ключ не найден
    значение = my_dict[ключ] = по умолчанию
 

Например,

 >>> mydict = {'a':1, 'b':2, 'c':3}
>>> mydict.setdefault('d', 4)
4 # возвращает новое значение в mydict['d']
>>> напечатать (mydict)
{'a':1, 'b':2, 'c':3, 'd':4} # действительно добавлена ​​новая пара ключ/значение
# но посмотрите, что произойдет, если попробовать его на существующем ключе. ..
>>> mydict.setdefault('a', 111)
1 # возвращено старое значение
>>> напечатать (mydict)
{'a':1, 'b':2, 'c':3, 'd':4} # существующий ключ был проигнорирован
 

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

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

Python >= 3.5

 new_dict = {* *mydict, 'новый_ключ': new_val}
 

Python

 new_dict = dict(mydict, new_key=new_val)
 

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

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

 время импорта
timeit. timeit('dictionary = {"karga": 1, "darga": 2}; Dictionary.update({"aaa": 123123, "asd": 233})')
>> 0,49582505226135254
timeit.timeit('dictionary = {"karga": 1, "darga": 2}; словарь["aaa"] = 123123; словарь["asd"] = 233;')
>> 0,20782899856567383
 

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

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

 >>> foo = dict(a=1,b=2)
>>> Фу
{'а': 1, 'б': 2}
>>> goo = dict(c=3,**foo)
>>> слизь
{'с': 3, 'а': 1, 'б': 2}
 

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

 >>> foo = dict(a=1,b=2,c=3,d=4)
>>> new_dict = {k: v вместо k, v в списке (foo. items())[:2]}
>>> новый_дикт
{'а': 1, 'б': 2}
>>> new_dict.update(newvalue=99)
>>> новый_дикт
{'а': 1, 'б': 2, 'новое значение': 99}
>>> new_dict.update({k: v вместо k, v в списке(foo.items())[2:]})
>>> новый_дикт
{'a': 1, 'b': 2, 'новое значение': 99, 'c': 3, 'd': 4}
>>>
 

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

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

 а={1:2,3:4}
получить(1)
2
получить(5)
Никто
 

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

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

 класс myDict(dict):
    защита __init__(сам):
        я = дикт()
    def добавить (я, ключ, значение):
        #self[key] = value # добавить новый ключ и значение, перезаписывающие любой существующий ключ
        если self.get(ключ)!=Нет:
            print('ключ', ключ, 'уже используется') # сообщить, если ключ уже используется
        self.setdefault(key, value) # если клавиша exit ничего не делает
## пример
myd = мойDict()
имя = "Фред"
myd. add('яблоки',6)
печать('\n', мойд)
myd.add('бананы',3)
печать('\n', мойд)
myd.add('джек', 7)
печать('\n', мойд)
myd.add(имя, myd)
печать('\n', мойд)
myd.add('яблоки', 23)
печать('\n', мойд)
myd.add(имя, 2)
печать (myd)
 

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

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

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

 >>> из коллекций импортировать defaultdict
>>> пример = defaultdict(int)
>>> пример['ключ'] += 1
>>> пример['ключ']
defaultdict(<класс 'int'>, {'ключ': 1})
 

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

 >>> example = dict()
>>> пример['ключ'] += 1
Traceback (последний последний вызов):
  Файл "", строка 1, в 
KeyError: 'ключ'
 

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

 # Этот тип кода часто находится внутри цикла
если «ключ» не в примере:
    example['key'] = 0 # добавить ключ и начальное значение в dict; также может быть список
example['key'] += 1 # это реализация счетчика
 

defaultdict также может использоваться со сложными типами данных, такими как list и set :

 >>> example = defaultdict(list)
>>> пример['ключ']. append(1)
>>> пример
defaultdict(<класс 'список'>, {'ключ': [1]})
 

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

 # Вставка/обновление одиночного значения
        # метод записи индекса
        d['mynewkey'] = 'mynewvalue' # Обновляет, если существует 'a', иначе добавляет 'a'
        # ИЛИ
        d.update({'mynewkey': 'mynewvalue'})
        # ИЛИ
        d.update(dict('mynewkey'='mynewvalue'))
        # ИЛИ
        d.update('mynewkey'='mynewvalue')
        print(d) # {'key': 'value', 'mynewkey': 'mynewvalue'}
        # Чтобы добавить/обновить несколько ключей одновременно, используйте d.update():
        х = {3:4, 5:6, 7:8}
        д.обновление(х)
        print(d) # {'key': 'value', 'mynewkey': 'mynewvalue', 3: 4, 5: 6, 7: 8}
        # оператор обновления |= теперь работает со словарями:
        д |= {'с':3,'д':4}
        # Присвоение новой пары ключ-значение с помощью распаковки словаря.
        данные1 = {4:6, 9:10, 17:20}
        данные2 = {20:30, 32:48, 90:100}
        data3 = {38:"значение", 99:"недействительно"}
        г = {**данные1, **данные2, **данные3}
        # Оператор слияния | теперь работает со словарями:
        данные = данные1 | {'с':3,'д':4}
        # Создаем словарь из двух списков
        данные = dict(zip(list_with_keys, list_with_values))
 

Словарь можно обновить на месте с помощью |= и update() также списком кортежей.

 д = {'а': 1}
д |= [('b', 2), ('c', 3)]
# или
d.update([('b', 2), ('c', 3)])
print(d) # {'а': 1, 'б': 2, 'с': 3}
 

|= не только короче, чем update , но и быстрее. Например, если словарь обновляется dict длиной 5, |= почти на 30% быстрее, чем update() (что, в свою очередь, также быстрее, чем цикл) (проверено на Python 3.9.12).

 время импорта
setup = "пары = список (zip (диапазон (5), диапазон (5)))"
t1 = min(timeit.repeat("d={}\nd.update(pairs)", setup)) # 0.41770019999239594
t2 = min(timeit.repeat("d={}\nдля k,v в парах: d[k] = v", setup)) # 0.5213192999945022
t3 = min(timeit.repeat("d={}\nd |= пары", установка)) # 0.3178639999969164
 

Добавление новых ключей во вложенный словарь

Если ключ необходимо добавить в словарь, вложенный в словарь, dict.setdefault (или collections.defaultdict ) действительно полезен. Например, давайте попробуем добавить новую пару ключ-значение в mydict , только вложенную в другой ключ: 'адрес' .

 mydict = {'id': {'id_num': 'xxxx', 'url': 'www.example.com'}}
mydict['address']['work'] = '123 A St' # <---- KeyError: 'address'
 

Тогда желаемый вывод можно получить двумя строками (сначала инициализировав пустой словарь под 'адресом' ):

 mydict['address'] = {}
mydict['address']['work'] = '123 A St' # <---- OK
 

или это можно сделать за один шаг через dict.setdefault() :

 mydict.setdefault('address', {})['work'] = '123 A St' # <---- OK
 

Причина, по которой это работает, заключается в том, что значение по умолчанию пустой dict ( {} ) было передано в .setdefault , поэтому, когда пришло время добавить к нему пару ключ-значение, он уже инициализирован.

Вы можете написать для этого функцию, например:

 def dict_ins( d, key, value ):
    если ключ в d: поднять исключение («Этот ключ уже есть в словаре».)
    д[ключ] = значение
 

dico["новый ключ"] = "значение"

python — добавить словарь к словарю

спросил 11 лет, 5 месяцев назад

Изменено 8 месяцев назад

Просмотрено 941 тысяч раз

У меня есть два существующих словаря, и я хочу "присоединить" один из них к другому. Под этим я подразумеваю, что ключ и значения другого словаря должны быть включены в первый словарь. Например:

 ориг = {
   «А»: 1,
   'БИ 2,
   «С»: 3,
}
дополнительно = {
   «Д»: 4,
   «Э»: 5,
}
dest = # Что-то здесь, связанное с orig и дополнительным
печать назначения
{
   «А»: 1,
   'БИ 2,
   «С»: 3,
   «Д»: 4,
   'Э': 5
}
 

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

• python
• словарь

Можно сделать

 ориг.обновление(доп.)
 

или, если вы не хотите изменять orig , сначала сделайте копию:

 dest = dict(orig) # или orig.copy()
dest.update(дополнительно)
 

Обратите внимание, что если ключи extra и orig перекрываются, окончательное значение будет взято из extra. Например,

 >>> d1 = {1:1, 2:2}
>>> d2 = {2: 'ха!', 3: 3}
>>> d1.update(d2)
>>> д1
{1:1, 2: 'ха!', 3:3}
 

Есть два способа добавить один словарь в другой:

Обновление (изменяет orig на месте)

 orig.update(extra) # Python 2.7+
orig |= дополнительный # Python 3.9+
 

Слияние (создает новый словарь)

 # Python 2.7+
dest = collections.ChainMap (исходное, дополнительное)
dest = {k: v для d в (original, extra) для (k, v) в d.items()}
# Питон 3
назначение = {**оригинал, **дополнительно}
назначение = {**оригинал, 'D': 4, 'E': 5}
# Питон 3.9+
пункт назначения = ориг | дополнительный
 

Предостережения

Обратите внимание, что эти операции некоммутативны. Во всех случаях побеждает последний . Например.

 ориг = {'A': 1, 'B': 2}
экстра = {'A': 3, 'C': 3}
пункт назначения = ориг | дополнительный
# dest = {'A': 3, 'B': 2, 'C': 3}
назначение = дополнительный | ориг
# dest = {'A': 1, 'B': 2, 'C': 3}
 

Также важно отметить, что только из Python 3. 7 (и CPython 3.6) заказываются dict s. Итак, в предыдущих версиях порядок элементов в словаре может отличаться.

dict.update() похоже, он будет делать то, что вы хотите...

 >> orig.update(extra)
>>> ориг
{'A': 1, 'C': 3, 'B': 2, 'E': 5, 'D': 4}
>>>
 

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

 >>> dest = orig.copy()
>>> dest.update(дополнительно)
>>> ориг
{'A': 1, 'C': 3, 'B': 2}
>>> пункт назначения
{'A': 1, 'C': 3, 'B': 2, 'E': 5, 'D': 4}
 

Предполагая, что вы не хотите изменять orig , вы можете либо скопировать и обновить, как и другие ответы, либо создать новый словарь за один шаг, передав все элементы из обоих словарей в конструктор dict:

 из цепочки импорта itertools
dest = dict(chain(orig.items(), extra.items()))
 

Или без itertools:

 dest = dict(list(orig.items()) + list(extra.items()))
 

Обратите внимание, что вам нужно передать только результат items() в list() на Python 3, на 2. x dict.items() уже возвращает список, так что вы можете просто сделать dict(orig.items() + extra.items()) .

В качестве более общего варианта использования, скажем, у вас есть большой список словарей, которые вы хотите объединить в один словарь, вы можете сделать что-то вроде этого:

 из цепочки импорта itertools
dest = dict(chain.from_iterable(map(dict.items, list_of_dicts)))
 

Трехстрочный символ для объединения двух словарей:

 dest = {}
dest.update(оригинал)
dest.update(дополнительно)
 

Это создает новый словарь dest без изменения orig и extra .

Примечание. Если ключ имеет разные значения в orig и extra , то extra имеет приоритет над orig .

Есть метод .update() 🙂

обновление([другое]) Обновите словарь парами ключ/значение из других, перезаписав существующие ключи.

No related posts.