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

Кортеж как список с замком

Кортеж, он же tuple, это упорядоченная коллекция, которую нельзя изменить после создания. Синтаксис почти совпадает со списком, только вместо квадратных скобок используются круглые:

days = ("пн", "вт", "ср", "чт", "пт")
point = 10, 20
empty = ()
from_list = tuple([1, 2, 3])
from_string = tuple("python")
print(days[0])
print(point)
print(from_string)

Скобки здесь необязательны. Запись point = 10, 20 создаёт точно такой же кортеж, как point = (10, 20), просто без скобок. Круглые скобки нужны в основном для наглядности и там, где без них Python запутается в приоритетах операций. Из списка или строки кортеж собирает функция tuple(), она перебирает элементы по одному и складывает их в новый неизменяемый контейнер.

Читать содержимое можно привычным способом: по индексу, срезами, в цикле for. Работают len(), оператор in и даже срезы, возвращающие новый кортеж. Разница со списком проявляется ровно в одном месте, зато принципиальном: заменить элемент не получится.

days = ("пн", "вт", "ср")
print(len(days))
print("вт" in days)
print(days.count("пн"))
print(days.index("ср"))

Собственных методов у кортежа всего два: count() считает, сколько раз элемент встречается внутри, а index() возвращает его позицию. Методов добавления и удаления нет именно потому, что менять кортеж запрещено. Скромный набор инструментов здесь не недостаток, а знак того, что кортеж создан для хранения, а не для переборов с переделками.

Кортеж и список свободно превращаются друг в друга: функция list() разворачивает кортеж в список, функция tuple() собирает кортеж из списка. Это удобно, когда данные пришли в неизменяемой упаковке, а поработать с ними нужно как со списком:

t = (1, 2, 3)
lst = list(t)
lst.append(4)
back = tuple(lst)
print(lst)
print(back)

Ловушка с одним элементом и неизменяемость кортежа

Здесь новичков поджидает классическая ловушка. Запись (5) выглядит как кортеж из одного элемента, но в действительности это просто число в скобках, как в школьной математике. Python видит скобки и решает, что те лишь группируют выражение. Чтобы получился кортеж, после элемента нужна запятая:

not_tuple = (5)
one = (5,)
also_one = 5,
print(type(not_tuple))
print(type(one))
print(type(also_one))
print(len(one))

Кортеж делает запятая, а не скобка. Скобки в языке часто нужны только для красоты, зато запятая всегда честно означает перечисление элементов. Пустой кортеж записывается как () и встречается в задачах редко, однако знать про него полезно, например для передачи пустой коллекции в функцию, которая чего-то ожидает.

Достаточно попытаться отредактировать кортеж, и реакция интерпретатора не заставит себя ждать:

colors = ("red", "green", "blue")
colors[0] = "yellow"

Python сразу ответит ошибкой TypeError: 'tuple' object does not support item assignment. Это не каприз языка, а защита. Кортеж обещает, что его содержимое никто не подменит ни случайно, ни специально. Если в программе живут данные, которые обязаны оставаться постоянными, например дни недели, названия месяцев или коэффициенты формулы, кортеж хранит их надёжнее списка: случайная правка не испортит данные тихо, вместо этого всплывёт громкая и понятная ошибка.

Тонкий момент: неизменяемость неглубокая. Если положить в кортеж список, сам список останется изменяемым:

mixed = (1, 2, [3, 4])
mixed[2].append(5)
print(mixed)

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

Распаковка кортежа и обмен значениями

Самое элегантное применение кортежей это распаковка. Содержимое кортежа раскладывается по нескольким переменным одной строкой:

point = (100, 250)
x, y = point
print(x)
print(y)
name, age, city = "Анна", 25, "Казань"
print(name, city, age)

Справа может стоять и готовый кортеж, и простое перечисление значений через запятую: Python всё равно сначала соберёт их в кортеж, а потом распределит по переменным. Та же механика позволяет обменять значения двух переменных без временной переменной. В большинстве языков для такого обмена заводят третью переменную, в Python хватает одной строки:

a, b = 1, 2
a, b = b, a
print(a, b)

