Введение в множества (Sets) и философию их применения в Python

Добро пожаловать в девятый урок нашего углубленного курса по Python! На уровне Intermediate программирование перестает быть просто написанием скриптов, которые «как-то работают», и переходит в плоскость инженерии, где важны алгоритмическая сложность, оптимальное использование памяти и элегантность архитектуры. Сегодня мы подробно и максимально глубоко разберем одну из самых мощных, быстрых и математически обоснованных структур данных в языке Python — множества (sets).

Что такое множество? С точки зрения математики, основы которой были заложены Георгом Кантором в конце девятнадцатого века, множество — это совокупность уникальных объектов, рассматриваемая как единое целое. В языке программирования Python множество (тип set) полностью наследует эту математическую концепцию. Это изменяемая (mutable), неупорядоченная коллекция, которая может хранить только уникальные (не повторяющиеся) и обязательно неизменяемые (immutable/hashable) элементы.

Почему множества так важны? Представьте, что вы разрабатываете систему анализа логов веб-сервера. За сутки ваш сервер посетили миллионы пользователей, и вам нужно быстро получить список уникальных IP-адресов. Если вы будете использовать список (list) и для каждого нового IP-адреса проверять его наличие с помощью оператора in (например, if ip not in my_list: my_list.append(ip)), ваша программа будет работать катастрофически медленно. Причина кроется в алгоритмической сложности: поиск в списке занимает O(N) времени, где N — размер списка. Для миллиона записей это означает миллион операций сравнения для каждого нового элемента. В противоположность этому, множества в Python реализованы на основе хеш-таблиц. Это означает, что проверка принадлежности элемента множеству (оператор in), добавление нового элемента и удаление выполняются в среднем за O(1), то есть за константное время, независимо от размера множества! Это колоссальный прирост производительности, который отличает код Junior-разработчика от кода уверенного Middle/Senior специалиста.

Важно помнить о ключевом ограничении множеств: они неупорядочены. Вы не можете обратиться к элементу множества по индексу (например, my_set[0] вызовет ошибку TypeError). Порядок элементов при выводе множества на экран может меняться от запуска к запуску программы, так как он зависит от алгоритма хеширования, который в целях безопасности использует случайную «соль» (hash randomization) при каждом новом запуске интерпретатора Python. Кроме того, элементы внутри множества обязаны быть хешируемыми. Это значит, что вы можете поместить в множество числа (int, float), строки (str), булевы значения (bool) и кортежи (tuple, если они содержат только хешируемые элементы), но вы не можете добавить в множество список (list), словарь (dict) или другое множество (set), так как они являются изменяемыми и не имеют постоянного хеша. В этом модуле мы разберем все эти нюансы, научимся обходить ловушки и применим методологию Project-Based Learning для создания системы анализа текстовых данных.

Создание множеств: Синтаксис, ловушки и концепция хеширования (Hashability)

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

Первый и самый распространенный способ создания множества — это использование фигурных скобок {} с перечислением элементов через запятую, например: my_set = {1, 2, 3}. Синтаксически это очень похоже на создание словаря (dict), но без двоеточий между ключами и значениями. И именно здесь возникает классическая ловушка пустого множества. Если вы напишете empty_set = {}, вы создадите не пустое множество, а пустой словарь! Это связано с историческим развитием Python: словари появились в языке раньше множеств и «застолбили» за собой этот синтаксис. Чтобы создать по-настоящему пустое множество, вы обязаны использовать встроенную функцию (конструктор класса) set(). Запомните это правило: пустые фигурные скобки — это всегда словарь.

Второй способ создания — использование конструктора set(iterable). Эта функция принимает любой итерируемый объект (список, кортеж, строку, генератор) и создает множество из его элементов. Это самый быстрый и питоничный («Pythonic way») способ удаления дубликатов из списка. Например, unique_items = set([1, 2, 2, 3, 1]) вернет множество {1, 2, 3}. Однако здесь мы сталкиваемся с важнейшим понятием Python — хешируемостью (hashability).

