Курс по Python: https://stepik.org/course/100707

Смотреть материал на видео

На этом занятии мы с вами познакомимся с еще одной новой коллекцией данных – кортежами. Что такое кортеж? Это упорядоченная, но неизменяемая коллекция произвольных данных. Они, в целом, аналогичны спискам, но в отличие от них, элементы кортежей менять нельзя – это неизменяемый тип данных.

• Для задания кортежа достаточно перечислить значения через запятую:
• или, что то же самое, в круглых скобках:
• Но, обратите внимание, при определении кортежа с одним значение, следует использовать такой синтаксис:
• b = 1,     или    b = (1,)

Здесь висячая запятая указывает, что единицу следует воспринимать как первый элемент кортежа, а не как число 1. Без запятой – это будет уже просто число один. Вот это нужно очень хорошо запомнить, начинающие программисты здесь часто делают ошибку, не прописывая висячую запятую.

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

• по индексу: a[0]     a[2]           a[-1]
• через срезы: a[1:2]      a[0:-1]        a[:3]           a[1:]         a[:]

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

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

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

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

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

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

В-третьих, кортеж занимает меньше памяти, чем такой же список, например:

lst=[1,2,3]
t = (1,2,3)
print(lst.__sizeof__())
print(t.__sizeof__())

Как видите, размер кортежа меньше, чем списка. Здесь использован метод __sizeof__, который возвращает размер данных в байтах.

1. Из всего этого можно сделать такой общий вывод: если мы работаем с неизменяемым упорядоченным списком, то предпочтительнее использовать кортеж.
2. Теперь, когда мы поняли, что кортежи играют свою значимую роль в программах на Python, вернемся к их рассмотрению. Чтобы создать пустой кортеж можно просто записать круглые скобки:
3. или воспользоваться специальной встроенной функцией:

b = tuple()
print(type(a), type(b))

Но здесь сразу может возникнуть вопрос: зачем создавать пустой кортеж, если он относится к неизменяемым типам данных? Слово неизменяемый наводит на мысль, что вид кортежа остается неизменным. Но это не совсем так. В действительности, мы лишь не можем менять уже существующие элементы в кортеже, но можем создавать новые, используя оператор +, например:

• или для добавления данных в начало кортежа:
• Также можно добавить вложенный кортеж:
• или дублировать элементы кортежа через оператор *, подобно спискам:

b = (0,)*10
b = («hello», «world») * 5

Как видите, все эти операции вполне допустимы. А вот удалять отдельные его элементы уже нельзя. Если мы попытаемся это сделать:

1. то возникнет ошибка. Правда, можно удалить объект целиком:
2. тогда кортеж просто перестанет существовать, не будет даже пустого кортежа, здесь объект удаляется целиком.
3. Далее, с помощью функции tuple() можно создавать кортежи на основе любого итерируемого объекта, например, списков и строк:

a = tuple([1,2,3])
a = tuple(«Привет мир»)

А если нам нужно превратить кортеж в список, то подойдет известная нам функция list(), которая формирует список также из любого итерируемого объекта:

t = (1,2,3)
lst = list(t)

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

a = (True, [1,2,3], «hello», 5, {«house»: «дом»})

Причем, смотрите, если обратиться, например, к списку:

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

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

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

• tuple.count(значение) – возвращает число найденных элементов с указанным значением;
• tuple.index(значение[, start[, stop]]) – возвращает индекс первого найденного элемента с указанным значением (start и stop – необязательные параметры, индексы начала и конца поиска).

Эти методы работают так же, как и у списков. Пусть у нас есть кортеж:

a = («abc», 2, [1,2], True, 2, 5)

И мы хотим определить число элементов со значениями:

a.count(«abc»)
a.count(2)

1. Как видите, метод count() возвращает число таких элементов в кортеже. Если же элемент не будет найден:
2. то возвращается 0. Следующий метод:
3. возвращает индекс первого найденного элемента с указанным значением. Если значение не найдено:
4. то этот метод приводит к ошибке. Поэтому, прежде чем его использовать, лучше проверить, а есть ли такое значение вообще в кортеже:
5. Второй необязательный параметр

позволяет задавать индекс начала поиска. В данном случае поиск будет начинаться с третьего индекса. А последний третий аргумент:

определяет индекс, до которого идет поиск (не включая его). Если же записать вот так:

то возникнет ошибка, т.к. в поиск будет включен только 3-й индекс и там нет значения 2.

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

