Методы и операции множеств в Python

Обновлено:

Мы уже знаем, что set — это:

  • изменяемая коллекция;
  • неупорядоченный итерируемый объект;
  • коллекция уникальных хешируемых элементов;
  • структура данных, основанная на хеш-таблице.

Теперь рассмотрим методы класса set и операции над множествами.

1. Метод add()

Метод add() добавляет один элемент в множество.

numbers = {10, 20, 30}

numbers.add(40)

print(numbers)

Теперь множество содержит:

{10, 20, 30, 40}

Конкретный порядок элементов может отличаться.

Метод add() немного напоминает знакомый нам append() у списков.

Но есть важное отличие:

  • list.append() добавляет элемент в конец списка;
  • set.add() добавляет элемент в неупорядоченное множество.

Поэтому у set нет понятия последнего или первого элемента.

Повторное добавление

numbers = {10, 20, 30}

numbers.add(20)

print(numbers)

Множество не изменится, поскольку элемент 20 уже существует.

Метод add() изменяет исходный объект и возвращает None.

Если попробовать добавить нехешируемый элемент:

numbers.add([40, 50])

возникнет:

TypeError: unhashable type: 'list'

Методы удаления

У множества есть три метода удаления:

remove()
discard()
pop()

Они похожи, но отличаются поведением.

2. Метод remove()

Метод remove() удаляет указанный элемент:

numbers = {10, 20, 30}

numbers.remove(20)

print(numbers)

Останутся элементы:

{10, 30}

Если такого элемента нет:

numbers.remove(100)

возникнет:

KeyError: 100

Метод remove() не возвращает удалённый элемент. Результат его вызова — None.

3. Метод discard()

discard() работает практически так же:

numbers = {10, 20, 30}

numbers.discard(20)

print(numbers)

Останутся:

{10, 30}

Но если элемента нет:

numbers.discard(100)

ошибки не возникнет.

Метод просто ничего не изменит.

Таким образом:

numbers.remove(100)   # KeyError

numbers.discard(100)  # Без ошибки

discard() удобно использовать, когда отсутствие элемента является нормальной ситуацией.

4. Метод pop()

Метод pop() удаляет произвольный элемент множества и возвращает его.

numbers = {10, 20, 30}

removed_number = numbers.pop()

print(removed_number)
print(numbers)

В отличие от list.pop(), мы не можем указать индекс.

Почему? Потому что у множества нет индексов.

Важно: pop() не выбирает элемент случайным образом в математическом смысле. Он выбирает произвольный элемент, определяемый внутренним устройством множества. Рассчитывать на конкретный элемент нельзя.

Пустое множество

numbers = set()

numbers.pop()

Возникнет:

KeyError: 'pop from an empty set'

Сравнение методов удаления

Метод Что удаляет Возвращает Если элемента нет
remove(x) Указанный элемент None KeyError
discard(x) Указанный элемент None Без ошибки
pop() Произвольный элемент Удалённый элемент KeyError, если множество пустое

5. Метод clear()

Метод clear() полностью очищает множество.

numbers = {10, 20, 30}

numbers.clear()

print(numbers)

Результат:

set()

Сам объект при этом продолжает существовать:

numbers = {10, 20, 30}

old_id = id(numbers)

numbers.clear()

print(id(numbers) == old_id)
# True

Метод clear() возвращает None.


Математические операции над множествами

У множеств есть четыре основные операции:

  1. Объединение — union().
  2. Пересечение — intersection().
  3. Разность — difference().
  4. Симметрическая разность — symmetric_difference().

Для объяснения будем использовать два множества:

first = {1, 2, 3}

second = {3, 4, 5}

Представим их в виде двух пересекающихся кругов.

Только первый круг:   1, 2

Общая часть кругов:   3

Только второй круг:   4, 5

От выбранной операции зависит, какие области этих кругов попадут в результат.

6. Метод union() — объединение

Метод union() возвращает новое множество, содержащее все элементы обоих множеств.

first = {1, 2, 3}
second = {3, 4, 5}

result = first.union(second)

print(sorted(result))

Результат:

[1, 2, 3, 4, 5]

Обратите внимание: число 3 присутствовало в обоих множествах, но в результате оно только одно.

Метод создаёт новый set.

