Кортежи в Python

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

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

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

Проще всего литерал кортежа в Python создается при помощи круглых скобок, внутри которых элементы кортежа перечисляются через запятую (см. пример №1). В случае необходимости последний элемент кортежа можно также завершать запятой. Это никак не повлияет на количество элементов кортежа, а значит и его длину. Однако, если кортеж состоит из одного элемента, то запятую после него нужно указывать обязательно, иначе интерпретатор не сможет отличить кортеж от простого значения или выражения.

Пример №1. Создание кортежей в Python (часть 1).

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

Создать кортеж можно также при помощи встроенного конструктора типа tuple(). Если использовать его без аргумента, то он вернет нам пустой кортеж. Если же передать ему итерируемый объект, например, строку или список, то конструктор вернет кортеж, элементами которого будут соответствующие элементы переданного объекта (см. пример №2).

Пример №2. Создание кортежей в Python (часть 2).

Что касается генераторов, то создать кортеж с их помощью не получится, т.к. как генераторы заключенные в круглые скобки сами являются «выражениями генераторами».

Операции доступа по индексу и получения срезов для кортежей имеют практически тот же самый синтаксис и смысл, что и для списков (см. пример №3).

Пример №3. Доступ к элементам кортежа по индексу (часть 1).

В принципе во многих случаях можно определять кортеж и без использования круглых скобок, т.к. для его определения важно именно наличие запятых между объектами, которые станут элементами кортежа. Однако все зависит от конкретной ситуации. Например, запись вида my_func(x, y) означает, что данной функции должно быть передано два аргумента, а запись my_func((x, y)) означает, что функции должен быть передан кортеж из двух элементов. Так что лучше всегда явно определять кортеж, используя для этого круглые скобки.

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

Пример №4. Доступ к элементам кортежа по индексу (часть 2).

Следует отметить, что цепочка доступа к конкретному элементу может иметь и более сложную конструкцию, включающую не только квадратные скобки с индексами для доступа к элементам строк, кортежей или списков, но и квадратные скобки с ключами для доступа к элементам словарей, и точки для доступа к атрибутам объектов. Например, для кортежа tpl = ({'one': 'top', 'two': ['abc', [4, 5]]}, 0.3) цепочка получения доступа ко второму элементу вложенного списка [4, 5] будет иметь вид tpl[0]['two'][1][1].

Что касается получения срезов для кортежей, то для них справедлив тот же порядок, что и для других упорядоченных коллекций, т.е. строк и списков (см. пример №5).

Пример №5. Операция взятия среза у кортежей.

Опять же, при извлечении срезов следует помнить, что нумерация элементов в кортежах начинается с нуля, а элемент с индексом второго предела, указанного в квадратных скобках, не будет присутствовать в срезе. Например, в срезе кортежа tpl_1[0:5] будут присутствовать первые пять элементов с индексами от 0 до 4, но не включая элемент с индексом 5.

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

Пример №6. Порядок использования шага среза у кортежей.

Как видим, шаг среза также может иметь отрицательное значение (аналогично спискам и строкам). В этом случае отсчет элементов кортежа и шагов ведется в противоположном направлении, а границы среза указываются справа налево, т.е. индекс элемента, стоящего правее в кортеже должен указываться первым. Например, в срезе примера tpl_1[-3:1:-3] отсчет ведется справа налево, начиная с 3-го элемента, отсчитываемого с конца кортежа, до элемента с индексом 1, который находится левее и в срез не включается.

Неизменяемость кортежей означает, что для них запрещены операции добавления новых элементов, а также удаления или замены уже существующих. При этом мы спокойно можем изменять конкретные элементы кортежа, если они это допускают (см. пример №7).

Пример №7. Изменение элементов кортежей.

Поскольку кортежи относятся к упорядоченным последовательностям, операторы +, +=, * и *= имеют для них практически тот же смысл, что и для списков и строк (см. пример №8).

Пример №8. Использование операторов + и * применительно к кортежам.

Незабываем, что по обе стороны от оператора сложения должны находиться кортежи (в общем случае это должны быть последовательности одного и того же типа), т.к. интерпретатор не занимается автоматическим приведением типов и просто выдаст ошибку.

Далее. В отношении элементов кортежа мы можем использовать оператор проверки на вхождение in, который совершает поиск требуемого объекта (левый операнд) среди элементов целевого кортежа (правый операнд). Опять же, в случае успеха операция возвращает True, иначе – False (см. пример №9).

Пример №9. Использование оператора in применительно к кортежам.

Напомним, что оператор in может использоваться не только самостоятельно, но и совместно с оператором отрицания not, который инверсирует возвращаемое логическое значение оператора in. Соответственно, например, операция 'крот' not in ('кот', 'кит') вернет True вместо False.