https://www.youtube.com/watch?v=pf3V5rr30Ts\u0026pp=ygVJ0JrQvtGA0YLQtdC20Lgg0LIgUHl0aG9uOiDQvtGB0L3QvtCy0L3Ri9C1INC80LXRgtC-0LTRiyDQuCDRhNGD0L3QutGG0LjQuA%3D%3D

Курс по Python: https://stepik.org/course/100707

#1. Первое знакомство с Python Установка на компьютер

#2. Варианты исполнения команд. Переходим в PyCharm

#3. Переменные, оператор присваивания, функции type и id

#4. Числовые типы, арифметические операции

#5. Математические функции и работа с модулем math

#6. Функции print() и input(). Преобразование строк в числа int() и float()

#7. Логический тип bool. Операторы сравнения и операторы and, or, not

#8. Введение в строки. Базовые операции над строками

#9. Знакомство с индексами и срезами строк

#10. Основные методы строк

#11. Спецсимволы, экранирование символов, row-строки

#12. Форматирование строк: метод format и F-строки

#13. Списки — операторы и функции работы с ними

#14. Срезы списков и сравнение списков

#15. Основные методы списков

#16. Вложенные списки, многомерные списки

#17. Условный оператор if. Конструкция if-else

#18. Вложенные условия и множественный выбор. Конструкция if-elif-else

#19. Тернарный условный оператор. Вложенное тернарное условие

#20. Оператор цикла while

#21. Операторы циклов break, continue и else

#22. Оператор цикла for. Функция range()

#23. Примеры работы оператора цикла for. Функция enumerate()

#24. Итератор и итерируемые объекты. Функции iter() и next()

#25. Вложенные циклы. Примеры задач с вложенными циклами

#26. Треугольник Паскаля как пример работы вложенных циклов

#27. Генераторы списков (List comprehensions)

#28. Вложенные генераторы списков

#29. Введение в словари (dict). Базовые операции над словарями

#30. Методы словаря, перебор элементов словаря в цикле

#31. Кортежи (tuple) и их методы

#32. Множества (set) и их методы

#33. Операции над множествами, сравнение множеств

#34. Генераторы множеств и генераторы словарей

#35. Функции: первое знакомство, определение def и их вызов

#36. Оператор return в функциях. Функциональное программирование

#37. Алгоритм Евклида для нахождения НОД

#38. Именованные аргументы. Фактические и формальные параметры

#39. Функции с произвольным числом параметров *args и **kwargs

#40. Операторы * и ** для упаковки и распаковки коллекций

#41. Рекурсивные функции

#42. Анонимные (lambda) функции

#43. Области видимости переменных. Ключевые слова global и nonlocal

#44. Замыкания в Python

#45. Введение в декораторы функций

#46. Декораторы с параметрами. Сохранение свойств декорируемых функций

#47. Импорт стандартных модулей. Команды import и from

#48. Импорт собственных модулей

#49. Установка сторонних модулей (pip install). Пакетная установка

#50. Пакеты (package) в Python. Вложенные пакеты

#51. Функция open. Чтение данных из файла

#52. Исключение FileNotFoundError и менеджер контекста (with) для файлов

#53. Запись данных в файл в текстовом и бинарном режимах

#54. Выражения генераторы

#55. Функция-генератор. Оператор yield

#56. Функция map. Примеры ее использования

#57. Функция filter для отбора значений итерируемых объектов

#58. Функция zip. Примеры использования

#59. Сортировка с помощью метода sort и функции sorted

#60. Аргумент key для сортировки коллекций по ключу

#61. Функции isinstance и type для проверки типов данных

#62. Функции all и any. Примеры их использования

#63. Расширенное представление чисел. Системы счисления

#64. Битовые операции И, ИЛИ, НЕ, XOR. Сдвиговые операторы

#65. Модуль random стандартной библиотеки

#66. Аннотация базовыми типами

#67. Аннотации типов коллекций

#68. Аннотации типов на уровне классов

#69. Конструкция match/case. Первое знакомство

#70. Конструкция match/case с кортежами и списками

#71. Конструкция match/case со словарями и множествами

#72. Конструкция match/case. Примеры и особенности использования

Кортежи Python и основные операции

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

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

Кортеж в Python можно записать как набор значений, разделенных запятыми(,), заключенных в маленькие скобки(). Скобки необязательны, но их рекомендуется использовать. Кортеж можно определить следующим образом.

T1 =(101, «Peter», 22)
T2 =(«Apple», «Banana», «Orange»)
T3 = 10,20,30,40,50

print(type(T1))
print(type(T2))
print(type(T3))

Выход:

Примечание. Кортеж, созданный без скобок, также известен как упаковка кортежа.

