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

До сих пор множества были изменяемыми: add и update из урока 3, remove и discard из урока 4. Иногда это не достоинство, а помеха: состав должен застыть — дни выходных, пары городов в маршруте, группы прав доступа. Для таких данных у Python есть frozenset — замороженное множество: состав фиксируется при создании и больше не меняется.

Создание: frozenset от коллекции

Создаётся так же, как set через set() в уроке 2, только функцией frozenset:

routes = frozenset(['Москва', 'Казань', 'Сочи'])

print(sorted(routes))
print(len(routes))
print(type(routes))

['Казань', 'Москва', 'Сочи']
3
<class 'frozenset'>

Внутри — то же множество: уникальные элементы, мгновенный in, печать через sorted. Отличие в типе и в правах: методов изменения у frozenset нет вовсе.

Изменить нельзя

weekend = frozenset(['сб', 'вс'])

try:
    weekend.add('пн')
except AttributeError as e:
    print('AttributeError:', e)
print(len(weekend))

AttributeError: 'frozenset' object has no attribute 'add'
2

У frozenset нет ни add, ни remove, ни discard, ни update — попытка вызвать любой из них упадёт с AttributeError. Это не недоработка, а гарантия: состав нельзя случайно испортить в другом месте программы.

Читать и считать можно всё

weekend = frozenset(['сб', 'вс'])
workdays = frozenset(['пн', 'вт', 'ср', 'чт', 'пт'])

print('сб' in weekend)
print(len(weekend | workdays))
print(sorted(weekend & workdays))
print(type(weekend | workdays))

True
7
[]
<class 'frozenset'>

Проверки и операции работают как у set: in отвечает мгновенно, объединение и пересечение считаются, разность и симметричная разность тоже. Результат наследует тип левого операнда: frozenset | frozenset — снова frozenset, а если слева обычный set, получится set.

Ключ словаря: то, чего set не умеет

Словарь вычисляет хеш ключа один раз и дальше полагается на его постоянство. Обычный set меняется — хеш разъехался бы с содержимым; Python запрещает такие ключи вовсе. frozenset постоянен, поэтому годится: парой городов удобно описывать маршрут — направление не важно, едет ли кто-то из Казани в Москву или обратно, тариф тот же. Подробно о хешах и о том, что у множеств и словарей общего, — в уроке 17.

fare = {
    frozenset({'Москва', 'Казань'}): 2400,
    frozenset({'Москва', 'Сочи'}): 3200,
}

print(fare[frozenset({'Сочи', 'Москва'})])
print(len(fare))
print(frozenset({'Казань', 'Сочи'}) in fare)

3200
2
False

Ключ нашли, перечислив города в обратном порядке: {Сочи, Москва} и {Москва, Сочи} — одно множество, один ключ, один тариф. Так маршруты A-B и B-A превращаются в одну запись — удобно для цен, расстояний и рейсов. А третья проверка отвечает False: пары Казань и Сочи в словаре нет — тариф на этот маршрут ещё не задан.

fare = {{'Москва', 'Казань'}: 2400}

Traceback (most recent call last):
  File "app.py", line 1, in <module>
    fare = {{'Москва', 'Казань'}: 2400}
           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
TypeError: unhashable type: 'set'

Множество множеств

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

groups = {
    frozenset(['чай', 'кофе']),
    frozenset(['хлеб', 'булка']),
    frozenset(['чай', 'кофе']),
}

print(len(groups))
print(sum(len(g) for g in groups))
print(frozenset(['кофе', 'чай']) in groups)

2
4
True

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

Здесь прячется частое недопонимание. frozenset не замораживает существующее множество, а строит новое: последующие изменения исходника в него не попадут.

base = {'а', 'б'}
snapshot = frozenset(base)

base.add('в')
print(sorted(snapshot))
print(sorted(base))

['а', 'б']
['а', 'б', 'в']

Снимок остался без в — он сделан до добавления. Так устроены все конструкторы коллекций: list(x), set(x), tuple(x) копируют состав на момент вызова.

Понадобилась изменяемая версия — разморозка тоже проста: set(fs) даёт обычный set с тем же составом:

fs = frozenset(['а', 'б'])

mutable = set(fs)
mutable.add('в')

print(sorted(mutable))
print(sorted(fs))

['а', 'б', 'в']
['а', 'б']

Исходный frozenset не тронут: set(fs) собрал независимую копию. Заморозка и разморозка — два конструктора, каждый делает новый объект.

Что дальше

frozenset — первая неизменяемая структура курса: все права чтения, ноль прав записи. Дальше её собрат по неизменности, но с порядком: в уроке 11 — кортеж tuple, фиксированный набор значений с доступом по индексу и без права на переписывание.