Если возникает необходимость в обходе элементов кортежа, то, по аналогии со строками и списками, можно смело использовать оператор цикла for (см. пример №10).

Пример №10. Использование цикла for для обхода элементов кортежа.

Поскольку кортежи относятся к неизменяемым последовательностям, оператор удаления del к элементам кортежа неприменим, хотя сам кортеж данный оператор спокойно удаляет.

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

• tpl.count(x) – возвращает количество элементов с указанным значением x в целевом кортеже tpl (см. пример №11). Отметим, что в отличие от аналогичного метода для строк, здесь указывать интервал для поиска нельзя, т.к. метод принимает только один аргумент.
• tpl.index(x[, start[, end]]) – возвращает индекс i первого вхождения элемента tpl[i] со значением x в целевой кортеж tpl или в срез кортежа tpl[start:end], если он задан. В случае неудачного поиска метод вызывает исключение ValueError. Обратите внимание, что при использовании среза отсчет индекса элемента все равно стартует с начала всего кортежа.

Пример №11. Методы кортежей.

Применимы к кортежам и некоторые встроенные функции, которые получают доступ к элементам кортежа, но не изменяют его непосредственно: len() (возвращает количество элементов в кортеже), min() (возвращает элемент с минимальным значением, при этом элементы должны быть одного типа с возможностью сравнения), max() (возвращает элемент с максимальным значением, при этом элементы должны быть одного типа с возможностью сравнения), sum() (возвращает сумму элементов кортежа, при этом элементы должны быть числами) и т. д.

«Ну, и зачем нам эти кортежи, если есть списки?» – часто спрашивают начинающие программисты. Действительно, кортежи копируют списки и при этом сильно ограничены в возможностях, да еще и неизменяемые. Однако ключевая мысль здесь – «неизменяемые». Благодаря этому мы можем быть уверены, что кортеж не будет изменен через другую ссылку в другом месте программы. Кроме того, встречаются ситуации, когда использование списков недопустимо, например, в качестве ключей словаря кортежи можно использовать, а списки нет. Именно поэтому, когда в программе нужно использовать упорядоченные коллекции объектов с возможностью их изменения в будущем, нужно выбирать списки; если же нужны фиксированные коллекции объектов, следует выбирать кортежи.

Хотя сами кортежи и неизменяемы, они могут содержать элементы изменяемых типов (например, списки или словари), а те могут быть изменены программой. Такие кортежи использовать в качестве ключей словаря не получится.

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

Пример №12. Отличие кортежей от списков.

• В Python кортежи представляют собой упорядоченные, но неизменяемые, коллекции объектов произвольного типа с доступом по индексу.
• Чтобы создать кортеж достаточно перечислить требуемые объекты (элементы кортежа) через запятую внутри круглых скобок (например, tpl = (3.7, 'оса', [1, 2])). Здесь стоит не забывать, что если таким образом создается кортеж с одним элементом, после него следует ставить запятую (например, tpl = (7,)).
• Также кортежи могут быть созданы при помощи функции tuple(iterable) (например, инструкция tuple('abc') вернет кортеж ('a', 'b', 'c')).
• Использовать для создания кортежей генераторы нельзя, т.к. генераторы заключенные в круглые скобки сами являются «выражениями генераторами».
• После создания кортежа доступ к любому элементу кортежа можно получить по его индексу, т.е. порядковому номеру элемента в кортеже. При этом следует помнить, что индексация элементов в кортежах начинается с нуля (например, инструкция print(tpl[1]) выведет второй элемент последнего кортежа, т.е. строку 'b').
• Что касается срезов, то для кортежей они имеют практически тот же смысл, что и для строк и списков. Главное не забывать, что кортежи неизменяемы, и не пытаться использовать срезы для замены, удаления или добавления элементов в кортеж.
• Арифметические операторы + и *, а также их комбинированные собратья += и *=, работают с кортежами по хорошо известной нам схеме, т.е. практически так же, как со строками и списками.
• Оператор удаления del в отношении элементов кортежа неприменим. А вот оператор in и цикл for как раз наоборот: первый как всегда совершает поиск требуемого объекта среди элементов целевого кортежа, а второй позволяет поочередно обойти все его элементы.
• Из методов для кортежей доступны только общие методы упорядоченных последовательностей. Это tpl.count(x), который подсчитывает количество элементов с указанным значением x, и tpl.index(x[, start[, end]]), который возвращает индекс i первого вхождения в кортеж элемента tpl[i] со значением x). Найти эти методы можно в подразделе «Sequence Types – list, tuple, range» раздела «Built-in types» стандартной библиотеки.
• Благодаря своей неизменяемости кортежи занимают в памяти меньше места, чем списки, а операции с ними являются более производительными. При этом следует помнить, что хотя сами кортежи и неизменяемы, их элементы изменяемых типов (например, списки или словари) могут быть изменены программой (такие кортежи использовать в качестве ключей словаря не получится).