Пустой кортеж можно создать следующим образом.

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

tup1 =(«JavaTpoint»)
print(type(tup1))
#Creating a tuple with single element
tup2 =(«JavaTpoint»,)
print(type(tup2))

Выход:

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

Рассмотрим следующие примеры кортежа:

Пример 1.

tuple1 =(10, 20, 30, 40, 50, 60)
print(tuple1)
count = 0
for i in tuple1:
print(«tuple1[%d] = %d»%(count, i))
count = count+1

Выход:

(10, 20, 30, 40, 50, 60)
tuple1[0] = 10
tuple1[1] = 20
tuple1[2] = 30
tuple1[3] = 40
tuple1[4] = 50
tuple1[5] = 60

Пример 2.

tuple1 = tuple(input(«Enter the tuple elements …»))
print(tuple1)
count = 0
for i in tuple1:
print(«tuple1[%d] = %s»%(count, i))
count = count+1

Выход:

Enter the tuple elements …123456('1', '2', '3', '4', '5', '6')
tuple1[0] = 1
tuple1[1] = 2
tuple1[2] = 3
tuple1[3] = 4
tuple1[4] = 5
tuple1[5] = 6

Индексирование и нарезка кортежей

Индексация и нарезка кортежа аналогичны спискам. Индексирование в кортеже начинается с 0 и продолжается до длины(tuple) – 1.

Доступ к элементам в кортеже можно получить с помощью оператора index []. Python также позволяет нам использовать оператор двоеточия для доступа к нескольким элементам в кортеже.

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

Рассмотрим следующий пример:

tup =(1,2,3,4,5,6,7)
print(tup[0])
print(tup[1])
print(tup[2])
# It will give the IndexError
print(tup[8])

Выход:

Tuples / Кортежи в Python

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

В этом руководстве вы познакомитесь с кортежами Python в подробностях:

• Узнаете, как их создавать. Увидите, что значит неизменяемый тип на примерах
• Разберетесь, чем кортежи в Python отличаются от списков
• Познакомитесь с операциями: срезами, конкатенацией, умножением и так далее
• Увидите встроенные функции
• Научитесь присваивать сразу несколько значений кортежами

Кортеж Python

Эта структура данных используется для хранения последовательности упорядоченных и неизменяемых элементов.

https://www.youtube.com/watch?v=pf3V5rr30Ts\u0026pp=YAHIAQE%3D

Кортежи создают с помощью круглых скобок (). Для создания нужно написать следующее:

cake = ('c','a','k','e') print(type(cake))

Примечание: type() — это встроенная функция для проверки типа данных переданного параметра.

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

mixed_type = ('C',0,0,'K','I','E') for i in mixed_type: print(i,»:»,type(i))
C :
0 :
0 :
K :
I :
E :

mixed_type[1] = «O»
—————————————————————————

TypeError Traceback (most recent call last)

in ()
—-> 1 mixed_type[1] = 'O' # Попробуйте изменить 0 на «O»

TypeError: 'tuple' object does not support item assignment

Последняя ошибка появилась из-за попытки поменять значения внутри кортежа.

Кортежи можно создавать и вот так:

numbers_tuple = 1,2,3,4,5
print(type(numbers_tuple))

Кортежи против списков

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

numbers_tuple = (1,2,3,4,5)
numbers_list = [1,2,3,4,5] numbers_tuple.append(6)
—————————————————————————

AttributeError Traceback (most recent call last)

in ()
3
4 # Добавим число в кортеж
—-> 5 numbers_tuple.append(6)

AttributeError: 'tuple' object has no attribute 'append'

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

numbers_list.append(6)
numbers_list.append(7)
numbers_list.append(8) numbers_list.remove(7)
print(numbers_list)
[1, 2, 3, 4, 5, 6, 8]

Но зачем использовать этот тип данных, если он неизменяемый?

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

>>> import timeit
>>> timeit.timeit('x=(1,2,3,4,5,6,7,8,9)', number=100000)
0.0018976779974764213
>>> timeit.timeit('x=[1,2,3,4,5,6,7,8,9]', number=100000)
0.019868606992531568

Какую роль играет неизменяемость в случае с кортежами?

Согласно официальной документации Python неизменяемый — это «объект с фиксированным значением», но в отношении кортежей «значение» — это чересчур размытый термин. Лучше использовать id. id определяет расположения объекта в памяти.

Рассмотрим подробнее:

n_tuple = (1, 1, [3,4]) id(n_tuple[0]) == id(n_tuple[1])
True