Исходные множества остаются без изменений.

Можно передавать разные итерируемые объекты

Важная особенность метода union() заключается в том, что аргумент не обязан быть множеством.

Например:

numbers = {1, 2, 3}

result = numbers.union(
    [3, 4, 5]
)

print(sorted(result))
# [1, 2, 3, 4, 5]

Мы передали обычный список.

Также можно использовать tuple, range, строку и другие итерируемые объекты, если их элементы хешируемы.

Несколько аргументов

Метод union() принимает сразу несколько итерируемых объектов:

numbers = {1, 2, 3}

result = numbers.union(
    [4, 5],
    (6, 7),
    range(8, 11),
)

print(sorted(result))

Результат:

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

Иными словами:

set.union(iterable_1, iterable_2, ...)

объединяет элементы всех переданных коллекций.


7. Оператор |

Для объединения множеств существует оператор:

|

Например:

first = {1, 2, 3}
second = {3, 4, 5}

result = first | second

print(sorted(result))
# [1, 2, 3, 4, 5]

По смыслу:

first.union(second)

и:

first | second

делают одно и то же.

Оба варианта создают новое множество.

Ограничения оператора

Метод:

first.union([4, 5])

работает.

Но:

first | [4, 5]

приведёт к TypeError.

Для обычных операций над множествами операторы |, &, -, ^ требуют операнды из семейства множеств: set или frozenset.

Методы более универсальны, потому что могут принимать другие итерируемые объекты.

Объединить несколько множеств оператором тоже можно:

result = first | second | third

Изменение существующего множества

8. Метод update()

Метод update() выполняет объединение, но изменяет исходное множество.

numbers = {1, 2, 3}

numbers.update(
    [3, 4, 5]
)

print(sorted(numbers))
# [1, 2, 3, 4, 5]

Он также принимает несколько итерируемых объектов:

numbers = {1, 2}

numbers.update(
    [3, 4],
    (5, 6),
    range(7, 10),
)

print(sorted(numbers))
# [1, 2, 3, 4, 5, 6, 7, 8, 9]

Отличие union() от update()

first.union(second)

создаёт новое множество.

first.update(second)

изменяет first.

У объекта, изменённого методом update(), идентичность остаётся прежней:

numbers = {1, 2}

old_id = id(numbers)

numbers.update({3, 4})

print(id(numbers) == old_id)
# True

Сам метод update() возвращает None.

9. Оператор |=

Вместо:

first.update(second)

можно написать:

first |= second

Например:

numbers = {1, 2, 3}

numbers |= {3, 4, 5}

print(sorted(numbers))
# [1, 2, 3, 4, 5]

Оператор изменяет существующее множество.

Но в отличие от update() справа нельзя передать обычный список:

numbers |= [6, 7]  # TypeError

Здесь требуется set или frozenset.


Пересечение множеств

10. Метод intersection()

Пересечение — это элементы, которые присутствуют одновременно во всех рассматриваемых множествах.

Возьмём:

first = {1, 2, 3}
second = {3, 4, 5}

Общий элемент:

3

Поэтому:

result = first.intersection(second)

print(result)

Результат:

{3}

Это общая часть двух кругов.

Несколько множеств

numbers = {1, 2, 3, 4, 5}

result = numbers.intersection(
    [2, 3, 4],
    (3, 4, 6),
)

print(sorted(result))
# [3, 4]

Метод оставил только значения, присутствующие во всех трёх коллекциях.

Как и union(), он принимает итерируемые объекты, а не только set.

11. Оператор &

Пересечение можно получить оператором:

&
first = {1, 2, 3}
second = {3, 4, 5}

result = first & second

print(result)
# {3}

То есть:

first.intersection(second)

и:

first & second

дают одинаковое множество.

Оба варианта создают новый объект.

Для оператора используются set и frozenset, а метод принимает и другие итерируемые объекты.


12. Метод intersection_update()

Метод intersection_update() оставляет пересечение в исходном множестве:

numbers = {1, 2, 3, 4}

numbers.intersection_update(
    [2, 3, 5]
)

print(sorted(numbers))
# [2, 3]

Все остальные элементы были удалены.

Можно передать и несколько итерируемых объектов:

numbers = {1, 2, 3, 4, 5}

