Set в Python: первое множество и исчезающие дубликаты

Списки хранят данные как записали: пять визитов — пять элементов, даже если приходил один и тот же человек. Для отчёта это часто не то, что нужно: статистику интересуют уникальные имена, а не количество повторов. Для таких задач в Python есть множество — set: коллекция, которая физически не может хранить дубликат. Уникальность в ней не написана руками, а встроена в саму структуру. Разберём, как создать первое множество, что происходит с повторами и почему множества печатают особым способом.

Старый способ: цикл с проверкой

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

seen = []
for name in ['анна', 'борис', 'анна', 'вера', 'анна']:
    if name not in seen:
        seen.append(name)
print(sorted(seen))
print('уникальных:', len(seen))

['анна', 'борис', 'вера']
уникальных: 3

Работает: три имени вместо пяти визитов. Но три строки кода, две структуры и проверка на каждом шаге — ради операции, которая должна быть одной. Множество делает то же самое при создании, без цикла и без проверок.

Первое множество: фигурные скобки

Множество создаётся функцией set от готовой коллекции — например, от списка визитов. Дубликаты она отбрасывает сама, а длину отдаёт знакомой len:

visits = ['анна', 'борис', 'анна', 'вера', 'анна']
guests = set(visits)
print('визитов:', len(visits))
print('гостей:', len(guests))
print(sorted(guests))

визитов: 5
гостей: 3
['анна', 'борис', 'вера']

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

Дубликаты исчезают при создании

Множество записывают и литералом — элементами в фигурных скобках, через запятую. Что случится, если в записи продублировать значения:

numbers = {1, 3, 3, 5, 5, 5, 7}
print('в записи:', len(numbers))
print(sorted(numbers))
print('уникальных:', len(set([10, 20, 10, 30, 20])))

в записи: 4
[1, 3, 5, 7]
уникальных: 3

Множество хранит каждый элемент ровно один раз: повтор при создании не ошибка, а просто лишний вход, который не пустили. Семёрка записей с дубликатами честно превратилась в четыре значения. Этот же приём — быстрый подсчёт уникальных: длина списка минус длина множества показывает, сколько раз данные повторялись.

orders = ['anna', 'boris', 'anna', 'vera', 'anna', 'boris']
unique = set(orders)
print('заказов:', len(orders))
print('клиентов:', len(unique))
print(sorted(unique))

заказов: 6
клиентов: 3
['anna', 'boris', 'vera']

Шесть заказов, три клиента — одна строка вместо цикла из первого примера. Уникальность посчитана без единой проверки.

Скобки одни, типы разные

У списков и множеств разные скобки, но путаница живёт глубже: фигурные скобки в Python обслуживают сразу две структуры. Посмотрим на оба литерала рядом:

both = [1, 2, 3]
unique = {1, 2, 3}
print(type(both).__name__, type(unique).__name__)
print(len(both), len(unique))

list set
3 3

Квадратные скобки дают список, фигурные — множество. А вот фигурные скобки без элементов {} дают не пустое множество, а пустой словарь — это самая известная ловушка темы, и ей целиком посвящён следующий урок. Пока запомните: пустое множество создаётся только через set().

Порядок не гарантирован: печатаем через sorted

Список помнит порядок, в котором его записали. Множество — нет: оно устроено как хеш-таблица, и элементы лежат в ней так, как легли при вставке. Порядок внутри set может отличаться от записи и меняться между запусками и версиями Python, поэтому результат прямой печати сверить нельзя:

print({'б', 'а', 'в'})

Надёжный способ — функция sorted: она принимает любое перебираемое, в том числе множество, и возвращает обычный список в порядке возрастания. Список уже печатается предсказуемо, а заодно его можно срезать, посчитать и передать дальше:

letters = {'б', 'а', 'в'}
print(sorted(letters))
print(type(sorted(letters)))
print(len(letters))

['а', 'б', 'в']
<class 'list'>
3

sorted вернул список — на это указывает <class 'list'>. Само множество letters при этом не изменилось: sorted ничего не переставляет внутри источника, он лишь собирает его элементы в новый отсортированный список. Договоримся на весь курс: множества печатаем через sorted(s), len(s) или проверки True/False — никогда напрямую.

Что можно положить в множество

Элементом множества может быть неизменяемое значение: число, строка, кортеж. Изменяемые — списки и словари — не проходят: Python вычисляет для каждого элемента хеш, а у изменяемых объектов хеш не определён. Попытка положить список в множество падает с TypeError:

ok = {1, 2, 'три'}
print(len(ok))
try:
    bad = {1, [2, 3]}
except TypeError as e:
    print('Ошибка:', e)
print(sorted({1, 2}))

3
Ошибка: unhashable type: 'list'
[1, 2]

Сообщение говорит прямо: unhashable type — изменяемый тип без хеша. Механизм хеша — тот же, что у ключей словаря: если вы клали ключи в dict, это ограничение вам уже знакомо, а в уроке про общие механизмы множеств и словарей мы сведём их вместе. Тройка, строка и пара чисел в одном множестве при этом живут спокойно — важна неизменяемость элемента, а не одинаковость типов.

Множество или список

Обе структуры хранят набор значений, но заточены под разное. Сводим выбор в таблицу:

Первое множество создано, и два главных свойства на руках: уникальность и мгновенная проверка принадлежности — ей посвящён урок про оператор in. А пока наведём порядок в способах создания: литерал, set() от списка, set() от строки и коварные пустые скобки — всё это в уроке про создание множеств.