Справа от знака равенства здесь создан кортеж (2, 1), который тут же распаковался в переменные слева. Ещё одна частая ситуация: функция возвращает несколько значений, и на самом деле она возвращает кортеж. Встроенная функция divmod() отдаёт сразу частное и остаток от деления:

result = divmod(17, 5)
print(result)
quotient, remainder = result
print(quotient, remainder)

Если нужны не все значения, лишние собираются в список через звёздочку:

first, *rest = (10, 20, 30, 40)
print(first)
print(rest)

Особенно красиво распаковка выглядит при переборе списка кортежей, а такая структура встречается сплошь и рядом, например при хранении координат:

points = [(0, 0), (1, 2), (3, 5)]
for x, y in points:
    print(x + y)

Распаковка встречается в чужом коде постоянно, поэтому привыкать к ней лучше сразу: она делает программы короче и выразительнее.

Выбор между кортежем и списком на практике

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

  1. Константы программы, например дни недели, месяцы или названия сторон света, не должны меняться, и кортеж гарантирует их неприкосновенность;
  2. Кортеж защищает от случайной правки: опечатка не сможет тихо испортить данные, вместо этого появится внятная ошибка;
  3. Кортеж занимает меньше памяти и создаётся быстрее списка, что становится заметным на больших объёмах;
  4. Кортеж годится в ключи словаря и в элементы множества, а список на такие роли не подходит;
  5. Запись (10, 20) в коде сама подсказывает читающему: эти два числа связаны и меняться не будут.

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

Множество хранит только уникальные элементы

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

letters = {"a", "b", "c"}
numbers = {1, 2, 2, 3, 3, 3}
print(numbers)
print(len(numbers))

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

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

print(set("молоко"))

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

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

empty_set = set()
empty_dict = {}
print(type(empty_set))
print(type(empty_dict))

Самый популярный трюк с множеством это очистка списка от повторов. Вместо цикла с проверками получается однострочка:

goods = ["хлеб", "молоко", "хлеб", "сыр", "молоко", "кефир"]
unique = list(set(goods))
print(unique)

Порядок при такой очистке теряется, поэтому приём подходит там, где последовательность не важна. Если порядок нужно сохранить, дубликаты убирают в цикле, но это уже совсем другая история.

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

Новый элемент добавляет метод add(). Удалить содержимое можно двумя способами: remove() выбрасывает KeyError, если элемента нет, а discard() молча пропускает отсутствие. Разница на первый взгляд мелкая, но в живом коде она избавляет от лишних проверок:

basket = {"яблоко", "груша"}
basket.add("слива")
basket.discard("банан")
basket.remove("груша")
print(basket)
basket.remove("банан")

Последняя строка вызовет KeyError, потому что банана в корзине нет и ждать его неоткуда. Когда элемент может отсутствовать, честнее брать discard().

Главные силы множеств раскрываются в операциях над двумя коллекциями. Объединение через | собирает все элементы из обоих множеств, пересечение через & оставляет только общие, разность через - убирает из первого множества то, что нашлось во втором:

monday = {"Анна", "Борис", "Вера"}
tuesday = {"Борис", "Глеб", "Дарья"}
print(monday | tuesday)
print(monday & tuesday)
print(monday - tuesday)

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

Практические задачи, которые решают множества

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

users = [101, 102, 103, 104, 105]
banned_ids = {103, 107}
for user_id in users:
    if user_id in banned_ids:
        print("Заблокированный пользователь:", user_id)

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

Третья задача это сравнение двух наборов данных: найти общих друзей двух людей, новые файлы в папке, товары, которые были в наличии вчера, но исчезли сегодня. Операции &, | и - решают подобные вопросы в одну строку.

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

frozen = frozenset([1, 2, 3])
print(frozen)

Когда множество не подходит? Если порядок элементов важен или дубликаты нужны по условию задачи, работает список. Если данные должны меняться строго по правилам, работает кортеж. Иногда коллекции объединяются: кортеж из уникальных значений получается парой строк unique = tuple(set(goods)).

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

Кортеж и множество закрывают последние пробелы в знании коллекций, а со следующего урока начинается самое любопытное: словари, коллекция из пар ключ-значение, где кортежи и множества встречаются на каждом шагу.