Кортежи Python: полное руководство

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

Что такое кортеж в Python?

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

Три ключевых свойства определяют кортежи:

• Упорядоченность — элементы имеют фиксированную позицию (индекс 0, 1, 2, …).
• Неизменяемость — после создания нельзя изменять, добавлять или удалять элементы.
• Допускает дубликаты — одно и то же значение может встречаться несколько раз.

Кортежи vs. списки

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

Используйте кортеж, когда данные не должны меняться — константы конфигурации, возвращаемые функцией значения, несущие несколько связанных данных, или ключи словаря.

Создание кортежей

Базовый синтаксис

Перечислите значения через запятую внутри круглых скобок:

Смешанные типы

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

mixed = (1, 'hello', 3.14, True)
print(mixed)
# Output: (1, 'hello', 3.14, True)

Пустой кортеж

empty = ()
print(empty)        # Output: ()
print(type(empty))  # Output: <class 'tuple'>

Кортеж из одного элемента

Это распространённая ловушка. Без завершающей запятой Python воспринимает скобки как группировку, а не кортеж:

not_a_tuple = (42)
print(type(not_a_tuple))  # Output: <class 'int'>

real_tuple = (42,)
print(type(real_tuple))   # Output: <class 'tuple'>

Завершающая запятая делает выражение кортежем — всегда включайте её для кортежей из одного элемента.

Создание из итерируемого объекта

Используйте встроенный конструктор tuple() для преобразования любого итерируемого объекта в кортеж:

Кортеж без скобок (упаковка)

Python позволяет создать кортеж, просто перечислив значения через запятую — скобки необязательны:

packed = 1, 2, 3
print(packed)        # Output: (1, 2, 3)
print(type(packed))  # Output: <class 'tuple'>

Доступ к элементам кортежа

Положительная индексация

Индексы начинаются с 0 для первого элемента:

Отрицательная индексация

Отрицательные индексы отсчитываются с конца. -1 — это последний элемент:

Срезы

Используйте [start:stop:step] для извлечения подкортежа. Индекс stop не включается:

t = (0, 1, 2, 3, 4)
print(t[1:4])   # Output: (1, 2, 3)
print(t[:3])    # Output: (0, 1, 2)
print(t[2:])    # Output: (2, 3, 4)
print(t[::2])   # Output: (0, 2, 4)

Вложенные кортежи

Доступ к вложенным элементам осуществляется цепочкой квадратных скобок:

nested = ((1, 2), (3, 4), (5, 6))
print(nested[1])     # Output: (3, 4)
print(nested[1][0])  # Output: 3

Проверка наличия элемента

Оператор in проверяет, существует ли значение в кортеже:

fruits = ('apple', 'banana', 'cherry')
print('banana' in fruits)  # Output: True
print('mango' in fruits)   # Output: False

Дополнительные техники индексации и срезов см. в разделе Доступ к кортежам.

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

После создания элементы кортежа нельзя изменить:

my_tuple = (1, 2, 3)
my_tuple[0] = 99  # TypeError: 'tuple' object does not support item assignment

Если нужна изменённая версия, создайте новый кортеж из срезов и конкатенации:

Обратите внимание, что кортеж может содержать изменяемые объекты, например списки. Сам кортеж неизменяем (нельзя заменить ссылку на список), но список внутри по-прежнему можно изменять.

Полное обсуждение способов обхода ограничений см. в разделе Обновление кортежей.

Операции с кортежами

Конкатенация с помощью +

Объединение двух кортежей с помощью + создаёт новый кортеж:

t1 = (1, 2)
t2 = (3, 4)
print(t1 + t2)
# Output: (1, 2, 3, 4)

Повторение с помощью *

Повторите содержимое кортежа с помощью *:

t = (0,) * 3
print(t)
# Output: (0, 0, 0)

Все стратегии объединения см. в разделе Объединение кортежей.

Методы кортежей

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

count()

Возвращает количество вхождений значения:

index()

Возвращает индекс первого вхождения значения. Вызывает ValueError, если значение не найдено:

Полный справочник см. в разделе Методы кортежей.

Встроенные функции для работы с кортежами

Встроенные функции Python работают с любыми итерируемыми объектами, включая кортежи:

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

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

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

Расширенная распаковка с *

Переменная со звёздочкой поглощает произвольное количество оставшихся элементов в список:

first, *rest = (10, 20, 30, 40)
print(first)  # Output: 10
print(rest)   # Output: [20, 30, 40]

Обмен переменными

Распаковка кортежей позволяет обменять переменные одной строкой — без временной переменной:

x, y = 5, 10
x, y = y, x
print(x, y)
# Output: 10 5

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

Перебор кортежа

Цикл for обходит каждый элемент по порядку:

fruits = ('apple', 'banana', 'cherry')
for fruit in fruits:
    print(fruit)
# Output:
# apple
# banana
# cherry

Используйте enumerate(), когда нужен также индекс:

for i, fruit in enumerate(fruits):
    print(i, fruit)
# Output:
# 0 apple
# 1 banana
# 2 cherry

Циклы while, zip() и обход вложенных кортежей см. в разделе Цикл по кортежам.

Создание кортежей из генераторных выражений

В Python нет синтаксиса включений для кортежей, но можно передать генераторное выражение в tuple() для получения того же результата:

Выражение x**2 for x in my_list внутри tuple() — это генератор: он производит значения по одному, не создавая промежуточного списка.

Когда использовать кортежи

Кортежи особенно хороши в следующих ситуациях:

• Несколько возвращаемых значений. Функции могут чисто возвращать несколько значений в виде кортежа: return x, y.
• Ключи словаря. Списки не могут быть ключами словаря, поскольку они изменяемы; кортежи — могут.
• Целостность данных. Если коллекция не должна меняться — значения RGB, строка базы данных, географические координаты — кортеж обеспечивает это на уровне языка.
• Небольшое преимущество в производительности. Перебор и создание кортежей немного быстрее аналогичных операций со списками.

# Using a tuple as a dictionary key
locations = {}
locations[(48.8566, 2.3522)] = 'Paris'
locations[(51.5074, -0.1278)] = 'London'
print(locations[(48.8566, 2.3522)])
# Output: Paris

Практика