Что значит «нехешируемый тип» (unhashable type)? Как мы упоминали ранее, множества построены на хеш-таблицах. Чтобы положить объект в хеш-таблицу, Python должен вычислить его хеш — уникальное числовое значение, фиксированного размера, которое служит «адресом» элемента в памяти таблицы. Функция hash() в Python требует, чтобы объект был неизменяемым на протяжении всей своей жизни. Если объект можно изменить (как список или словарь), его хеш также должен был бы измениться, что разрушило бы структуру хеш-таблицы: элемент оказалось бы невозможно найти по его первоначальному «адресу». Поэтому, если вы попытаетесь выполнить set([[1, 2], [3, 4]]), интерпретатор немедленно выбросит исключение TypeError: unhashable type: 'list'. Понимание разницы между Mutable (изменяемыми) и Immutable (неизменяемыми) объектами критически важно для работы с множествами. Если вам нужно хранить сложные структуры внутри множества, используйте кортежи (tuple) вместо списков, так как кортежи неизменяемы и, следовательно, хешируемы (при условии, что все элементы внутри кортежа также хешируемы).

Модификация множеств: Добавление элементов (методы add и update)

Множества являются изменяемыми (mutable) коллекциями, что означает, что мы можем добавлять и удалять элементы после создания множества, не создавая новый объект в памяти (id множества остается неизменным). Для добавления элементов в Python предусмотрены два основных метода: add() и update(). Понимание разницы между ними критически важно для написания чистого и эффективного кода.

Метод add(element) используется для добавления строго одного элемента в множество. Если вы передадите в add() строку, например, my_set.add("hello"), то в множество будет добавлена вся строка целиком как единый объект-строка. Что произойдет, если попытаться добавить элемент, который уже существует в множестве? Абсолютно ничего. Python не вызовет ошибку и не продублирует элемент; он просто вычислит хеш элемента, проверит, занята ли соответствующая ячейка в хеш-таблице, и если там находится идентичный объект, операция добавления будет молча проигнорирована. Это свойство идемпотентности делает множества идеальными для сбора уникальных данных в циклах.

Метод update(*iterables) работает иначе. Он принимает один или несколько итерируемых объектов (списки, кортежи, строки, другие множества) и добавляет каждый элемент этих объектов в исходное множество по отдельности. Это эквивалентно математической операции объединения множеств с сохранением результата (in-place union). Если вы напишете my_set.update("hello"), то произойдет нечто совершенно иное, чем при использовании add: метод update проитерируется по строке как по коллекции символов, и добавит в множество отдельные буквы: 'h', 'e', 'l', 'o' (обратите внимание, что вторая буква 'l' будет проигнорирована как дубликат). Метод update чрезвычайно удобен, когда вам нужно слить данные из множества списков в одну уникальную коллекцию. Он также может принимать несколько аргументов через запятую: my_set.update(list1, tuple2, set3), что делает его мощным инструментом для массовой загрузки данных в хеш-таблицу. Важно отметить, что оба метода (и add, и update) изменяют множество «на месте» (in-place) и возвращают None. Никогда не пишите my_set = my_set.add(5), так как это приведет к потере множества и присвоению переменной значения None!

Удаление элементов: тонкости методов remove, discard, pop и clear

Процесс удаления элементов из множества требует не меньшего внимания, чем их добавление. Язык Python предоставляет нам четыре различных метода для очистки данных из множества, и выбор правильного инструмента зависит от логики вашей программы и того, как вы хотите обрабатывать потенциальные ошибки. Эта вариативность подчеркивает философию Python: предоставление разработчику точного контроля над потоком выполнения программы.

Метод remove(element) удаляет указанный элемент из множества. Однако у него есть строгая особенность: если вы попытаетесь удалить элемент, которого в множестве не существует, Python выбросит исключение KeyError. Использование remove() оправдано в тех случаях, когда логика вашей программы (бизнес-логика) гарантирует, что элемент должен находиться в коллекции. Если его там нет, значит, где-то в архитектуре произошел сбой, и исключение KeyError послужит отличным сигналом о проблеме (принцип «fail fast» — падай быстро). Это защищает вас от скрытых багов.

В отличие от него, метод discard(element) работает более «мягко». Он также удаляет указанный элемент, но если элемент отсутствует в множестве, discard() просто тихо завершает свою работу, не вызывая никаких ошибок и не прерывая выполнение скрипта. Этот метод идеально подходит для ситуаций, когда вам не важно, был ли элемент в множестве изначально; ваша единственная цель — гарантировать, что после выполнения команды этого элемента там точно нет. Использование discard() позволяет избежать громоздких конструкций с try/except или предварительных проверок через if element in my_set:, что делает код чище и быстрее.