numbers.intersection_update(
    [2, 3, 4],
    (3, 4, 6),
)

print(sorted(numbers))
# [3, 4]

Метод возвращает None.

13. Оператор &=

Вместо:

first.intersection_update(second)

можно написать:

first &= second

Например:

numbers = {1, 2, 3, 4}

numbers &= {2, 4, 6}

print(sorted(numbers))
# [2, 4]

Оператор изменяет существующий set.


Разность множеств

14. Метод difference()

Разность позволяет взять элементы первого множества, которых нет во втором.

first = {1, 2, 3}
second = {3, 4, 5}

result = first.difference(second)

print(sorted(result))
# [1, 2]

Мы получили только ту часть первого круга, которая не пересекается со вторым.

Можно представить:

Первое множество:  1, 2, 3

Второе множество:        3, 4, 5

Осталось:          1, 2

Порядок имеет значение

first.difference(second)

возвращает элементы только из first.

А:

second.difference(first)

вернёт:

{4, 5}

Поэтому:

first.difference(second)

и:

second.difference(first)

обычно дают разные результаты.

Несколько аргументов

numbers = {1, 2, 3, 4, 5}

result = numbers.difference(
    [2],
    (4, 5),
)

print(sorted(result))
# [1, 3]

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


15. Оператор -

Разность можно получить обычным минусом:

first = {1, 2, 3}
second = {3, 4, 5}

result = first - second

print(sorted(result))
# [1, 2]

Оператор - для множеств не выполняет числовое вычитание.

Он выполняет разность множеств.


16. Метод difference_update()

Метод difference_update() удаляет из исходного множества значения, присутствующие в переданных коллекциях.

numbers = {1, 2, 3, 4, 5}

numbers.difference_update(
    [2, 4]
)

print(sorted(numbers))
# [1, 3, 5]

Можно передать несколько итерируемых объектов:

numbers = {1, 2, 3, 4, 5}

numbers.difference_update(
    [2],
    (4, 5),
)

print(sorted(numbers))
# [1, 3]

Метод изменяет существующий set и возвращает None.

17. Оператор -=

Аналогично:

first -= second

Например:

numbers = {1, 2, 3, 4, 5}

numbers -= {2, 4}

print(sorted(numbers))
# [1, 3, 5]

Симметрическая разность

18. Метод symmetric_difference()

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

Возьмём:

first = {1, 2, 3}
second = {3, 4, 5}

В результате должны остаться:

1, 2 — только в первом

4, 5 — только во втором

А общий элемент:

3

не попадёт в результат.

result = first.symmetric_difference(
    second
)

print(sorted(result))
# [1, 2, 4, 5]

По сути мы берём объединение двух множеств и исключаем общую часть.

Это можно записать математически:

Симметрическая разность =
Объединение - Пересечение

Или через знакомые операторы:

result = (
    (first | second)
    - (first & second)
)

Важное отличие

В отличие от:

union()
intersection()
difference()

метод:

symmetric_difference()

принимает только один итерируемый объект.

То есть мы рассматриваем два множества: исходное и переданное.


19. Оператор ^

Для симметрической разности используется:

^

Например:

first = {1, 2, 3}
second = {3, 4, 5}

result = first ^ second

print(sorted(result))
# [1, 2, 4, 5]

То есть:

first.symmetric_difference(second)

и:

first ^ second

дают одинаковый результат.


20. Метод symmetric_difference_update()

Если нужно изменить исходное множество:

numbers = {1, 2, 3}

numbers.symmetric_difference_update(
    [3, 4, 5]
)

print(sorted(numbers))
# [1, 2, 4, 5]

Исходный объект numbers изменился.

Метод принимает один итерируемый объект и возвращает None.

21. Оператор ^=

numbers = {1, 2, 3}

numbers ^= {3, 4, 5}

print(sorted(numbers))
# [1, 2, 4, 5]

22. Сравнение основных операций

Возьмём:

first = {1, 2, 3}
second = {3, 4, 5}
Операция Оператор Результат
Объединение first \| second {1, 2, 3, 4, 5}
Пересечение first & second {3}
Разность first - second {1, 2}
Обратная разность second - first {4, 5}
Симметрическая разность first ^ second {1, 2, 4, 5}

