Кортежи в Python (tuple): создание, распаковка и методы

Кортеж в Python (tuple) — упорядоченная неизменяемая последовательность. Короткий ответ: кортеж создаётся через запятую в круглых скобках point = (3, 4), элемент читается по индексу point[0], а кортеж из одного элемента обязательно пишется с запятой: (5,). Изменить, добавить или удалить элемент после создания нельзя.

Ниже — как создать tuple в Python, работать с индексами, распаковывать кортежи, какие у них методы и когда кортеж лучше списка. Все примеры проверены на Python 3.12; вывод показан комментарием # →.

Как создать кортеж

point = (3, 4)
colors = "red", "green", "blue"   # скобки не обязательны
empty = ()
single = (5,)                     # один элемент — с запятой
from_list = tuple([1, 2, 3])
from_str = tuple("abc")

print(type(colors))  # → <class 'tuple'>
print(single)        # → (5,)
print(from_list)     # → (1, 2, 3)
print(from_str)      # → ('a', 'b', 'c')
print(len(empty))    # → 0

Кортеж создаёт запятая, а не скобки. Скобки лишь группируют выражение, поэтому (5) — это просто число:

x = (5)
y = (5,)
print(type(x))  # → <class 'int'>
print(type(y))  # → <class 'tuple'>

Функция tuple() превращает в кортеж любую коллекцию: список, строку, range, множество.

Индексы и срезы

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

days = ("пн", "вт", "ср", "чт", "пт", "сб", "вс")
print(days[0])     # → пн
print(days[-1])    # → вс
print(days[:5])    # → ('пн', 'вт', 'ср', 'чт', 'пт')
print(days[::2])   # → ('пн', 'ср', 'пт', 'вс')
print("сб" in days)  # → True
print(len(days))     # → 7

Неизменяемость кортежа

После создания кортеж нельзя изменить: ни присвоить элемент, ни добавить, ни удалить.

point = (3, 4)
point[0] = 10  # → TypeError: 'tuple' object does not support item assignment
point.append(5)  # → AttributeError: 'tuple' object has no attribute 'append'

Операция += не меняет кортеж, а создаёт новый и привязывает к нему имя. Другие ссылки на старый кортеж его не видят:

t = (1, 2)
alias = t
t += (3,)
print(t)      # → (1, 2, 3)
print(alias)  # → (1, 2)

Изменяемые объекты внутри кортежа

Неизменяем сам кортеж — набор ссылок на объекты. Если внутри лежит список, этот список можно менять:

data = ([1, 2], "текст")
data[0].append(3)
print(data)  # → ([1, 2, 3], 'текст')
hash(data)   # → TypeError: unhashable type: 'list'

Такой кортеж уже нельзя использовать как ключ словаря или элемент множества — он перестал быть хешируемым.

Распаковка кортежа

Распаковка присваивает элементы кортежа нескольким переменным сразу. Количество переменных должно совпадать с количеством элементов:

point = (3, 4)
x, y = point
print(x, y)  # → 3 4

a, b = 1, 2
a, b = b, a          # обмен значений без временной переменной
print(a, b)  # → 2 1

Звёздочка собирает «лишние» элементы в список, а _ по соглашению обозначает ненужное значение:

first, *rest = (1, 2, 3, 4)
print(first, rest)   # → 1 [2, 3, 4]
head, *_, tail = (10, 20, 30, 40)
print(head, tail)    # → 10 40
name, _, age = ("Анна", "Москва", 30)
print(name, age)     # → Анна 30

Распаковка работает и в заголовке цикла for — так удобно обходить список пар:

users = [("Анна", 30), ("Олег", 25)]
for name, age in users:
    print(f"{name}: {age}")

Анна: 30
Олег: 25

Тот же механизм используют dict.items() и enumerate: они выдают кортежи, которые распаковываются в две переменные.

Возврат нескольких значений из функции

Когда функция возвращает несколько значений через запятую, на самом деле она возвращает один кортеж:

def min_max(numbers):
    return min(numbers), max(numbers)

result = min_max([4, 1, 9, 7])
print(result)        # → (1, 9)
low, high = min_max([4, 1, 9, 7])
print(low, high)     # → 1 9

Методы кортежа и операции

У кортежа всего два метода — count() и index(). Всё, что меняет коллекцию (append, remove, sort), есть только у списка.

t = (1, 2, 2, 3, 2)
print(t.count(2))    # → 3
print(t.index(3))    # → 3
print(t.index(2))    # → 1   первое вхождение
t.index(10)          # → ValueError: tuple.index(x): x not in tuple

Остальное делают общие операции и встроенные функции:

a = (1, 2)
b = (3,)
print(a + b)          # → (1, 2, 3)
print(a * 3)          # → (1, 2, 1, 2, 1, 2)
print(min(a), max(a), sum(a))  # → 1 2 3
print(sorted((3, 1, 2)))       # → [1, 2, 3]
print(tuple(sorted((3, 1, 2))))  # → (1, 2, 3)
print(tuple(reversed(a)))      # → (2, 1)

sorted() всегда возвращает список — чтобы получить отсортированный кортеж, оберните результат в tuple().

