Сложить два словаря python

Python: коллекции, часть 3/4: объединение коллекций, добавление и удаление элементов

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

Оглавление:

1. Объединение строк, кортежей, списков, словарей без изменения исходных.
2. Объединение множеств без изменения исходных.
3. Объединение списка, словаря и изменяемого множества с изменением исходной коллекции.
4. Добавление и удаление элементов изменяемых коллекций.
5. Особенности работы с изменяемой и не изменяемой коллекцией.

1. Объединение строк, кортежей, списков, словарей без изменения исходных

Рассмотрим способы объединения строк, кортежей, списков, словарей без изменения исходных коллекций — когда из нескольких коллекций создаётся новая коллекция того же тип без изменения изначальных.

Объединение строк (string) и кортежей (tuple) возможна с использованием оператора сложения «+»

str1 = 'abc' str2 = 'de' str3 = str1 + str2 print(str3) # abcde tuple1 = (1, 2, 3) tuple2 = (4, 5) tuple3 = tuple1 + tuple2 print(tuple3) # (1, 2, 3, 4, 5) 

Добавляем все элементы второго списка к элементам первого, (аналог метод .extend() но без изменения исходного списка):

a = [1, 2, 3] b = [4, 5] c = a + b print(a, b, c) # [1, 2, 3] [4, 5] [1, 2, 3, 4, 5] 

a = [1, 2, 3] b = [4, 5] c = a + [b] print(a, b, c) # [1, 2, 3] [4, 5] [1, 2, 3, [4, 5]] 

a, b = [1, 2, 3], [4, 5] c = [*a, *b] # работает на версии питона 3.5 и выше print(c) # [1, 2, 3, 4, 5]

Сложить два словаря чтобы получить третий оператором + Питон не позволяет «TypeError: unsupported operand type(s) for +: ‘dict’ and ‘dict’».

Это можно сделать по-другому комбинируя методы .copy() и .update():

dict1 = dict2 = dict3 = dict1.copy() dict3.update(dict2) print(dict3) #

В Питоне 3.5 появился новый более изящный способ:

dict1 = dict2 = dict3 = <**dict1, **dict2>print(dict3) #

2. Объединение множеств без изменения исходных

Для обоих типов множеств (set, frozenset) возможны различные варианты комбинации множеств (исходные множества при этом не меняются — возвращается новое множество).

# Зададим исходно два множества (скопировать перед каждым примером ниже) a = b = < 'b', 'c'># отступ перед b для наглядности 

c = a.union(b) # c = b.union(a) даст такой же результат # c = a + b # Обычное объединение оператором + не работает # TypeError: unsupported operand type(s) for +: 'set' and 'set' c = a | b # Альтернативная форма записи объединения print(c) #

c = a.intersection(b) # c = b.intersection(a) даст такой же результат c = a & b # Альтернативная форма записи пересечения print(c) #

a = b = < 'b', 'c'>c = < 'b', 'd'>d = a.intersection(b, c) # Первый вариант записи d = set.intersection(a, b, c) # Второй вариант записи (более наглядный) print(d) #

c = a.difference(b) # c = a - b другой способ записи дающий тот же результат print(c) # c = b.difference(a) # c = b - a другой способ записи дающий тот же результат print(c) #

c = b.symmetric_difference(a) # c = a.symmetric_difference(b) # даст такой же результат c = b ^ a # Альтернативная форма записи симметричной разницы print(c) #

3. Объединение списка, словаря и изменяемого множества с изменением исходной коллекции

Добавляем все элементы второго списка к элементам первого с измением первого списка методом .extend():

a.extend(b) # a += b эквивалентно a.extend(b) print(a, b) # [1, 2, 3, 4, 5] [4, 5] 

 a.append(b) # a += [b] эквивалентно a.append(b) print(a, b) # [1, 2, 3, [4, 5]] [4, 5] 

Обратите внимание: для совпадающих ключей словаря при этом обновляются значения:

dict1 = dict2 = dict1.update(dict2) print(dict1) #

a = b = < 'b', 'c'>a.difference_update(b) print(a, b) # a = b = < 'b', 'c'>b.difference_update(a) print(a, b) #
a = b = < 'b', 'c'>a.intersection_update(b) print(a, b) # a = b = < 'b', 'c'>b.intersection_update(a) print(a, b) #
a = b = < 'b', 'c'>a.symmetric_difference_update(b) print(a, b) # a = b = < 'b', 'c'>b.symmetric_difference_update(a) print(a, b) #

4 Добавление и удаление элементов изменяемых коллекций

Добавление и удаление элементов в коллекцию возможно только для изменяемых коллекций: списка (list), множества (только set, не frozenset), словаря (dict). Причём для списка, который является индексированной коллекцией, также важно на какую позицию мы добавляем элемент.

my_list = [1, 2, 3] my_list.insert(0, 0) # index = 0 - вставляем в начало print(my_list) # [0, 1, 2, 3] my_list.insert(10, 4) # Индекс выходит за границы списка - просто добавим в конец print(my_list) # [0, 1, 2, 3, 4] my_list.insert(-10, -1) # Индекс выходит за границы в минус - добавим в начало print(my_list) # [-1, 0, 1, 2, 3, 4] my_list = [1, 2, 3] my_list.insert(1, 1.5) # Вставим между 1 и 2 (индексация с нуля!) # То есть вставляется на позицию с указанным индексом, а то значение что на ней было # и те что правее - сдвигаются на 1 индекс вправо print(my_list) # [1, 1.5, 2, 3] 