Метод pop() извлекает и удаляет из множества произвольный элемент, возвращая его значение. В отличие от списков, где pop() без аргументов удаляет последний элемент, в множествах понятие «последний» не существует из-за отсутствия упорядоченности. На практике pop() извлекает элементы в том порядке, в котором они хранятся в памяти хеш-таблицы, что для нас выглядит как псевдослучайность. Если множество пустое, pop() вызовет исключение KeyError: 'pop from an empty set'. Этот метод часто используется в алгоритмах обхода графов (например, поиск в глубину или ширину), где множество используется как пул еще не посещенных узлов. Наконец, метод clear() полностью опустошает множество, удаляя из него все элементы, превращая его в set(). Важно понимать, что clear() не удаляет сам объект множества из оперативной памяти; он лишь очищает его внутреннюю структуру, позволяя использовать тот же объект повторно.

Математические операции: Объединение множеств (Union)

До сих пор мы рассматривали множества просто как контейнеры для уникальных данных. Но их истинная мощь, унаследованная из дискретной математики, раскрывается при выполнении операций над группами множеств. Изучение этих операций мы начнем с объединения — Union. Операция объединения двух множеств A и B (обозначается в математике как A ∪ B) создает новое множество, которое содержит все уникальные элементы из множества A, все уникальные элементы из множества B, и, разумеется, те элементы, которые присутствуют в обоих множествах, но без какого-либо дублирования.

В Python выполнить операцию объединения можно двумя способами: с использованием специального оператора вертикальной черты | (побитовое ИЛИ) или с помощью именованного метода .union(). На первый взгляд, они делают абсолютно одно и то же, возвращая новый объект множества и не изменяя исходные. Однако между ними существует фундаментальное архитектурное различие, которое часто становится вопросом на собеседованиях уровня Middle. Оператор | требует, чтобы оба операнда (и слева, и справа) были строго объектами типа set или frozenset. Если вы попытаетесь выполнить операцию my_set | [1, 2, 3], интерпретатор немедленно остановит работу с ошибкой TypeError: unsupported operand type(s) for |: 'set' and 'list'.

С другой стороны, метод .union() гораздо более гибок. Он спроектирован так, чтобы принимать любой итерируемый объект в качестве аргумента. Под капотом my_set.union([1, 2, 3]) сам сконвертирует переданный список, кортеж или строку во временное множество, выполнит операцию объединения и вернет результат. Это делает метод .union() предпочтительным выбором, когда вы работаете со смешанными типами коллекций и не хотите тратить время и строки кода на явную конвертацию типов (приведение типов). Кроме того, метод .union() может принимать несколько аргументов одновременно: set_a.union(list_b, tuple_c, string_d), объединяя все элементы этих коллекций в одно гигантское множество за один вызов. Понимание этой тонкой грани между строгой типизацией операторов и гибкостью методов — это шаг к глубокому осмыслению философии дизайна языка Python, описанной в PEP 8 и The Zen of Python.

Математические операции: Пересечение множеств (Intersection)

Следующая фундаментальная операция теории множеств — это пересечение (Intersection). В математике пересечение множеств A и B (A ∩ B) — это множество, состоящее только из тех элементов, которые одновременно принадлежат и множеству A, и множеству B. Говоря простым языком, это поиск общих черт, точек соприкосновения. В программировании эта операция используется повсеместно: от нахождения общих друзей в социальных сетях (пользователь А и пользователь Б имеют общие контакты) до фильтрации данных по нескольким критериям (например, найти товары, которые находятся в категории «Электроника» И имеют тег «Скидка»).

Как и в случае с объединением, Python предоставляет два синтаксических способа поиска пересечений: оператор амперсанд & (побитовое И) и метод .intersection(). Логика их применения идентична правилу, изученному на предыдущем шаге. Оператор & является строгим и требует, чтобы слева и справа находились исключительно множества. Метод .intersection() готов принять любой итерируемый объект: список, кортеж, генератор. Оба этих способа создают и возвращают совершенно новый объект множества в памяти, не затрагивая исходные данные. Если множества не имеют ни одного общего элемента (в математике такие множества называются непересекающимися, disjoint), операция вернет пустое множество set().