Все четыре операции возвращают новый set, не изменяя исходные множества.


23. Операции с изменением исходного set

Метод Оператор Результат действия
update() \|= Добавить все элементы
intersection_update() &= Оставить общие элементы
difference_update() -= Удалить элементы второго множества
symmetric_difference_update() ^= Оставить элементы, присутствующие только в одном множестве

Все эти методы изменяют существующий объект и возвращают None.

Операторы присваивания изменяют множество на месте.


Метод copy()

24. Поверхностная копия

Как и у списков или словарей, у set есть метод:

copy()

Например:

original = {10, 20, 30}

copied = original.copy()

print(original == copied)
# True

print(original is copied)
# False

Создаётся новый объект set с теми же элементами.

Почему обычно достаточно поверхностной копии

Множество хранит только хешируемые объекты.

В наших привычных примерах это:

int
float
str
tuple

Такие объекты обычно неизменяемы.

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

Достаточно:

copied = original.copy()

Однако это не абсолютное правило для всех возможных объектов Python: пользовательские хешируемые объекты могут содержать изменяемое состояние. С такими объектами разница между поверхностным и глубоким копированием иногда сохраняет значение.


Методы проверки отношений между множествами

Теперь рассмотрим три метода:

isdisjoint()
issubset()
issuperset()

Они не создают новые множества, а возвращают:

True

или:

False

25. Метод isdisjoint()

Метод проверяет, имеют ли две коллекции хотя бы один общий элемент.

Если пересечений нет, возвращается:

True

Например:

first = {1, 2, 3}
second = {4, 5, 6}

print(
    first.isdisjoint(second)
)
# True

Общих элементов нет.

А здесь:

first = {1, 2, 3}
second = {3, 4, 5}

print(
    first.isdisjoint(second)
)
# False

есть общий элемент:

3

Поэтому результат False.

Принимает любой итерируемый объект

Например:

numbers = {10, 20, 30}

print(
    numbers.isdisjoint(
        [40, 50, 60]
    )
)
# True

Можно передать список, кортеж и другой итерируемый объект с подходящими элементами.


Подмножество

26. Метод issubset()

Метод проверяет, являются ли все элементы первого множества элементами второго.

Например:

required_skills = {
    'Python',
    'SQL',
}

developer_skills = {
    'Python',
    'SQL',
    'Django',
}

print(
    required_skills.issubset(
        developer_skills
    )
)
# True

У разработчика есть все требуемые навыки.

Поэтому:

required_skills

является подмножеством:

developer_skills

Равные множества тоже подходят

first = {1, 2, 3}
second = {1, 2, 3}

print(
    first.issubset(second)
)
# True

Множество является подмножеством самого себя.

Также issubset() может принимать обычный итерируемый объект:

numbers = {1, 2}

print(
    numbers.issubset(
        [1, 2, 3, 4]
    )
)
# True

27. Оператор <=

Вместо:

first.issubset(second)

можно использовать:

first <= second

Например:

first = {1, 2}
second = {1, 2, 3}

print(first <= second)
# True

Оператор:

<=

означает:

Все элементы первого множества присутствуют во втором.

Причём равенство тоже разрешено:

print({1, 2} <= {1, 2})
# True

28. Оператор <

Оператор:

<

проверяет строгое подмножество.

То есть первое множество должно быть подмножеством второго, но они не должны быть равны.

first = {1, 2}
second = {1, 2, 3}

print(first < second)
# True

Но:

first = {1, 2}
second = {1, 2}

print(first < second)
# False

Важно

Операторы:

<
<=
>
>=

для множеств не являются обычным сравнением количества элементов.

Например:

first = {1, 2}
second = {3, 4, 5}

print(first < second)
# False

Несмотря на то что в первом множестве меньше элементов, оно не является подмножеством второго.

Потому что его элементы вообще отсутствуют во втором множестве.


Надмножество

29. Метод issuperset()

issuperset() выполняет противоположную проверку.

Он проверяет:

Содержит ли первое множество все элементы второго?

Например:

developer_skills = {
    'Python',
    'SQL',
    'Django',
}

required_skills = {
    'Python',
    'SQL',
}

print(
    developer_skills.issuperset(
        required_skills
    )
)
# True

