Методы и операции множеств в 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.
Математические операции над множествами
У множеств есть четыре основные операции:
- Объединение —
union(). - Пересечение —
intersection(). - Разность —
difference(). - Симметрическая разность —
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 — неизменяемую разновидность множества.