Однако, здесь мы вводим новый концепт — обновление «на месте» (in-place updates). Во многих реальных задачах создания нового объекта в памяти бывает избыточным, особенно если вы работаете с миллионами записей и экономите оперативную память (RAM). Для таких случаев Python предоставляет метод intersection_update() (и его операторный аналог &=). Метод intersection_update() не возвращает нового множества (он возвращает None). Вместо этого он модифицирует вызывающее множество, удаляя из него все элементы, которых нет в переданном аргументе. Таким образом, множество «сужается» до размеров пересечения, сохраняя свой исходный id() в памяти. Это крайне полезный паттерн оптимизации, который часто применяется в алгоритмах фильтрации данных на бэкенде: вы загружаете исходный массив данных в множество, а затем применяете цепочку intersection_update с различными фильтрами, последовательно отсекая ненужное.

Математические операции: Разность множеств (Difference)

Изучив, как находить объединения и общие элементы, логично перейти к операции, позволяющей находить уникальные различия. Эта операция называется разностью (Difference). В математике разность множеств A и B (записывается как A - B или A \ B) — это множество, содержащее все элементы, которые принадлежат множеству A, но не принадлежат множеству B. Иными словами, мы берем первое множество и «вычитаем» из него все совпадения со вторым. Критически важное отличие разности от объединения и пересечения заключается в том, что эта операция некоммутативна (несимметрична). То есть A - B не равно B - A (за исключением случая, когда множества полностью идентичны). Порядок операндов имеет решающее значение.

С точки зрения практического программирования, разность — это инструмент номер один для решения задач вроде: «Показать пользователей, которые зарегистрировались, но еще не совершили ни одной покупки», «Найти IP-адреса, с которых были попытки входа, но которых нет в белом списке», или «Определить, какие обязательные поля формы пользователь забыл заполнить». В Python разность реализуется с помощью очевидного оператора минус - или метода .difference(). Аналогично предыдущим операциям, оператор минус требует строгих типов данных (set слева, set справа), в то время как метод .difference() великодушно принимает любой итерируемый объект в качестве вычитаемого (список, кортеж и т.д.).

Для ситуаций, когда вы хотите обновить существующее множество, удалив из него элементы, присутствующие в другой коллекции, используйте метод difference_update() или его оператор-аналог -=. Этот метод изменяет множество in-place, экономя системные ресурсы. Например, у вас есть множество активных задач tasks = {'task1', 'task2', 'task3'}, и по API пришел список завершенных задач completed = ['task2']. Оптимальным решением будет выполнить tasks.difference_update(completed), после чего в tasks останутся только нерешенные проблемы. Это гораздо эффективнее, чем писать циклы с проверками условий.

Математические операции: Симметричная разность (Symmetric Difference)

Мы подошли к самой необычной, но чрезвычайно полезной математической операции — симметричной разности (Symmetric Difference). В теории множеств симметричная разность множеств A и B (обозначается как A △ B) — это множество, содержащее элементы, которые принадлежат либо множеству A, либо множеству B, но не обоим одновременно. Программистам эта логика отлично знакома: это полный аналог логической операции XOR (исключающее ИЛИ). Если элемент есть только в левом множестве — берем его. Если элемент есть только в правом — берем его. Если элемент есть в обоих — отбрасываем (исключаем).

Математически симметричную разность можно выразить через уже знакомые нам операции: это объединение двух множеств минус их пересечение (A | B) - (A & B). Но Python, будучи языком, созданным для удобства разработчика, предоставляет специальный синтаксис для этой операции: оператор «каретка» (циркумфлекс) ^ или метод .symmetric_difference(). Симметричная разность обладает свойством коммутативности, то есть A ^ B всегда равно B ^ A. Эта операция незаменима в сценариях, когда вам нужно найти расхождения между двумя базами данных или конфигурациями. Например, у вас есть список сотрудников из отдела кадров и список доступов в IT-системе. Применив симметричную разность, вы мгновенно получите список «проблемных» аккаунтов: тех, кто числится в штате, но не имеет доступа, ПЛЮС тех, у кого доступ остался, но в штате они уже не числятся. Одним элегантным выражением вы решаете задачу аудита безопасности, которая при использовании циклов потребовала бы десятков строк запутанного кода.