id(n_tuple[0]) == id(n_tuple[2])
False
print(id(n_tuple[0]), id(n_tuple[2]))
4297148528, 4359711048
n_tuple.append(5)
—————————————————————————

AttributeError Traceback (most recent call last)

in ()
—-> 1 n_tuple.append(5)

AttributeError: 'tuple' object has no attribute 'append'

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

n_tuple[2].append(5)
n_tuple
(1, 1, [3, 4, 5])

Это позволяет изменять оригинальный кортеж? Куда в таком случае делась их неизменяемость?

Суть в том, что id списка в кортеже не меняется несмотря на добавленный в него элемент 5.

id(n_tuple[2])
4359711048

Теперь вы знаете следующее:

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

• Вы не можете добавлять в них новые элементы. У этого типа нет методов append() или extend()
• Удалять элементы тоже нельзя, также из-за неизменяемости. Методов remove() и pop() здесь нет
• Искать элементы в кортеже можно, потому что этот процесс его не меняет
• Разрешено использовать оператор in для проверки наличия элемента в кортеже

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

https://www.youtube.com/watch?v=JVEBE7pviE0\u0026pp=ygVJ0JrQvtGA0YLQtdC20Lgg0LIgUHl0aG9uOiDQvtGB0L3QvtCy0L3Ri9C1INC80LXRgtC-0LTRiyDQuCDRhNGD0L3QutGG0LjQuA%3D%3D

Если вы хотите узнать больше о списках Python, обязательно ознакомьтесь с этим руководством!

Стандартные операции с кортежами

Python предоставляет несколько способов для управления кортежами. Рассмотрим их на примерах.

Срезы

Значение индекса первого элемента в кортеже — 0. По аналогии со списками эти значения можно использовать с квадратными скобками [] для получения доступа к кортежам:

numbers = (0,1,2,3,4,5)
numbers[0]
0

Можно использовать и отрицательные значения:

numbers[-1]
5

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

[Начальный индекст (включен):Конечный индекс (исключен):Частота]

Частота в данном случае является опциональным параметром, а его значение по умолчанию равно 1.

# Элемент с индексом 4 исключен
numbers[1:4]
(1, 2, 3)

numbers[:]
(0, 1, 2, 3, 4, 5)
# Частота = 2
numbers[::2]
(0, 2, 4)

Совет: значение частоты может быть и негативным, чтобы развернуть кортеж.

numbers[::-1]
(5, 4, 3, 2, 1, 0)

Объединение кортежей

Можно объединять кортежи для создания нового объекта. Операция объединения выполняет конкатенацию двух кортежей.

x = (1,2,3,4)
y = (5,6,7,8) z = x + y print(z)
(1, 2, 3, 4, 5, 6, 7, 8)
y = [5,6,7,8]
z = x + y
print(z)
—————————————————————————

TypeError Traceback (most recent call last)

in ()
1 y = [5,6,7,8]
—-> 2 z = x + y
3 print(z)

TypeError: can only concatenate tuple (not «list») to tuple

Разрешается объединять только определенные типы данных. Так, попытка соединить кортеж и список закончится ошибкой.

Умножение кортежей

Операция умножения приводит к тому, что кортеж повторяется несколько раз.

x = (1,2,3,4)
z = x*2
print(z)
(1, 2, 3, 4, 1, 2, 3, 4)

Функции кортежей

В отличие от списков у кортежей нет методов, таких как append(), remove(), extend(), insert() или pop() опять-таки из-за их неизменяемости. Но есть другие:

count() и len()

count() возвращает количество повторений элемента в кортеже.

a = [1,2,3,4,5,5]
a.count(5)
2

len() — длину кортежа:

a = (1,2,3,4,5)
print(len(a))
5

any()

Функцию any() можно использовать, чтобы определить являются ли элементы кортежа итерируемыми. Если да, то она вернет True.

a = (1,)
print(any(a))
True

Обратите внимание на запятую (,) в объявлении кортежа a. Если ее не указать при создании объекта с одним элементом? Python предположит, что вы по ошибке добавили лишнюю пару скобок (это ни на что не влияет), но тип данных в таком случае — это не кортеж. Поэтому важно не забывать использовать запятую при объявлении кортежа с одним элементом.

И снова к функции any. В булевом контексте значение элемента не имеет значения. Пустой кортеж вернет False, а кортеж с хотя бы одним элементом — True.

b = ()
print(any(b))
False

Функция может быть полезной, если кортеж вызывается? и нужно удостовериться, что он не пустой.

tuple()

Функция tuple() используется для конвертации данных в кортеж. Например, так можно превратить список в кортеж.