# Работает со списком my_list = [1, 2, 3, 4, 5, 6, 7] del my_list[1] # Удаление элемента по индексу print(my_list) # [1, 3, 4, 5, 6, 7] del my_list[-3:-1] # Удаление элементов выбранных срезом print(my_list) # [1, 3, 4, 7] # del my_list[10] # IndexError: list assignment index out of range # Работает со словарем my_dict = del my_dict['b'] print(my_dict) # # del my_dict['z'] # KeyError при попытке удалить не сушествующий 

5 Особенности работы с изменяемой и не изменяемой коллекцией

Строка неизменяемая коллекция — если мы ее меняем — мы создаем новый объект!

str1 = 'abc' print(str1, id(str1)) # abc 140234080454000 str1 += 'de' print(str1, id(str1)) # abcde 140234079974992 - Это НОВЫЙ объект, с другим id! 

Пример кода с двумя исходно идентичными строками.

str1 = 'abc' str2 = str1 print(str1 is str2) # True - это две ссылки на один и тот же объект! str1 += 'de' # Теперь переменная str1 ссылается на другой объект! print(str1 is str2) # False - теперь это два разных объекта! print(str1, str2) # abcde abc - разные значения 

list1 = [1, 2, 3] list2 = list1 print(list1 is list2) # True - это две ссылки на один и тот же объект! # А дальше убеждаемся, насколько это важно: list1 += [4] print(list1, list2) # [1, 2, 3, 4] [1, 2, 3, 4] # изменилось значение ОБЕИХ переменных, так как обе переменные ссылаются на один объект! 

А если нужна независимая копия, с которой можно работать отдельно?

list1 = [1, 2, 3] list2 = list(list1) # Первый способ копирования list3 = list1[:] # Второй способ копирования list4 = list1.copy() # Третий способ копировани - только в Python 3.3+ print(id(list1), id(list2), id(list3), id(list4)) # все 4 id разные, что значит что мы создали 4 разных объекта list1 += [4] # меняем исходный список print(list1, list2, list3, list4) # [1, 2, 3, 4] [1, 2, 3] [1, 2, 3] [1, 2, 3] # как мы и хотели - изменив исходный объект, его копии остались не тронутыми 

Приглашаю к обсуждению:

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

Источник

Как объединить два словаря в Python

В этой статье мы рассмотрим различные способы объединения двух словарей в Python.

Введение

Часто бывают ситуации, когда в Python есть два словаря, которые вы хотели бы объединить.

Некоторые решения доступны не для всех версий Python, поэтому мы рассмотрим способы слияния для отдельных выпусков.

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

Объединение словарей

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

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

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

Объединение словарей в Python 3.9+

Начиная с версии Python 3.9, мы можем использовать операторов слияния (знак | ) ставится для объединения двух словарей:

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

Объединение словарей до Python 3.9

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

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

Объединение словарей в Python 2

В устаревших версиях Python приведенные выше фрагменты не будут работать. В более поздних версиях слияние может быть облегчено путем объединения элементов словаря или dict_items обеих переменных.

Мы также можем использовать словарные методы copy() и update(). Включая этот, extend() он нам нужен для добавления его (данного словаря) в другой словарь.

Использование метода items()

Начнем с объединения с items():

x = dict(a.items() + b.items()) print(x)

Приведенный выше синтаксис подходит для простых значений. Для вложенного словаря, содержащего значения списка, items() вызов необходимо преобразовать в list() а затем объединить:

y = dict(list(c.items()) + list(d.items())) print(y)

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

Использование метода update()

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

x = a.copy() x.update(b) print (x)

Добавление значений списка во все версии Python

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

Это можно сделать, используя метод extend() показанный ниже:

for k, v in d.items(): if k in c: c[k].extend(v) else: c[k] = v print(c)

Вывод

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

Источник

Как объединить словари в Python

Статьи

Введение

В ходе статьи разберём различные способы объединить словари в языке программирования Python.

Объединение словарей в Python 3.9+

Начиная с версии Python 3.9 появилась возможность объединить два словаря при помощи оператора слияния (|).

x = y = z = x | y print(z) # Вывод:

Объединение словарей в Python 3.5-3.8

В версиях Python начиная с 3.5, по 3.9 предыдущий способ к сожалению не работал. Вместо оператора слияния используется распаковка обоих словарей при помощи двойных звёздочек (**):

Использование методов copy() и update()

В данном способе мы методом copy() копируем первый словарь в z, после чего обновляем получившийся словарь z методом update(), тем самым добавляя в него значения второго словаря:

x = y = z = x.copy() z.update(y) print(z) # Вывод:

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

x = y = x.update(y) print(x) # Вывод:

Использование метода items()

В данном способе мы добавляем данные из первого и второго словаря в списки с кортежами. Далее мы их складываем оператором сложения (+) и преобразовываем в словарь:

x = y = z = dict(list(x.items()) + list(y.items())) print(z) # Вывод:

Получается, что словарь x превращается в список кортежей – [(‘a’, 10), (‘b’, 8)].
Словарь y тоже превращается в список кортежей – [(‘c’, 6), (‘d’, 4)].

И т.к. они находятся в скобках функции dict() получается такая картина:

Ну и как мы знаем, функция dict() преобразовывает их в словарь.

Заключение

В ходе статьи мы с Вами научились объединять словари в Python различными способами. Надеюсь Вам понравилась статья, желаю удачи и успехов! 🙂

Источник