Множества (set) в Python: операции, методы и практические примеры для начинающих

Если вы ищете понятное руководство по теме «множества в Python», эта статья для вас. Разберём, что такое set и frozenset, какие операции поддерживаются, где множества действительно полезны, и как избежать распространённых ошибок. Все примеры совместимы с Python 3.10+.

Что такое множество (set) в Python

set — это изменяемая коллекция уникальных и неупорядоченных элементов. Элемент множества должен быть хешируемым (immutable): число, строка, кортеж и т. п. Дубликаты автоматически удаляются.

# Создание множеств
empty = set()              # пустое множество
nums = {1, 2, 3, 3}        # дубликат 3 будет отброшен
print(nums)                # {1, 2, 3}

from_iter = set("hello")  # из итерируемого объекта
print(from_iter)           # {'h', 'e', 'l', 'o'} (порядок не гарантируется)

# Проверка вхождения — очень быстрая (амортизированно O(1))
print(2 in nums)  # True

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

Множества поддерживают привычную математику: объединение, пересечение, разность, симметрическую разность. Есть как операторы, так и методы.

A = {1, 2, 3, 4}
B = {3, 4, 5}

print(A | B)   # объединение: {1, 2, 3, 4, 5}
print(A & B)   # пересечение: {3, 4}
print(A - B)   # разность: {1, 2}
print(A ^ B)   # симм. разность: {1, 2, 5}

# Эквивалентные методы
print(A.union(B))                  # {1, 2, 3, 4, 5}
print(A.intersection(B))           # {3, 4}
print(A.difference(B))             # {1, 2}
print(A.symmetric_difference(B))   # {1, 2, 5}

Изменяющие (in-place) варианты делают то же самое, но модифицируют множество:

A = {1, 2, 3, 4}
B = {3, 4, 5}
A.update(B)                    # A |= B
print(A)                       # {1, 2, 3, 4, 5}

A = {1, 2, 3, 4}
A.intersection_update(B)       # A &= B
print(A)                       # {3, 4}

Часто используемые методы set

s = {1, 2, 3}
s.add(10)             # добавить элемент
s.update([2, 5, 6])   # добавить несколько элементов из итерируемого
print(s)              # {1, 2, 3, 5, 6, 10}

s.remove(2)           # удалить элемент; KeyError, если нет
s.discard(999)        # безопасное удаление; ошибок не будет
x = s.pop()           # удалить и вернуть какой-то элемент (произвольный)
print('удалили', x)

print(len(s))         # размер множества
copy_s = s.copy()     # поверхностная копия

# Отношения множеств
A = {1, 2}
B = {1, 2, 3}
print(A.issubset(B))      # True (A ⊆ B)
print(B.issuperset(A))    # True (B ⊇ A)
print(A.isdisjoint({3}))  # True, нет общих элементов

Практика: удаление дубликатов из списка

Быстро удалить дубликаты можно через set, но порядок элементов потеряется:

items = [3, 1, 2, 3, 2, 1]
unique_any_order = list(set(items))
print(unique_any_order)   # например, [1, 2, 3] (порядок не гарантируется)

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

def unique_preserve_order(seq):
    seen = set()
    out = []
    for x in seq:
        if x not in seen:
            out.append(x)
            seen.add(x)
    return out

print(unique_preserve_order(items))  # [3, 1, 2]

Альтернативно с учётом сохранения порядка словаря с Python 3.7+:

unique_keep_order = list(dict.fromkeys(items))
print(unique_keep_order)  # [3, 1, 2]

frozenset: неизменяемое множество

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

f = frozenset([1, 2, 3])
D = {f: "immutable key"}
print(D[f])  # immutable key

outer = {frozenset({1, 2}), frozenset({2, 3})}
print(outer)

Подводные камни и типичные ошибки

• Нельзя хранить изменяемые типы: список, словарь и т. п. вызовут ошибку, т.к. они не хешируемы.
• Порядок не гарантируется: не используйте set, если важна последовательность элементов.
• Сравнение множеств учитывает только состав, а не порядок: {1,2} == {2,1} — True.

s = set()
try:
    s.add([1, 2])
except TypeError as e:
    print(e)  # unhashable type: 'list'

# Используйте кортежи вместо списков
s.add((1, 2))
print(s)  # {(1, 2)}

Производительность: где множества особенно полезны

Проверка вхождения в множестве (x in s) обычно амортизированно O(1), тогда как для списка — O(n). На больших данных разница заметна.

import timeit
setup = "data = list(range(100000)); s = set(data)"
list_check = timeit.timeit("99999 in data", setup=setup, number=1000)
set_check = timeit.timeit("99999 in s", setup=setup, number=1000)
print('list:', round(list_check, 4), 'sec')
print('set :', round(set_check, 4), 'sec')

Мини‑проект: уникальные слова в тексте

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

import re
text = """
Python — это простой и мощный язык. Множества в Python помогают быстро находить уникальные элементы!
"""
words = re.findall(r"\w+", text.lower(), flags=re.UNICODE)
stop = {"и", "в", "на", "это", "то", "а"}
vocab = sorted(set(words) - stop)
print(vocab[:10])
print('Всего уникальных слов:', len(vocab))

Практические советы

• Используйте set для быстрых проверок вхождения и удаления дубликатов.
• Если важен порядок, применяйте приём с seen или dict.fromkeys.
• Для элементов‑коллекций используйте кортежи (tuple), а не списки.
• Для объединения больших наборов предпочтительнее update вместо ручного цикла.
• Не полагайтесь на порядок вывода множества, он не определён.

Хотите системно прокачать Python с практикой и обратной связью? Посмотрите программу и первые шаги: Пошаговый курс «Программирование на Python с Нуля до Гуру» — начать обучение сегодня.