Первое множество содержит все элементы второго.

Также два равных множества дают:

True

30. Операторы >= и >

Методу:

issuperset()

соответствует:

>=

Например:

first = {1, 2, 3}
second = {1, 2}

print(first >= second)
# True

Равные множества тоже подходят:

print({1, 2} >= {1, 2})
# True

А:

>

проверяет строгое надмножество:

print({1, 2, 3} > {1, 2})
# True

Но:

print({1, 2} > {1, 2})
# False

Потому что множества равны.


31. Сравнение операторов подмножества и надмножества

Оператор Значение Равные множества
A <= B A — подмножество B True
A < B A — строгое подмножество B False
A >= B A — надмножество B True
A > B A — строгое надмножество B False

Для операторов сравнения нужны множества set или frozenset.

Методы issubset() и issuperset() дополнительно принимают другие итерируемые объекты.


Совместимость с frozenset

32. Небольшой анонс следующей темы

В Python существует ещё один тип данных:

frozenset

Это неизменяемое множество.

Подробнее его рассмотрим в следующей теме.

Пока достаточно знать, что set и frozenset совместимы со многими операциями над множествами.

Например:

first = {1, 2, 3}

second = frozenset(
    {3, 4, 5}
)

result = first | second

print(sorted(result))
# [1, 2, 3, 4, 5]

Для бинарных операций результат имеет тип левого операнда.

Например:

print(
    type(first | second)
)
# <class 'set'>

А:

print(
    type(second | first)
)
# <class 'frozenset'>

Операторы:

|
&
-
^

и операторы сравнения множеств работают с обоими типами.

Методы, изменяющие объект на месте, доступны только изменяемому set.


Практический алгоритм: объединение словарей со сложением значений

33. Проблема обычного объединения dict

Вспомним, что словари можно объединять через:

|

Например, есть остатки товаров на двух складах:

warehouse_1 = {
    'apple': 5,
    'banana': 3,
    'pear': 2,
}

warehouse_2 = {
    'banana': 4,
    'pear': 7,
    'orange': 6,
}

Объединим их:

result = warehouse_1 | warehouse_2

print(result)

Результат:

{
    'apple': 5,
    'banana': 4,
    'pear': 7,
    'orange': 6,
}

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

Например:

banana:

первый склад  → 3
второй склад  → 4

После объединения:

banana → 4

Но нам хотелось бы получить:

banana → 7

То есть сложить количество товара на двух складах.


34. Оператор | у dict_keys

В предыдущих темах мы познакомились с методом:

keys()

Например:

warehouse_1.keys()

возвращает объект:

dict_keys(...)

Важно: представления dict_keys поддерживают операции, характерные для множеств.

Поэтому можно написать:

all_products = (
    warehouse_1.keys()
    | warehouse_2.keys()
)

print(
    type(all_products)
)

Результат:

<class 'set'>

То есть объединение двух объектов dict_keys через | возвращает новый set, содержащий уникальные ключи обоих словарей.

Посмотрим на сами ключи:

print(
    sorted(all_products)
)

Получим:

['apple', 'banana', 'orange', 'pear']

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


35. Складываем значения одинаковых ключей

Теперь используем dict comprehension:

warehouse_1 = {
    'apple': 5,
    'banana': 3,
    'pear': 2,
}

warehouse_2 = {
    'banana': 4,
    'pear': 7,
    'orange': 6,
}

total_inventory = {
    product: (
        warehouse_1.get(product, 0)
        + warehouse_2.get(product, 0)
    )
    for product in (
        warehouse_1.keys()
        | warehouse_2.keys()
    )
}

print(
    dict(
        sorted(
            total_inventory.items()
        )
    )
)

Результат:

{
    'apple': 5,
    'banana': 7,
    'orange': 6,
    'pear': 9,
}

36. Как работает этот алгоритм

Разберём конструкцию:

{
    product: (
        warehouse_1.get(product, 0)
        + warehouse_2.get(product, 0)
    )
    for product in (
        warehouse_1.keys()
        | warehouse_2.keys()
    )
}

Первый шаг. Получаем все уникальные ключи

warehouse_1.keys() | warehouse_2.keys()

В результате множество с названиями:

apple
banana
orange
pear

