Операции над
множествами

Категория

Операции set

Уровень

Базовый → средний

Связанные темы

Множества, логика, сравнение наборов

Зачем это знать

Сравнивать наборы данных без циклов

§1Вопросы о двух наборах

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

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

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

§2Объединение

Объединение собирает всё, что есть хотя бы в одном из наборов, — повторы при этом исчезают сами.

backend = {"Python", "SQL"}
frontend = {"JavaScript", "HTML", "SQL"}

print(sorted(backend | frontend))

['HTML', 'JavaScript', 'Python', 'SQL']

A | B     только в A  +  общие  +  только в B

§3Пересечение

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

active = {101, 102, 103}
subscribed = {102, 103, 104}

print(sorted(active & subscribed))

[102, 103]

Символ & выбран не случайно: он же означает логическое «и» в побитовых операциях. Пересечение — это «элемент в A и в B», объединение — «в A или в B».

§4Разность

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

required = {"read", "write", "delete"}
granted = {"read", "write"}

print(sorted(required - granted))

['delete']

Это, пожалуй, самая полезная операция на практике: «чего не хватает», «что удалилось», «какие файлы ещё не обработаны» — всё это разность.

§5Направление разности

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

required = {"read", "write", "delete"}
granted = {"read", "write"}

print(required - granted)
print(granted - required)

{'delete'}
set()

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

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

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

yesterday = {"A", "B", "C"}
today = {"B", "C", "D"}

print(sorted(yesterday ^ today))

['A', 'D']

Результат отвечает «что различается», но не говорит, в какую сторону: A и D здесь равноправны. Если направление важно, берут две обычные разности.

A = {A, B, C}      B = {B, C, D}

A | B  →  A B C D     всё
A & B  →    B C       общее
A - B  →  A           только слева
A ^ B  →  A     D     только с одной стороны

§7Методы и операторы

У каждой операции есть два вида записи.

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

§8Разница между ними

Одно отличие всё-таки есть, и оно практическое: метод принимает любую итерируемую коллекцию, оператор — только множество.

print({1, 2} | [3])

TypeError: unsupported operand type(s) for |: 'set' and 'list'

print(sorted({1, 2}.union([3])))

[1, 2, 3]

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

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

Проверка «все ли элементы A входят в B» отвечает на вопрос вида «хватает ли прав».

required = {"read", "write"}
granted = {"read", "write", "delete"}

print(required.issubset(granted))
print(required <= granted)

True
True

Запись required <= granted читается как «требуемое не больше выданного». Это гораздо короче, чем цикл с проверкой каждого права.

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

Зеркальная проверка — «содержит ли B всё из A».

required = {"read", "write"}
granted = {"read", "write", "delete"}

print(granted.issuperset(required))
print(granted >= required)

True
True

Выбор между issubset() и issuperset() — вопрос того, что удобнее поставить в начало фразы.

§11Строгие и нестрогие проверки

Знаки < и <= различаются так же, как у чисел: строгий вариант требует, чтобы множества не были равны.

values = {"read", "write"}

print(values <= values)
print(values < values)

True
False

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

§12isdisjoint(): нет общего

Метод отвечает, что пересечение пусто, — и делает это, не строя само пересечение.

print({1, 2}.isdisjoint({3, 4}))
print({1, 2}.isdisjoint({2, 3}))

True
False

То же самое можно записать как not (a & b), но isdisjoint() останавливается на первом общем элементе и не создаёт промежуточное множество.

§13Несколько наборов сразу

Операции можно объединять в цепочку — или передать методу несколько аргументов.

a = {1, 2, 3}
b = {2, 3, 4}
c = {3, 4, 5}

print(sorted(a & b & c))
print(sorted(a.intersection(b, c)))

[3]
[3]

Метод с несколькими аргументами удобнее, когда наборы лежат в списке: тогда их распаковывают звёздочкой из главы 6.6 — set.union(*groups).

§14Практика: права доступа

Собрать всё вместе на одной задаче.

granted = {"read", "write"}
required = {"write", "delete"}

print(required <= granted)
print(sorted(required - granted))
print(sorted(required & granted))

False
['delete']
['write']

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

§15Частые ошибки

§16Проверьте себя

§17Шпаргалка

Итог главы

Четыре операции отвечают на вопросы о двух наборах без циклов: объединение даёт всё, пересечение — общее, разность — то, чего нет справа, симметрическая разность — то, что есть ровно с одной стороны. Разность единственная из них несимметрична, и перепутанный порядок операндов даёт правдоподобный ответ на другой вопрос. Проверки <= и >= отвечают «входит ли один набор в другой» — это готовая проверка достаточности прав. Операторы требуют множеств с обеих сторон, методы принимают любые коллекции.