a_list = [1,2,3,4,5]
b_tuple = tuple(a_list)
print(type(b_tuple))

min() и max()

Функция max()q возвращает самый большой элемент последовательности, а min() — самый маленький. Возьмем следующий пример:

print(max(a))
print(min(a))
5
A

Эти функции можно использовать и для кортежей со строками.

a = ('Apple') print(max(a))
p

sum()

С помощью этой функции можно вернуть сумму элементов в кортеже. Работает только с числовыми значениями.

sum(a)
28

sorted()

Чтобы получить кортеж с отсортированными элементами, используйте sorted() как в следующем примере:

a = (6,7,4,2,1,5,3)
sorted(a)
[1, 2, 3, 4, 5, 6, 7]

Но важно отметить, что возвращаемый тип — список, а не кортеж. При этом последовательность в оригинальном объекте неизменна, а сам он остается кортежем.

Присваивание несколько кортежей

Кортежи можно использовать для присваивания нескольких значений одновременно. Вот так:

a = (1,2,3)
(one,two,three) = a
print(one)
1

a — это кортеж из трех элементов и (one, two, three) — кортеж трех переменных. Присваивание (one, two, three) кортежу a присваивает каждое значение a каждой переменной: one, two и three по очереди. Это удобно, если нужно присвоить определенному количеству переменных значений в кортеже.

Выводы

Теперь вы знаете, что такое кортежи, как их создавать, какие самые распространенные операции, и как ими можно управлять. Также — распространенные методы структур Python. А в качестве бонуса научились присваивать нескольким переменным разные значения.

Кортежи в Python (tuple)

Кортеж (tuple) — ещё один вид последовательностей в Python.

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

# кортеж
immutable_tuple = (4, 5, 6)
immutable_tuple[0] = 404

>
Traceback (most recent call last):
immutable_tuple[0] = 404
TypeError: 'tuple' object does not support item assignment# список
mutable_list = [7, 8, 9]
mutable_list[0] = 1
print(mutable_list)

> [1, 8, 9]

Как видно, в литеральной форме кортеж python 3 записывается в виде последовательности элементов в круглых скобках, в то время как для списков характерны квадратные.

???? Некоторые особенности кортежей:

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

x = 100
y = 200
x, y = y, x

print(x)
> 200

print(y)
> 100

Примеры кортежей

# пустой кортеж
empty_tuple = ()

# кортеж из 4-х элементов разных типов
four_el_tuple = (36.

6, 'Normal', None, False)

# пример tuple, что содержит вложенные элементы
nested_elem_tuple = (('one', 'two'), ['three', 'four'], {'five': 'six'}, (('seven', 'eight'), ('nine', 'ten')))
print(nested_elem_tuple)

> (('one', 'two'), ['three', 'four'], {'five': 'six'}, (('seven', 'eight'), ('nine', 'ten')))

Зачем использовать кортеж вместо списка?

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

• Неизменяемость — именно это свойство кортежей, порой, может выгодно отличать их от списков.
• Скорость — кортежи быстрее работают. По причине неизменяемости кортежи хранятся в памяти особым образом, поэтому операции с их элементами выполняются заведомо быстрее, чем с компонентами списка.
• Безопасность — неизменяемость также позволяет им быть идеальными кандидатами на роль констант. Константы, заданные кортежами, позволяют сделать код более читаемым и безопасным.
• Использование tuple в других структурах данных — кортежи применимы в отдельных структурах данных, от которых python требует неизменяемых значений. Например ключи словарей (dicts) должны состоять исключительно из данных immutable-типа.

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

def get_status(service_name):
return None, f»service {service_name} is OK!»

print(type(get_status('nginx')))
>

error, message = get_status('nginx')
print(error)
print(message)
> None
> service nginx is OK!

Работа с кортежами

Создание

Как и другие коллекции языка Питон, кортеж можно создать двумя способами.

https://www.youtube.com/watch?v=JVEBE7pviE0\u0026pp=YAHIAQE%3D

Способ №1: Литеральное объявление:

literal_creation = ('any', 'object')

print(literal_creation)
> ('any', 'object')

print(type(literal_creation))
>

Способ №2: Через функцию tuple():

tuple_creation = tuple('any iterable object')

print(tuple_creation)
> ('a', 'n', 'y', ' ', 'i', 't', 'e', 'r', 'a', 'b', 'l', 'e', ' ', 'o', 'b', 'j', 'e', 'c', 't')

print(type(tuple_creation))
>

????‍♀️ Важно, чтобы аргумент, передаваемый в tuple() был итерируемым объектом:

incorrect_creation = tuple(777)