Для изменения множества in-place (на месте) доступен метод symmetric_difference_update() или оператор ^=. Этот метод возьмет текущее множество, добавит в него элементы из переданного аргумента, которых там не было, и удалит те элементы, которые совпали. Звучит сложно, но на практике это работает как переключатель состояния (toggle). Если вы дважды примените симметричную разность одного и того же множества B к множеству A, множество A вернется в свое исходное состояние.

Отношения между множествами: Подмножества, Надмножества и Непересекающиеся множества

Помимо операций, создающих новые данные, Python предлагает методы для проверки логических отношений между множествами. Эти методы всегда возвращают булево значение (True или False) и используются в условных конструкциях (if/else) для маршрутизации логики программы. Три главных столпа логических проверок — это проверка на подмножество (subset), надмножество (superset) и полное отсутствие пересечений (disjoint).

Метод issubset(other) или оператор <= проверяет, являются ли все элементы первого множества частью второго множества. Если множество A полностью вложено в множество B (или равно ему), A считается подмножеством B. Например, множество навыков Junior-разработчика {'Python', 'SQL'} является подмножеством навыков Senior-разработчика {'Python', 'SQL', 'Docker', 'AWS'}. Оператор < проверяет строгое (proper) подмножество: A должно быть вложено в B, но при этом A не может быть в точности равно B.

Метод issuperset(other) или оператор >= — это зеркальное отражение issubset. Он проверяет, включает ли (поглощает ли) первое множество все элементы второго. Возвращаясь к нашему примеру: Senior является надмножеством Junior. Использование операторов > и < делает код чрезвычайно читаемым, буквально превращая математические концепции в понятный английский язык (set A is strictly greater than set B).

Наконец, метод isdisjoint(other) проверяет, не имеют ли множества ни одного общего элемента. Если пересечение множеств пусто, метод возвращает True, иначе — False. Важная архитектурная особенность isdisjoint заключается в его алгоритмической оптимизации: он работает значительно быстрее, чем ручная проверка len(A & B) == 0. Причина кроется в том, что isdisjoint использует механизм «раннего выхода» (early exit/short-circuiting). Как только интерпретатор CPython (написанный на C) находит хотя бы один совпадающий элемент во время итерации по хеш-таблице, он немедленно прерывает поиск и возвращает False. Ему не нужно вычислять полное пересечение и выделять память под новое множество. Это идеальный инструмент для валидации входных данных, например, проверки, что ни один из запрещенных символов (множество A) не содержится в пароле пользователя (множество B).

Frozenset: Неизменяемые множества и их место в архитектуре данных

Мы досконально изучили поведение классических множеств (тип set). Вы знаете, что они невероятно быстры, гибки и позволяют изменять свое содержимое (добавлять и удалять элементы). Но в начале урока мы озвучили фундаментальное правило Python: элементы множества должны быть хешируемыми (неизменяемыми). А поскольку тип set сам по себе является изменяемым (mutable), он не имеет хеша. Это создает очевидный архитектурный парадокс: вы не можете поместить множество внутрь другого множества, и вы не можете использовать множество в качестве ключа словаря (dict). Попытка создать nested_set = {{1, 2}, {3, 4}} неминуемо приведет к TypeError: unhashable type: 'set'.

Для решения этой проблемы архитекторы Python ввели специальный встроенный тип данных — frozenset (замороженное множество). frozenset — это полная копия обычного множества, но с одним критическим отличием: оно неизменяемо (immutable). После того как frozenset создан, вы не можете использовать методы add, remove, update, pop или clear. Объект фиксируется в оперативной памяти навсегда. Из-за того, что frozenset нельзя изменить, интерпретатор Python может безопасно вычислить для него математический хеш. А раз у него есть хеш, значит, он может быть элементом обычного множества или ключом в словаре!

Когда и зачем использовать frozenset на практике? Классический пример (use case) из Data Engineering: кэширование и мемоизация вызовов функций. Представьте, что у вас есть тяжелая функция, которая вычисляет сходство между группой документов. Порядок документов в группе не важен (документы A, B и C — это та же группа, что и C, B, A). Если вы будете использовать списки в качестве ключей для словаря-кэша, вы получите ошибку типов. Если преобразуете в кортежи — (A, B) и (B, A) будут восприниматься как разные ключи, и функция отработает дважды впустую. Решение — использовать frozenset аргументов в качестве ключа. frozenset({A, B}) и frozenset({B, A}) математически равны и имеют одинаковый хеш. Таким образом, кэш сработает идеально. Создается frozenset только одним способом: передачей итерируемого объекта в конструктор frozenset(iterable). Специального литерала (типа фигурных скобок) для них в языке не предусмотрено.