1. Какие из утверждений относятся к кортежам: коллекция объектов, упорядоченная последовательность, неизменяемая и неупорядоченная последовательность, изменяемая неупорядоченная коллекция объектов, неизменяемая упорядоченная последовательность элементов? Показать решение.

2. Разрешается ли использовать в качестве элементов кортежа списки? Показать решение.

3. Для чего нужны кортежи, если есть списки? Показать решение.

4. Какие из представленых литералов относятся к типу tuple: ('tuple', 'list'), '(3, 4)', (5,), 'Питон, Python'? Проверьте типы программно. Показать решение.

# Выводим типы представленных литералов.
print("Тип ('tuple', 'list'):", type(('tuple', 'list')))
print("Тип '(3, 4)':", type('(3, 4)'))
print("Тип (5,):", type((5,)))
print("Тип 'Питон, Python':", type('Питон, Python'))

Тип ('tuple', 'list'): <class 'tuple'>
Тип '(3, 4)': <class 'str'>
Тип (5,): <class 'tuple'>
Тип 'Питон, Python': <class 'str'>
			

5. Дан кортеж (([1, 2], ['012', 'abc']), [4, 3]). Как получить доступ к символу 'c' строки 'abc'? Показать решение.

# Сохраняем кортеж в переменной.
tpl = (([1, 2], ['012', 'abc']), [4, 3])
# Используем цепочку доступа по индексу.		
print(tpl[0][1][1][2])

c


			

6. Какие значения будут присвоены переменным в инструкциях tpl_1 = (1, 2, 3, 4, 5, 6, 7)[1:4], tpl_2 = (1, 2, 3, 4, 5, 6, 7)[-4:-3] и tpl_3 = (1, 2, 3, 4, 5, 6, 7)[::2]? Проверьте свой ответ программно. Показать решение.

# Получаем срезы.
tpl_1 = (1, 2, 3, 4, 5, 6, 7)[1:4]  
tpl_2 = (1, 2, 3, 4, 5, 6, 7)[-4:-3]
tpl_3 = (1, 2, 3, 4, 5, 6, 7)[::2]

# Выведет (2, 3, 4].
print('tpl_1:', tpl_1)
# Выведет (4,) (с запятой!).
print('tpl_2:', tpl_2)         
# Выведет (1, 3, 5, 7).
print('tpl_3:', tpl_3)

tpl_1: (2, 3, 4)
tpl_2: (4,)
tpl_3: (1, 3, 5, 7)
 



 
 
 
 

7. Имеется кортеж (1, 2, 3). В нем необходимо заменить первый элемент и получить кортеж (5, 2, 3). Как это сделать, ведь кортежи неизменяемы? Показать решение.

# Сохраним кортеж в переменной.
tpl = (1, 2, 3)

# Создаем новый кортеж, используя операции 
# конкатенации и извлечения среза.
tpl_1 = (5,) + tpl[1:]
# Выводим новый кортеж на экран.
print(tpl_1)		

# Используем дорогостоящую операцию 
# преобразования в список и обратно.
li = list(tpl)
li[0] = 5
tpl_2 = tuple(li)
# Выводим новый кортеж на экран.
print(tpl_2)

(5, 2, 3)
(5, 2, 3)
 
 
 
 
 
 
 
 
 
 
 
 
 
			

8. Что произойдет, если в кортеже (1, [2, 3]) попытаться изменить в списке одно из значений? Объясните свой ответ. Показать решение.

# Целевой кортеж.
tpl = (1, [2, 3])  
# Выведет (1, [2, 3]).
print('tpl:', tpl)

# Вносим изменения в список.
tpl[1][0] = 5  
# Выведет (1, [5, 3]).
print('tpl:', tpl)

tpl: (1, [2, 3])
tpl: (1, [5, 3])
 
 
 
 
  
 
			

9. Что можно сказать про методы с именами count, split, index и clear в контексте кортежей? Показать решение.

10. Дополнительные тесты по теме расположены в разделе «Кортежи» нашего сборника тестов.

11. Дополнительные упражнения и задачи по теме расположены в разделе «Кортежи» нашего сборника задач и упражнений.

• Списки в Python
• Кортежи в Python
• Словари в Python
• Вернуться к содержанию