>
Traceback (most recent call last):
incorrect_creation = tuple(777)
TypeError: 'int' object is not iterable

Упаковка

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

Стоит обратить внимание 2 момента:

1. Выражения some_tuple = (11, 12, 13) и some_tuple = 11, 12, 13 тождественны.
2. Для объявления кортежа, включающего один единственный элемент, нужно использовать завершающую запятую:

is_tuple = ('a',)
is_tuple_too = 'b',
not_a_tuple = 'c'

print(type(is_tuple))
print(type(is_tuple_too))
print(type(not_a_tuple))

>
>
>

Распаковка

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

notes = ('Do', 'Re', 'Mi', 'Fa', 'Sol', 'La', 'Si')
do, re, mi, fa, sol, la, si = notes
print(mi)

> Mi

Количество переменных должно совпадать с числом элементов tuple

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

night_sky = 'Moon', 'Stars'
moon, _ = night_sky
print(moon)

> Moon

Обращение к элементу и поиск в кортеже

Обратиться к элементу кортежа можно по номеру его позиции. Причём как с начала, так и с конца:

# Mike — [0], Leo — [1], Don — [2], Raph — [3]
turtles = ('Mike', 'Leo', 'Don', 'Raph')
# Mike — [-4], Leo — [-3], Don — [-2], Raph — [-1]

print(turtles[1])
print(turtles[-2])
print(turtles[2] == turtles[-2])
> Leo
> Don
> True

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

input_box = ('firstbox', (15, 150))
# помним про индексацию, ведущую своё начало с 0
print(input_box[1][1])

> 150

Узнать, присутствует ли объект среди элементов кортежа, можно с помощью оператора in:

song = ('Roses', 'are', 'Red')
print('Red' in song)
print('Violet' in song)

> True
> False

Сравнение

tuple_A = 2 * 2,
tuple_B = 2 * 2 * 2,
tuple_C = 'a',
tuple_D = 'z',
tuple_E = (42, 'maximum')
tuple_F = (42, 'minimum')
tuple_Z = 999,

# при сравнении кортежей, числа сравниваются по значению
print(tuple_A < tuple_B) > True

# строки в лексикографическом порядке
print(tuple_C < tuple_D) > True

# при равенстве элементов на одинаковых позициях, сравниваются элементы на следующих
print(tuple_E < tuple_F) > True

# сравнение элементов продолжается до первого неравенства
print(tuple_Z < tuple_F) > False

Перебор

Наиболее простым и очевидным способом перебрать элементы кортежа является обход его в цикле for:

my_tuple = ('Wise', 'men', 'say', 'only', 'fools', 'rush', 'in')

# Вывести все элементы кортежа
for word in my_tuple:
print(word)
>
Wise
men
say
only
fools
rush
in

Сортировка

Нет ничего проще, чем отсортировать готовый кортеж. В этом наш друг и помощник — прекрасная функция sorted():

not_sorted_tuple = (10**5, 10**2, 10**1, 10**4, 10**0, 10**3)
print(not_sorted_tuple)

> (100000, 100, 10, 10000, 1, 1000)

sorted_tuple = tuple(sorted(not_sorted_tuple))
print(sorted_tuple)

> (1, 10, 100, 1000, 10000, 100000)

Удаление

Добавить или удалить элемент содержащийся в tuple нельзя, по причине всё той же неизменяемости. Однако сам кортеж стереть с цифрового лица Земли возможно. Оператор del к нашим услугам:

some_useless_stuff = ('sad', 'bad things', 'trans fats')
del some_useless_stuff
print(some_useless_stuff)

>
Traceback (most recent call last):
print(some_useless_stuff)
NameError: name 'some_useless_stuff' is not defined

Методы и особые операции

Срез

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

tuple[start:fin:step]

Где start — начальный элемент среза (включительно), fin — конечный (не включительно) и step— «шаг» среза.

float_tuple = (1.1, 0.5, 45.5, 33.33, 9.12, 3.14, 2.73)
print(float_tuple[0:3])

> (1.1, 0.5, 45.5)

# тождественная запись
print(float_tuple[:3])

> (1.1, 0.5, 45.5)

# если не указывать конечное значение, будут выведены все элементы до конца
print(float_tuple[0:])

> (1.1, 0.5, 45.5, 33.33, 9.12, 3.14, 2.73)

# не указывать начальное — с начала
print(float_tuple[:])

> (1.1, 0.5, 45.5, 33.33, 9.12, 3.14, 2.73)

# выведем элементы с шагом 2
print(float_tuple[-7::2])

> (1.1, 45.5, 9.12, 2.73)