Метод / операция	Что делает
t[i], t[a:b]	элемент по индексу, срез (новый кортеж)
t.count(x)	сколько раз x встречается
t.index(x)	индекс первого x, ValueError если его нет
len(t), x in t	длина, проверка вхождения
t1 + t2, t * n	склейка, повторение — новый кортеж
min(), max(), sum()	минимум, максимум, сумма
sorted(t)	отсортированный список
tuple(x), list(t)	преобразование коллекции в кортеж и обратно

Как «изменить» кортеж

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

t = (3, 1, 2)
items = list(t)
items.append(4)
t = tuple(items)
print(t)  # → (3, 1, 2, 4)

Если так приходится делать постоянно, скорее всего, данным нужен список, а не кортеж.

Чем кортеж отличается от списка

Признак	list	tuple
Запись	[1, 2, 3]	(1, 2, 3) или 1, 2, 3
Изменяемость	да	нет
Методы	append, remove, sort и др.	только count и index
Ключ словаря, элемент set	нельзя	можно, если все элементы хешируемые
Типичное применение	однородные данные, которые растут	запись фиксированной структуры

Список подходит для набора однотипных значений, который будет меняться: товары в корзине, строки файла. Кортеж — для записи с фиксированными полями: координаты (x, y), пара «имя — возраст», RGB-цвет. Неизменяемость защищает такие данные от случайной правки.

Кортеж как ключ словаря

Главное практическое отличие — хешируемость. Кортеж можно сделать ключом словаря или положить в множество, список — нельзя:

distances = {("Москва", "Казань"): 820, ("Москва", "Тверь"): 180}
print(distances[("Москва", "Тверь")])  # → 180
visited = {(0, 0), (0, 1)}
print((0, 1) in visited)  # → True
distances[["Москва", "Сочи"]] = 1600  # → TypeError: unhashable type: 'list'

Память

Кортеж занимает немного меньше памяти, чем список с теми же элементами: списку нужны служебные поля для изменения размера и запас под будущие добавления. На 64-битном Python 3.12:

import sys
print(sys.getsizeof([1, 2, 3]))  # → 88
print(sys.getsizeof((1, 2, 3)))  # → 64

Точные числа зависят от версии и платформы, а сама разница редко бывает причиной выбора — решает смысл данных.

Сравнение и сортировка кортежей

Кортежи сравниваются поэлементно слева направо: первое различие определяет результат.

print((1, 2, 3) < (1, 3))     # → True
print((2, "a") > (1, "z"))    # → True
print((1, 2) == (1, 2))       # → True

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

students = [("Олег", 4), ("Анна", 5), ("Иван", 4)]
print(sorted(students, key=lambda s: (-s[1], s[0])))
# → [('Анна', 5), ('Иван', 4), ('Олег', 4)]

Именованный кортеж: namedtuple

Если обращение p[0] плохо читается, используйте namedtuple из модуля collections: это кортеж, к элементам которого можно обращаться по имени.

from collections import namedtuple

Point = namedtuple("Point", ["x", "y"])
p = Point(3, 4)
print(p)          # → Point(x=3, y=4)
print(p.x, p[1])  # → 3 4
print(p._replace(x=10))  # → Point(x=10, y=4)

namedtuple остаётся неизменяемым: _replace() возвращает новый объект. Для более сложных записей с методами обычно пишут класс или dataclass.

Частые ошибки

Кортеж из одного элемента без запятой

(5) — это число 5, а ("abc") — строка. Кортеж из одного элемента — (5,) или ("abc",).

Случайная запятая в конце строки

Обратная ситуация: лишняя запятая превращает значение в кортеж.

total = 10,
print(total)        # → (10,)
print(total + 5)    # → TypeError: can only concatenate tuple (not "int") to tuple

Число переменных при распаковке не совпадает

x, y = (1, 2, 3)     # → ValueError: too many values to unpack (expected 2)
x, y, z = (1, 2)     # → ValueError: not enough values to unpack (expected 3, got 2)

Проверьте длину кортежа или соберите лишнее звёздочкой: x, *rest = (1, 2, 3).

Попытка изменить элемент

TypeError: 'tuple' object does not support item assignment означает, что вы пытаетесь присвоить значение элементу кортежа. Создайте новый кортеж или используйте список.

tuple() от числа

tuple(5) вызывает TypeError: 'int' object is not iterable: функция tuple() ожидает коллекцию. Для кортежа из одного числа пишите (5,).

Частые вопросы

Как превратить кортеж в строку?

Метод join склеивает только строки, поэтому числа сначала преобразуют через map(str, ...).

t = (2026, 10, 10)
print("-".join(map(str, t)))  # → 2026-10-10

Как отсортировать список кортежей по второму элементу?

Передайте в sorted() ключ, который возвращает нужный элемент: lambda p: p[1] или operator.itemgetter(1).

pairs = [("Олег", 25), ("Анна", 31), ("Иван", 19)]
print(sorted(pairs, key=lambda p: p[1]))
# → [('Иван', 19), ('Олег', 25), ('Анна', 31)]

Как развернуть кортеж?

Срез с шагом -1 возвращает новый кортеж в обратном порядке: t[::-1]. Метода reverse() у кортежа нет.

t = (1, 2, 3)
print(t[::-1])  # → (3, 2, 1)

Кортеж работает быстрее списка?

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

Как проверить, что переменная — кортеж?

Используйте isinstance(x, tuple). Проверка вернёт True и для namedtuple, потому что именованный кортеж — подкласс tuple.

Итог

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