Так как это set, порядок обхода не гарантирован.

Второй шаг. Обходим ключи

for product in ...

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

Третий шаг. Получаем значение из первого словаря

warehouse_1.get(product, 0)

Если товар есть на первом складе, получаем его количество.

Если нет — получаем:

0

Четвёртый шаг. Получаем значение из второго словаря

warehouse_2.get(product, 0)

Работает точно так же.

Пятый шаг. Складываем количества

Например, для:

banana

получаем:

warehouse_1.get('banana', 0)
# 3

и:

warehouse_2.get('banana', 0)
# 4

Складываем:

3 + 4 = 7

Записываем:

'banana': 7

Для:

orange

на первом складе такого ключа нет:

warehouse_1.get('orange', 0)
# 0

Но на втором складе он есть:

warehouse_2.get('orange', 0)
# 6

Получаем:

0 + 6 = 6

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


37. Тот же алгоритм через обычный цикл

Для наглядности можно записать его без comprehension:

total_inventory = {}

all_products = (
    warehouse_1.keys()
    | warehouse_2.keys()
)

for product in all_products:
    quantity_1 = warehouse_1.get(
        product,
        0,
    )

    quantity_2 = warehouse_2.get(
        product,
        0,
    )

    total_inventory[product] = (
        quantity_1 + quantity_2
    )

А dict comprehension позволяет сократить этот алгоритм:

total_inventory = {
    product: (
        warehouse_1.get(product, 0)
        + warehouse_2.get(product, 0)
    )
    for product in (
        warehouse_1.keys()
        | warehouse_2.keys()
    )
}

Это хороший практический пример одновременного использования:

  • dict;
  • dict_keys;
  • объединения множеств;
  • метода get();
  • dict comprehension.

Краткая таблица методов set

Метод Назначение
add(x) Добавить элемент
remove(x) Удалить элемент; ошибка, если отсутствует
discard(x) Удалить элемент, если он существует
pop() Удалить и вернуть произвольный элемент
clear() Очистить множество
union() Создать объединение
update() Добавить элементы в исходное множество
intersection() Создать пересечение
intersection_update() Оставить пересечение в исходном множестве
difference() Создать разность
difference_update() Удалить элементы других коллекций
symmetric_difference() Создать симметрическую разность
symmetric_difference_update() Изменить множество, оставив симметрическую разность
copy() Создать поверхностную копию
isdisjoint() Проверить отсутствие общих элементов
issubset() Проверить, является ли множество подмножеством
issuperset() Проверить, является ли множество надмножеством

Главное по теме

Для добавления одного элемента:

numbers.add(10)

Для удаления:

numbers.remove(10)   # KeyError, если нет

numbers.discard(10)  # Без ошибки

numbers.pop()        # Удалить и вернуть

Для полной очистки:

numbers.clear()

Четыре основные операции над множествами:

first | second   # Объединение

first & second   # Пересечение

first - second   # Разность

first ^ second   # Симметрическая разность

Соответствующие методы:

first.union(second)

first.intersection(second)

first.difference(second)

first.symmetric_difference(second)

Методы принимают не только множества, но и другие итерируемые объекты.


Если нужно изменить существующий set:

first |= second

first &= second

first -= second

first ^= second

или:

first.update(second)

first.intersection_update(second)

first.difference_update(second)

first.symmetric_difference_update(second)

Для проверки отношений:

first.isdisjoint(second)

Нет ли общих элементов?

first.issubset(second)

Все ли элементы первого содержатся во втором?

first.issuperset(second)

Все ли элементы второго содержатся в первом?


Соответствующие операторы:

first <= second  # Подмножество

first < second   # Строгое подмножество

first >= second  # Надмножество

first > second   # Строгое надмножество

Они сравнивают именно принадлежность элементов, а не размеры множеств.


И наконец, объекты dict_keys тоже поддерживают операции над множествами:

first_dict.keys() | second_dict.keys()

Получаем set из уникальных ключей обоих словарей.

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

result = {
    key: (
        first_dict.get(key, 0)
        + second_dict.get(key, 0)
    )
    for key in (
        first_dict.keys()
        | second_dict.keys()
    )
}

В следующей теме рассмотрим frozenset — неизменяемую разновидность множества.