# отрицательный шаг позволит вывести tuple в обратном порядке
print(float_tuple[::-1])

> (2.73, 3.14, 9.12, 33.33, 45.5, 0.5, 1.1)

Длина кортежа

Используя функцию len(), получаем длину/количество элементов:

php = ('p', 'h', 'p')
print(len(php))

> 3

Конкатенация

Для tuple определена операция конкатенации:

storm_1 = ('Lightning')Union = (' and ')
storm_2 = ('Thunder')

print(storm_1 + Union + storm_2)

> Lightning and Thunder

Повторение

Как и в случае с конкатенацией, для кортежей, впрочем, как и для строк, определена операция повторения:

dog_do = ('woof!',)
print(dog_do * 3)
> ('woof!', 'woof!', 'woof!')

Индекс заданного элемента

Метод index() позволяет получить индекс элемента. Достаточно передать нужное значение элемента, как аргумент метода:

rom = ('I', 'II', 'III', 'IV', 'V', 'VI', 'VII', 'VIII', 'IX', 'X')
print(rom.index('X'))

> 9

Число вхождений элемента

Метод count() ведёт подсчет числа вхождений элемента в кортеж.

AT = ('Finn', 'Jake', 'BiMo', 'Marceline', 'Princess Bubblegum', 'BiMo')
print(AT.count('Finn'))

> 1

print(AT.count('BiMo'))

> 2

Преобразование

tuple → str

Представляем вашему вниманию лёгкий способ преобразовать кортеж в строку при помощи метода join():

game_name = ('Breath', ' ', 'of', ' ', 'the', ' ', 'Wild')
game_name = ''.join(game_name)
print(game_name)

> Breath of the Wild

tuple → list

Тут всё ещё проще. Для такой конвертации необходимо всего лишь передать кортеж, как аргумент функции list():

dig_tuple = (1111, 2222, 3333)
print(dig_tuple)

> (1111, 2222, 3333)

dig_list = list(dig_tuple)
print(dig_list)

> [1111, 2222, 3333]

tuple → dict

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

score = (('Eric', 65000), ('Stephany', 87000))
score_dict = dict((x, y) for x, y in score)
print(score_dict)

> {'Eric': 65000, 'Stephany': 87000}

Именованные кортежи

Мощная особенность и настоящая гордость языка.

Именованный кортеж (или named tuple) позволяет программисту обращаться к элементу кортежа не по индексу, а через удобочитаемый заранее заданный идентификатор.

Покажем на примере:

# для начала импортируем сам модуль
from collections import namedtuple

citizen = namedtuple(«Citizen», «name age status»)
Alex = citizen(name='Alex Mercer', age=27, status='show businessman')
print(Alex.name)

> Alex Mercer

print(Alex.status)

> show businessman

Точечная нотация при обращении к свойству объекта может вызвать невольную ассоциацию с классами. В общем-то одно из применений namedtuple как раз связано с ситуациями, когда нужно передать несколько свойств объекта одним куском.

Кортежи в Python

Кортеж (англ. tuple) — встроенный тип данных в Python. Кортежи используются для хранения нескольких элементов в одной переменной.

Оглавление

Особенности кортежей

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

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

От редакции Pythonist: о списках читайте в статье «Списки в Python: полное руководство для начинающих», а о разнице между кортежами и списками — в статье «Чем отличается кортеж от списка в Python».

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

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

Создать кортеж в Python очень просто, но есть несколько моментов, о которых вам нужно знать.

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

Ниже приведен пример создания кортежа, содержащего три элемента.

exampletuple = («house», «unit», «apartment»)

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

('house', 'unit', 'apartment')

Кортеж с одним элементом

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

Правильное создание кортежа в Python: exampletuple = («house»,).

Неправильное создание кортежа: exampletuple = («house»).

Использование конструктора tuple()

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

exampletuple = tuple((«house», «unit», «apartment»))
print(exampletuple)

# Вывод:
# ('house', 'unit', 'apartment')

Как видите, выводится то же значение, что и при создании кортежа без конструктора.

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

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

Индексация кортежей в Python начинается с 0, поэтому для ссылки на первый элемент используется индексное значение 0. Вы можете получить доступ к элементам кортежа, используя квадратные скобки [] и индексы элементов.

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

От редакции Pythonist: рекомендуем почитать «Цикл for в Python: тонкости написания».

Индексы элементов кортежа

В нашем примере мы создаем кортеж с 5 элементами. Это означает, что первый элемент будет иметь индекс 0, а последний — 4. Попытка получить доступ к элементу кортежа по индексу вне этого диапазона приведет к ошибке.