Project-Based Learning: Система анализа текстовых логов и дедупликации (Шаг 1)

Теория мертва без практики. Методология Project-Based Learning требует от нас погружения в реальные бизнес-задачи. Представим, что вы работаете в Data Science подразделении маркетинговой компании. У вас есть два огромных массива данных: логи поисковых запросов пользователей на вашем сайте (корпус A) и логи запросов у компании-конкурента, которые вы легально приобрели (корпус B). Данные грязные, в них много дубликатов, смешаны регистры (строчные/прописные буквы), присутствуют спецсимволы. Перед вами стоят три бизнес-задачи: во-первых, очистить массивы и получить уникальные списки запросов (дедупликация); во-вторых, найти ядро пересечения (какие запросы популярны у обеих компаний, чтобы настроить на них таргетированную рекламу); в-третьих, найти уникальные ниши (запросы, которые есть только у вас, или только у конкурента). Решать эту задачу с помощью списков и вложенных циклов — значит обречь сервер на зависание (сложность O(N*M)). Мы решим её элегантно, быстро и по-питоновски (Pythonic way) с помощью множеств и генераторов множеств (Set Comprehensions).

Для начала давайте разберем концепт Set Comprehension (генератор множеств). Вы уже знакомы с List Comprehensions (списковыми включениями). Синтаксис генератора множеств абсолютно идентичен, за исключением того, что он оборачивается в фигурные скобки {} вместо квадратных []. Конструкция выглядит так: {выражение for элемент in итерируемый_объект if условие}. Этот механизм не только сокращает количество строк кода, но и работает на уровне языка C (C-level extensions), что делает его выполнение значительно быстрее классического цикла for с вызовом метода .add() на каждой итерации. На первом этапе нашего проекта мы напишем функцию очистки данных, которая примет сырой список строк, приведет все к нижнему регистру (чтобы 'Apple' и 'apple' стали одним словом), очистит от пробелов по краям с помощью .strip() и отбросит пустые строки. И всё это будет упаковано в один генератор множества, который на выходе мгновенно удалит все дубликаты.

Project-Based Learning: Пересечения и разности в реальном проекте (Шаги 2 и 3)

Теперь, когда наши данные очищены и превращены в хеш-таблицы (объекты типа set), поиск ответов на бизнес-вопросы займет микросекунды и потребует всего несколько строк кода. Переходим ко второму шагу проекта: поиску «ядра» — запросов, которые популярны у обеих компаний. Для этого мы применяем математическую операцию пересечения (Intersection). Используя оператор & между множеством наших запросов и множеством запросов конкурента, мы мгновенно получаем список common_queries. В реальном бизнесе эти ключевые слова будут переданы в отдел контекстной рекламы (PPC), так как по ним идет самая ожесточенная борьба за клиента. Это ваш "красный океан". Сложность этой операции под капотом составляет O(min(len(s1), len(s2))), что невероятно эффективно: Python перебирает только наименьшее из двух множеств и ищет совпадения в большем (поиск в котором, напомним, занимает константное время O(1)).

Третий шаг — поиск уникальных ниш. Маркетологам нужно знать, по каким запросам продвигаемся только мы (чтобы защитить эти позиции), и по каким запросам продвигается только конкурент (чтобы попытаться захватить этот трафик). Здесь на сцену выходит симметричная разность (Symmetric Difference). Используя оператор ^, мы отсекаем общее ядро (которое мы нашли на предыдущем шаге) и оставляем только специфические, уникальные запросы, присутствующие строго в одном из логов. Если же нам нужно точечно посмотреть, что есть у конкурента, чего нет у нас, мы используем обычную разность (unique_competitor - unique_ours). Это "голубой океан" возможностей для бизнеса. Посмотрите на финальный код проекта: он краток, читаем и математически строг. Именно к такому стилю программирования (Pythonic) мы стремимся на уровне Intermediate. Использование правильной структуры данных — в данном случае множеств — избавляет нас от написания сложных алгоритмов поиска и сортировки, перекладывая всю тяжелую работу на оптимизированное ядро CPython.