После создания кортежа мы выводим значения элементов под индексами 0 и 3.

exampletuple = («house», «unit», «apartment», «villa», «acreage»)
print(exampletuple[0])
print(exampletuple[3])

# Вывод:
# house
# villa

Как видите, значение элемента с индексом 0 — это первая строка, house. А под индексом 3 хранится четвертая строка, villa.

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

В коллекции данных кортежа можно использовать отрицательный индекс. Использование отрицательных чисел означает, что отсчет идет в обратном направлении. Так, индекс -1 относится к последнему элементу кортежа.

В следующем примере мы создаем кортеж с 5 элементами. Мы будем обращаться к этим элементам, используя отрицательный индекс вместо положительного.

exampletuple = («house», «unit», «apartment», «villa», «acreage»)
print(exampletuple[-1])
print(exampletuple[-3])

# Вывод:
# acreage
# apartment

Как видите, мы вывели последний и третий элемент нашего кортежа.

Срезы кортежей

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

Указывать начало и конец диапазона не обязательно. Но важно, какое именно значение вы опустите. Так, например, срез [:3] выберет все элементы от начала кортежа, т. е. от элемента с индексом 0, до элемента с индексом 3. А срез [1:] — элементы от индекса 1 до конца кортежа.

В нашем примере ниже мы хотим получить все, что находится между индексами 1 и 3.

exampletuple = («house», «unit», «apartment», «villa», «acreage»)
print(exampletuple[1:3])

# Вывод:
# ('unit', 'apartment')

Обратите внимание, что при взятии среза элемент, указанный как конец диапазона, в срез не входит. Здесь мы вывели срез [1:3] и получили в выводе элементы с индексами 1 и 2.

Обновление кортежей

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

exampletuple = («house», «unit», «apartment», «villa», «acreage»)
newtuple = exampletuple[0:3]
print(newtuple)

# Вывод:
# ('house', 'unit', 'apartment')

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

От редакции Pythonist: на тему изменяемости объектов рекомендуем очень хорошую и подробную статью — «Python 3: изменяемый, неизменяемый…».

Конкатенация нескольких кортежей

Вам может понадобиться объединить несколько кортежей. Например, присоединить часть одного кортежа к другому.

В следующем примере мы берем часть исходного кортежа и объединяем ее с новым кортежем. Этот объединенный кортеж хранится в новой переменной.

exampletuple = («house», «unit», «apartment», «villa», «acreage»)
newtuple = exampletuple[0:3] + («ranch», «farm»)
print(newtuple)

# Вывод:
# ('house', 'unit', 'apartment', 'ranch', 'farm')

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

Удаление значений в кортеже

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

В приведенном ниже примере мы удаляем элемент apartment, разрезая кортеж и не включая этот конкретный элемент в newtuple.

exampletuple = («house», «unit», «apartment», «villa», «acreage»)
newtuple = exampletuple[:2] + exampletuple[3:]
print(newtuple)

# Вывод:
# ('house', 'unit', 'villa', 'acreage')

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

Удаление кортежа

Удаление целого кортежа в Python довольно простое и может быть выполнено с помощью оператора del. После удаления любое обращение к этому кортежу приведет к ошибке, если только вы не создадите его заново.

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

exampletuple = («house», «unit», «apartment»)
print(exampletuple)
del exampletuple
print(exampletuple)

Результат:

('house', 'unit', 'apartment')
Traceback (most recent call last):
File «D:Python uple.py», line 7, in
print(exampletuple)
NameError: name 'exampletuple' is not defined

Вывод показывает, что Python успешно удалил кортеж, поскольку при попытке вывести его во второй раз возникла ошибка.

Встроенные функции кортежей

Мы уже рассмотрели некоторые способы взаимодействия с кортежами. В таблице ниже приведены еще несколько функций, которые вы можете использовать с кортежами.

cmp(tuple1,tuple2)	Сравнивает элементы двух кортежей.
len(tuple)	Возвращает длину кортежа.
all(tuple)	Возвращает True, если все элементы кортежа оцениваются как True или если кортеж пуст.
any(tuple)	Возвращает True, если хоть один элемент кортежа оценивается как True. Если кортеж пуст — возвращает False.
max(tuple)	Возвращает максимальное значение в кортеже.
min(tuple)	Возвращает минимальное значение в кортеже.
sum(tuple)	Суммирует все числа в кортеже. Если в кортеже встречается строка, выдает ошибку.
sorted(tuple)	Сортирует кортеж.

Заключение

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

Перевод статьи «How to Use Python Tuples».