Кортеж питон: Кортежи в Python: основные методы и функции

Кортежи в Python: основные методы и функции

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

Кортеж в Питоне: свойства и особенности

1. Кортежи не поддерживают добавление и удаление элементов, но допускают расширение и дополнение для тех элементов, которые относятся к изменяемым типам (списки, словари), а также любые операции с элементами элементов:

>>> numbers = ([1, 2, 3, 4], [5, 4, 5])
>>> numbers[1].extend([3, 5, 9])
>>> numbers[0].append([7, 7, 8])
>>> numbers[1][1] += 5
>>> print(numbers)
([1, 2, 3, 4, [7, 7, 8]], [5, 9, 5, 3, 5, 9])

    

2. Кортежи поддерживают неограниченный уровень вложенности:

numbers = ((4, 5, 8, (5, 1, (5, 3))), (7, 2, (4, 5, (3, 1, 1))))
    

3. Кортежи работают немного быстрее, чем списки – это связано с особенностями хранения tuple в памяти:

>>> from timeit import timeit
>>> times = 1000000
>>> t1 = timeit("list(['груша', 'виноград','яблоко', 'банан', 'апельсин'])", number=times)
>>> t2 = timeit("tuple(('груша', 'виноград','яблоко', 'банан', 'апельсин'))", number=times)
>>> diff = "{:.0%}".format((t2 - t1)/t1)
>>> print(f'Время копирования списка {times} раз: {t1}')
Время копирования списка 1000000 раз: 0.5761922669999961
>>> print(f'Время копирования кортежа {times} раз: {t2}')
Время копирования кортежа 1000000 раз: 0.22475764600000048
>>> print(f'Разница: {diff}')
Разница: -61%

    

4. Кортежи занимают меньше места в памяти:

>>> from sys import getsizeof
>>> numbers1 = ((1, 2, 3, 4), (5, 4, 5))
>>> numbers2 = [[1, 2, 3, 4], [5, 4, 5]]
>>> print(getsizeof(numbers1))
36
>>> print(getsizeof(numbers2))
44

    

5. Кортежи поддерживают конкатенацию + и повторение * n:

>>> num1 = (1, 2, 3)
>>> num2 = (4, 5, 6)
>>> print(num1 + num2)
(1, 2, 3, 4, 5, 6)
>>> print(num1 * 3)
(1, 2, 3, 1, 2, 3, 1, 2, 3)

    

6. Элементы tuple можно использовать в качестве значений переменных; этот прием называют распаковкой кортежа:

>>> seasons = ('весна', 'лето', 'осень', 'зима')
>>> s1, s2, s3, s4 = seasons
>>> print(s1, s3)
весна осень

    

Создание tuple в Питоне

Пустой кортеж можно создать двумя способами – с помощью круглых скобок () и с использованием функции tuple():

my_tuple = ()
my_tuple2 = tuple()

    

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

>>> my_tuple = (5)
>>> print(type(my_tuple))
<class 'int'>
>>> my_tuple = (5,)
>>> print(type(my_tuple))
<class 'tuple'>

    

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

Способ 1: Перечисление элементов

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

info = ('Егор', 'разработчик', 350000, 28)
    

Элементы кортежа необязательно перечислять в круглых скобках – когда Python получает более одного значения для переменной, создание («упаковка») кортежа происходит автоматически:

>>> letters = 'a', 'b', 'c', 'd'
>>> print(letters)
('a', 'b', 'c', 'd')

    

Способ 2: Преобразование других типов данных

С помощью встроенной функции tuple() можно создать кортеж из списка, строки или множества:

>>> my_lst = [4, 6, 2, 8]
>>> print(tuple(my_lst))
(4, 6, 2, 8)
>>> my_str = 'Я изучаю Python'
>>> print(tuple(my_str))
('Я', ' ', 'и', 'з', 'у', 'ч', 'а', 'ю', ' ', 'P', 'y', 't', 'h', 'o', 'n')
>>> my_set = {2, 5, 6, 7}
>>> print(tuple(my_set))
(2, 5, 6, 7)

    

Однако при подобном преобразовании словаря в кортеж останутся только ключи:

>>> my_dict = {'яблоки': 52, 'апельсины': 35}
>>> print(tuple(my_dict))
('яблоки', 'апельсины')

    

>>> num = 178394
>>> print(tuple(num))
Traceback (most recent call last):
  File "<pyshell>", line 1, in <module>
TypeError: 'int' object is not iterable

    

Но если конвертировать число в строку, преобразование пройдет без ошибок:

>>> num = 31232534
>>> print(tuple(str(num)))
('3', '1', '2', '3', '2', '5', '3', '4')

    

В ходе преобразования строки в кортеж с помощью одной лишь функции tuple() строка разбивается на отдельные символы. Если нужно разбить строку по одному разделителю, подойдет метод partition():

>>> st = 'Я изучаю***Python'
>>> print(st.partition('***'))
('Я изучаю', '***', 'Python')

    

Чтобы разбить строку по всем разделителям, вместе с tuple() используют split():

>>> st = tuple(input().split())
Код на языке Python
>>> print(st)
('Код', 'на', 'языке', 'Python')
    

Способ 3: Генератор кортежей

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

>>> my_tuple = (i for i in range(5))
>>> print(my_tuple)
<generator object <genexpr> at 0x023B5830>

    

Но если генератор кортежа все-таки необходимо использовать, это можно сделать двумя способами:

1.

>>> numbers = (i for i in range(10))
>>> print(*numbers)
0 1 2 3 4 5 6 7 8 9

    

2. Либо использовать в генераторе функцию tuple():

>>> my_tuple = tuple(i ** 2 for i in range(1, 12, 2))
>>> print(my_tuple)
(1, 9, 25, 49, 81, 121)

    

Способ 4: Распаковка строк и списков

Оператор распаковки * и запятая после имени переменной автоматически превращают строки и списки в кортежи:

>>> st = 'Я изучаю Python'
>>> sp = ['Python', 'HTML5', 'CSS', 'JavaScript']
>>> tuple1 = (*st,)
>>> tuple2 = (*sp,)
>>> print(tuple1)
('Я', ' ', 'и', 'з', 'у', 'ч', 'а', 'ю', ' ', 'P', 'y', 't', 'h', 'o', 'n')
>>> print(tuple2)
('Python', 'HTML5', 'CSS', 'JavaScript')

    

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

>>> my_tuple = (4, 5, 6)
>>> del my_tuple[1]
Traceback (most recent call last):
  File "<pyshell>", line 1, in <module>
TypeError: 'tuple' object doesn't support item deletion
>>> my_tuple[2] = 9
Traceback (most recent call last):
  File "<pyshell>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment

    

Индексация и срезы

Индексация и срезы в кортежах работают так же, как и в списках:

>>> my_tuple = ('банан', 'груша', 'манго')
>>> print(my_tuple[0], my_tuple[-1])
банан манго
>>> print(my_tuple[1:])
('груша', 'манго')
>>> print(my_tuple[::-1])
('манго', 'груша', 'банан')

    

Для возвращения индексa элемента используется

>>> nutr = ('белки', 'жиры', 'углеводы')
>>> print(nutr. index('белки'))
0

    

Длина, сумма, минимальный и максимальный элементы

Эти методы тоже аналогичны списочным:

>>> my_tuple = ('карандаш', 'ручка', 'шар')
>>> print(len(my_tuple))
3
>>> print(min(my_tuple, key=len))
шар
>>> print(max(my_tuple, key=len))
карандаш
>>> nums = (4, 5, 2, 1, 6)
>>> print(sum(nums))
18

    

Принадлежность

С помощью операторов in и not in можно убедиться в наличии (отсутствии) определенного значения в кортеже:

>>> nums = (1, 3, 5, 6, 7, 8)
>>> (5 in nums)
True
>>> (25 not in nums)
True

    

Подсчет элементов

>>> cities = ('Москва', 'Ростов', 'Москва', 'Рязань', 'Саратов', 'Москва')
>>> print(cities. count('Москва'))
3

    

Сортировка

Кортежи поддерживают сортировку, однако результатом будет список:

>>> nums = (4, 1, 7, 2, 0, 9, 5)
>>> print(sorted(nums))
[0, 1, 2, 4, 5, 7, 9]

    

Если результат должен сохраняться в виде кортежа, нужно использовать tuple():

>>> nums = (4, 1, 7, 2, 0, 9, 5)
>>> print(tuple(sorted(nums, reverse=True)))
(9, 7, 5, 4, 2, 1, 0)

    

Преобразование кортежей в другие типы данных

Кортеж можно преобразовать в строку:

>>> letters = ('P', 'y', 't', 'h', 'o', 'n')
>>> print('*'.join(letters))
P*y*t*h*o*n

    

В список:

>>> sp = (2, 7, 5, 8, 1)
>>> print(list(sp))
[2, 7, 5, 8, 1]

    

В словарь (если кортеж вложенный и состоит из пар значений):

>>> info = (('фрукты', 5), ('овощи', 15), ('конфеты', 3))
>>> print(dict(info))
{'фрукты': 5, 'овощи': 15, 'конфеты': 3}

    

Во множество:

>>> numbers = (3, 2, 1, 6, 7, 2, 2, 9)
>>> print(set(numbers))
{1, 2, 3, 6, 7, 9}

    

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

Как и списки, кортежи с однородными данными можно сравнивать между собой с помощью операторов >, >=, <, <=, ==, !=. Если элементы кортежей принадлежат к разным типам данных, поддерживаются только операторы == и !=.

>>> tuple1 = (1, 2, 3)
>>> tuple2 = (4, 5, 6)
>>> print(tuple1 < tuple2)
True
>>> print(tuple1 != tuple2)
True

    

Практика

Задание 1

Напишите программу, которая:

• Создает кортежи из положительных и отрицательных целых чисел на основе полученной от пользователя строки.
• Выводит количество положительных и отрицательных чисел в этих кортежах.

Пример ввода:

45 -6 -9 43 23 5 2 -9 -1 6 3
    

Вывод:

Кортеж (45, 43, 23, 5, 2, 6, 3) состоит из 7 положительных чисел
Кортеж (-6, -9, -9, -1) состоит из 4 положительных чисел

    

Решение:

numbers = tuple(map(int, input(). split()))
pos = tuple(i for i in numbers if i > 0)
neg = tuple(i for i in numbers if i < 0)
print(f'Кортеж {pos} состоит из {len(pos)} положительных чисел')
print(f'Кортеж {neg} состоит из {len(neg)} положительных чисел')

    

Задание 2

Напишите программу, которая:

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

Пример ввода:

3.45 6.78 8.99 1.45 4.32 19.04 0.55
    

Вывод:

Минимальное число: 0.55
Максимальное число: 19.04
Сумма min и max: 19.59

    

Решение:

my_tuple = tuple(map(float, input().split()))
print(f'Минимальное число: {min(my_tuple)}')
print(f'Максимальное число: {max(my_tuple)}')
print(f'Сумма min и max: {((min(my_tuple) + max(my_tuple))):. 2f}')

    

Задание 3

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

fruit = (['яблоки', 46], ['персики', 49], ['лимоны', 36], ['виноград', 190])
    

Калорийность винограда указана ошибочно. Напишите программу, которая исправит калорийность на 75, и добавит в третий элемент кортежа новое значение ['айва', 42]. Результат должен выглядеть так:

fruit = (['яблоки', 46], ['персики', 49], ['лимоны', 36, 'айва', 42], ['виноград', 75])
    

Решение:

fruit = (['яблоки', 46], ['персики', 49], ['лимоны', 36], ['виноград', 190])
fruit[3][1] = 75
fruit[2].extend(['айва', 42])
print(fruit)

    

Задание 4

Имеется вложенный кортеж:

numbers = ((5, 4, 5, 4), (3, 3, 4, 6), (8, 9, 5, 4), (12, 4, 5, 1), (9, 3, 5, 1))
    

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

4.5 4.0 6.5 5.5 4.5
    

Решение:

numbers = ((5, 4, 5, 4), (3, 3, 4, 6), (8, 9, 5, 4), (12, 4, 5, 1), (9, 3, 5, 1))
avg = tuple(sum(i)/len(i) for i in numbers)
print(*avg)

    

Задание 5

Имеется вложенный кортеж:

nested_tuple = ((12, 3, 1), (5, 11), (15, 7, 8, 9), (10, 6, 4))
    

Напишите программу для преобразования nested_tuple в обычный кортеж, упорядоченный по возрастанию:

(1, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 15)
    

Решение:

nested_tuple = ((12, 3, 1), (5, 11), (15, 7, 8, 9), (10, 6, 4))
res = []
flat_list = [res.extend(i) for i in nested_tuple]
print(tuple(sorted(res)))

    

Задание 6

Напишите программу для сортировки вложенного кортежа по третьему элементу. Исходный кортеж:

(('красный', 33, 55), ('зеленый', 17, 44), ('синий', 12, 3), ('черный', 2, 5))
    

Результат:

(('черный', 2, 5), ('синий', 12, 3), ('зеленый', 17, 44), ('красный', 33, 55))
    

В качестве ключа сортировки следует использовать конструкцию key=lambda x: x[2] – это анонимная функция. В последующих статьях мы будем подробно разбирать применение анонимных функций.

Решение:

nested_tuple = (('красный', 33, 55), ('зеленый', 17, 44), ('синий', 12, 3), ('черный', 2, 5))
nested_tuple = tuple(sorted(list(nested_tuple), key=lambda x: x[2]))
print(nested_tuple)

    

Задание 7

Напишите программу, которая:

• принимает на вход строку, состоящую из цифр или символов, разделенных пробелами;
• создает из строки кортеж;
• проверяет, состоит ли кортеж из одинаковых элементов;
• выводит True или False в зависимости от результатов проверки.

Для проверки соответствия всех элементов одному условию в Python используется встроенная функция all():

all(i == my_tuple[0] for i in my_tuple)
    

Пример ввода:

35 35 35 35 35
    

Вывод:

True
    

Решение:

my_tuple = tuple(input().split())
print(all(i == my_tuple[0] for i in my_tuple))

    

Задание 8

Напишите программу, которая на основе исходного кортежа создает новый кортеж, из которого исключены все пользователи с номерами телефонов с региональным кодом +56.

Исходный кортеж:

info = (('Евгений Романов', 25, '+56(983)354-67-21'),
    	('Марина Дятлова', 22, '+56(190)251-45-79'),
    	('Кирилл Кудрявцев', 34, '+7(890)456-12-42'),
    	('Сергей Дятлов', 24, '+56(190)156-42-99'),
    	('Юлия Степанова', 21, '+16(398)355-33-09'),
    	('Тимофей Иванов', 34, '+7(918)222-52-77'))
    

Ожидаемый результат:

(('Кирилл Кудрявцев', 34, '+7(890)456-12-42'), ('Юлия Степанова', 21, '+16(398)355-33-09'), ('Тимофей Иванов', 34, '+7(918)222-52-77'))
    

Решение:

info = (('Евгений Романов', 25, '+56(983)354-67-21'),
    	('Марина Дятлова', 22, '+56(190)251-45-79'),
    	('Кирилл Кудрявцев', 34, '+7(890)456-12-42'),
    	('Сергей Дятлов', 24, '+56(190)156-42-99'),
    	('Юлия Степанова', 21, '+16(398)355-33-09'),
    	('Тимофей Иванов', 34, '+7(918)222-52-77'))
new_info = tuple([i for i in info if not i[2]. startswith('+56')])
print(new_info)

    

Задание 9

Имеется кортеж списков:

numbers = ([4, 5], [4, 5], [1, 6], [7, 3], [3, 3], [2, 4], [9, 5], [1, 1])
    

Напишите программу, которая добавит цифру 5 в конец каждого списка.

Ожидаемый результат:

numbers = ([4, 5, 5], [4, 5, 5], [1, 6, 5], [7, 3, 5], [3, 3, 5], [2, 4, 5], [9, 5, 5], [1, 1, 5])
    

Решение:

numbers = ([4, 5], [4, 5], [1, 6], [7, 3], [3, 3], [2, 4], [9, 5], [1, 1])
add = [i.extend([5]) for i in numbers]
print(numbers)

    

Задание 10

Напишите программу, которая:

• получает на вход целое число n – количество точек на плоскости;
• получает n строк с координатами x, y;
• определяет точку, наиболее удаленную от начала координат.

Пример ввода:

5
4 8
1 2
7 4
7 8
3 2

    

Вывод:

7 8
    

Решение:

n = int(input())
points = [tuple(map(int, input().split())) for i in range(n)]
mx = max(points, key=lambda x: x[0] ** 2 + x[1] ** 2)
print(*mx)

    

Подведем итоги

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

Содержание самоучителя

1. Особенности, сферы применения, установка, онлайн IDE
2. Все, что нужно для изучения Python с нуля – книги, сайты, каналы и курсы
3. Типы данных: преобразование и базовые операции
4. Методы работы со строками
5. Методы работы со списками и списковыми включениями
6. Методы работы со словарями и генераторами словарей
7. Методы работы с кортежами
8. Методы работы со множествами
   
9. Особенности цикла for
   
10. Условный цикл while
    
11. Функции с позиционными и именованными аргументами
    
12. Анонимные функции
    
13. Рекурсивные функции
    
14. Функции высшего порядка, замыкания и декораторы
    
15. Методы работы с файлами и файловой системой
    
16. Регулярные выражения
    
17. Основы скрапинга и парсинга
    

Кортежи | Python

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

>>> t = (1, 2, 3, 4)
>>> t
(1, 2, 3, 4)

Чтобы создать пустой кортеж достаточно указать пару пустых круглых скобок:

>>> t = ()
>>> t
()
>>>
>>> type(t)
<class 'tuple'>

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

>>> t = (1,)
>>> t
(1,)

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

>>> (1 + 1)
2

А запятые:

>>> 1 + 1,
(2,)
>>>
>>> (1 + 1,)
(2,)

Поэтому, очень часто скобки вообще не используются:

>>> t = 1, 2, 3, 4
>>> t
(1, 2, 3, 4)

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

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

>>> t = tuple()
>>> t
()

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

>>> tuple('abcd')
('a', 'b', 'c', 'd')
>>>
>>> tuple(range(5))
(0, 1, 2, 3, 4)
>>>
>>> tuple(dict(a=1, b=2, c=3))
('a', 'b', 'c')

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

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

>>> (i**2 for i in range(10))
<generator object <genexpr> at 0x013DC680>

Поскольку кортежи являются последовательностями, то они поддерживают оператор извлечения среза [START:STOP:STEP] (и индексируются так же как и списки), так же они поддерживают оператор проверки на вхождение in и not in, функцию измерения размера (длины) len(), а так же механиз итерирования с помощью конструкции for. .. in....

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

Кортежи, в отлие от списков являются неизменяемыми:

>>> l = [0, 1, 2]
>>> l[0] = 111
>>> l
[111, 1, 2]
>>>
>>>
>>> t = (1, 2, 3)
>>> t[0] = 111
TypeError: 'tuple' object does not support item assignment

Но так же как и строки, они могут служить «сырьем» для новых объектов:

>>> t
(1, 2, 3)
>>>
>>> t = (111,) + t[1:]
>>> t
(111, 2, 3)
>>>
>>>
>>> t = t[0:1] + (222,) + t[2:]
>>> t
(111, 222, 3)

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

>>> t = list(t)
>>> t[2] = 333
>>> t = tuple(t)
>>> t
(111, 222, 333)

Однако, кортеж является неизменяемым только до тех пор пока сам состоит из неизменяемых объектов:

>>> t = (1, 2, [3, 4])
>>> 
>>> t[2][1] = 4444
>>>
>>> t
(1, 2, [3, 4444])

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

Так как кортежи являются неизменяемыми, то они имеют всего два метода: .count(x) и .index(x).

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

Кортежи (и списки) могут учавствовать в операциях присваивания:

>>> a, b, c = 1, 2, 3
>>> a, b, c
(1, 2, 3)

Данный механизм очень удобен для обмена значениями между переменными:

>>> a, b, c = c, b, a
>>> a, b, c
(3, 2, 1)

Если слева от оператора = элементов меньше чем справа, то можно воспользоваться оператором * для указания элементу которому может быть присвоено более одного значения:

>>> *a, b, c = (1, 2, 3, 4)
>>> a, b, c
([1, 2], 3, 4)
>>>
>>> a, *b, c = (1, 2, 3, 4)
>>> a, b, c
(1, [2, 3], 4)
>>>
>>> a, b, *c = (1, 2, 3, 4)
>>> a, b, c
(1, 2, [3, 4])

Использование помеченных * переменных, так же позволяет указывать слева от = больше элементов чем справа:

>>> *a, b, c, d, e = (1, 2, 3, 4)
>>> a, b, c, d
([], 1, 2, 3)
>>>
>>> a, b, *c, d, e = (1, 2, 3, 4)
>>> a, b, c, d
(1, 2, [], 3)

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

>>> a, b, c, x, y, z = 1, 2, 3, 4, 5, 6
>>>
>>> t1 = a, x
>>>
>>> t2 = x, c, z, b
>>>
>>> t1
(1, 4)
>>>
>>> t2
(4, 3, 6, 2)

Механизм распаковки кортежей может использоваться в конструкциях for. .. in...:

>>> for x, y in ((1, 2), (1, 3), (1, 4)):
...     print(x, '+', y, '=', x + y)
...
1 + 2 = 3
1 + 3 = 4
1 + 4 = 5

Это может быть очень удобно при работе с некоторыми генераторами:

>>> for x, y in zip('abcd', range(1, 5)):
...     print(x*y)
...
a
bb
ccc
dddd

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

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

>>> t = (('mod_1', 8.71, (-1.32, 23.87)), ('mod_2', 5.12, (-0.41, 19.86)))
>>> t
(('mod_1', 8.71, (-1.32, 23.87)), ('mod_2', 5. 12, (-0.41, 19.86)))

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

>>> t[0][2][1]
23.87

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

>>> model_1, model_2 = 0, 1
>>> name, mean, min_max = 0, 1, 2
>>> minimum, maximum = 0, 1

Теперь обращение к элементам t может выглядеть чуть логичнее:

>>> t[model_1][min_max][maximum]
23.87

Но самый простой способ это использование встроенного модуля collections из стандартной библиотеки. Благодаря ему «очень легко» создать структуру кортежа из примера выше:

>>> import collections
>>>
>>> models = collections.namedtuple('models', 'model_1 model_2')
>>> params = collections. namedtuple('params', 'name mean min_max')
>>> limit = collections.namedtuple('limit', 'minimum maximum')

Потом, точно также «очень легко» создать сам именованный кортеж:

>>> Models = models(params('mod_1', 8.71, limit(-1.32, 23.87)),
...                 params('mod_2', 5.12, limit(-0.41, 19.86)))

А вот извлекать элементы из такого кортежа, действительно легко:

>>> Models.model_1.min_max.maximum
23.87

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

кортежей Python — javatpoint

 Пустой кортеж: ()
Кортеж с целыми числами: (4, 6, 8, 10, 12, 14)
Кортеж с разными типами данных: (4, 'Python', 9. 3)
Вложенный кортеж: ('Python', {4: 5, 6: 2, 8: 2}, (5, 3, 5, 6))
 

 (4, 5.7, «Кортежи», ['Python', 'Кортежи'])
<класс 'кортеж'>
<класс 'Ошибка Типа'>
 

 <класс 'ул'>
<класс 'кортеж'>
<класс 'кортеж'>
 

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

 Элемент с индексом -1: Коллекция
Элементы между -4 и -1: ("Python", "Tuple", "Ordered")
 

 Элементы между индексами 1 и 3: ("Кортеж", "Упорядочено")
Элементы между индексами 0 и -4: ("Python", "Tuple")
Весь кортеж: («Python», «Кортеж», «Упорядоченный», «Неизменяемый», «Коллекция», «Объекты»)
 

 объект «кортеж» не поддерживает удаление элемента
имя 'tuple_' не определено
 

 Исходный кортеж: ('Python', 'Tuples')
Новый кортеж: ('Python', 'Кортежи', 'Питон', 'Кортежи', 'Питон', 'Кортежи')
 

 Количество 2 в T1: 5
Количество java в T2: 2
 

 Первое появление 1 равно 2
Первое появление 1 после 4-го индекса: 6
 

 Верно
ЛОЖЬ
ЛОЖЬ
Истинный
 

 Питон
Кортеж
Заказал
Неизменный
 

 объект «кортеж» не поддерживает назначение элементов
("Python", "Tuple", "Ordered", "Immutable", [1, 2, 10, 4])
(«Питон», «Предметы»)
 

 («Питон», «Кортеж», «Упорядочено», «Неизменяемый», 4, 5, 6)
 

Кортеж Python — узнайте на примере

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

Кортеж — это упорядоченный набор значений.

Кортежи очень похожи на списки:

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

кроме:

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

Создать кортеж

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

 # Кортеж целых чисел
Т = (1, 2, 3)
# Кортеж строк
T = ('красный', 'зеленый', 'синий') 

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

 # Кортеж со смешанными типами данных
T = (1, 'abc', 1.23, True) 

Кортеж, содержащий ноль элементов, называется пустым кортежем , и вы можете создать кортеж с пустыми
скобки  ()

 # Пустой кортеж
T = () 

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

 # Кортеж без скобок
T = 1, 'abc', 1.23, True 

Для создания кортежа скобки не нужны. Именно конечные запятые действительно определяют кортеж. Но их использование не повредит; также они помогают сделать кортеж более заметным.

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

 Т = (4,)
печать (тип (Т))
# Выводит  

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

 # Не кортеж
Т = (4)
печать (тип (Т))
# Выводит  

Конструктор tuple()

Вы можете преобразовывать другие типы данных в кортежи с помощью конструктора Python tuple().

 # Преобразование списка в кортеж
T = кортеж ([1, 2, 3])
печать (Т)
# Отпечатки (1, 2, 3) 

 # Преобразование строки в кортеж
T = кортеж ('abc')
печать (Т)
# Выводит ('a', 'b', 'c') 

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

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

 T = ('красный', ('зеленый', 'синий', 'желтый') 

Упаковка и распаковка кортежа

Упаковка кортежа

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

 T = («красный», «зеленый», «синий», «голубой»)
печать (Т)
# Выводит («красный», «зеленый», «синий», «голубой») 

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

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

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

 T = («красный», «зеленый», «синий», «голубой»)
(а, б, в, г) = Т
печать (а)
# Печатает красный
печать (б)
# Печатает зеленый
печать (с)
# Печатает синим
печать (г)
# Печатает голубой 

В приведенном выше примере кортеж T распаковывается в переменные a, b, c и d.

При распаковке количество переменных слева должно совпадать с количеством элементов в кортеже.

 # Распространенные ошибки при распаковке кортежа
T = («красный», «зеленый», «синий», «голубой»)
(а, б) = Т
# Вызывает ValueError: слишком много значений для распаковки
T = («красный», «зеленый», «синий»)
(а, б, в, г) = Т
# Вызывает ValueError: недостаточно значений для распаковки (ожидалось 4, получено 3) 

Usage

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

 # Поменять местами значения 'a' и 'b'
а = 1
б = 99
а, б = б, а
печать (а)
# Отпечатков 99
печать (б)
# Выводит 1 

При распаковке кортежа правая сторона может быть любой последовательностью (кортеж, строка или список).

 # Разделить адрес электронной почты на имя пользователя и домен
адрес = '[электронная почта защищена]'
пользователь, домен = addr.split('@')
печать (пользователь)
# Печатает боб
печать (домен)
# Выводит python.org 

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

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

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

 T = ('красный', 'зеленый', 'синий', 'желтый', 'черный')
печать (Т [0])
# Печатает красный
печать (Т [2])
# Выводит синий 

Вы также можете получить доступ к кортежу с помощью отрицательной индексации. Отрицательные индексы отсчитываются в обратном порядке от конца кортежа. Таким образом,  T[-1]  относится к последнему элементу,  T[-2]  – к предпоследнему и так далее.

 T = («красный», «зеленый», «синий», «желтый», «черный»)
печать (Т [-1])
# Печатает черным
печать (Т [-2])
# Печатает желтый 

Нарезка кортежа

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

 T = ('a', 'b', 'c', 'd', 'e', ​​'f')
печать (Т [2: 5])
# Печатает ('c', 'd', 'e')
печать (Т [0: 2])
# Печатает ('a', 'b')
печать (Т [3:-1])
# Выводит ('d', 'e') 

Изменить элементы кортежа

Кортежи неизменяемы (неизменяемы). После создания кортежа его нельзя изменить.

 T = («красный», «зеленый», «синий»)
T[0] = 'черный'
# Вызывает TypeError: объект 'tuple' не поддерживает назначение элемента 

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

 Т = (1, [2, 3], 4)
Т[1][0] = 'хх'
печать (Т)
# Выводит (1, ['xx', 3], 4) 

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

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

 T = («красный», «зеленый», «синий»)
del T 

Конкатенация и повторение кортежа

Кортежи можно объединять с помощью оператора конкатенации + или оператора репликации *

 # Concatenate
T = ('красный', 'зеленый', 'синий') + (1, 2, 3)
печать (Т)
# Печатает ("красный", "зеленый", "синий", 1, 2, 3)
# Репликация
Т = ('красный',) * 3
печать (Т)
# Выводит ('red', 'red', 'red') 

Найти длину кортежа

Чтобы узнать, сколько элементов содержит кортеж, используйте метод len().

 T = («красный», «зеленый», «синий»)
печать (длина (Т))
# Выводит 3 

Проверить, существует ли элемент в кортеже

Чтобы определить, входит ли значение в кортеж или нет, вы можете использовать операторы in и not in с оператором if.

 # Проверить наличие
T = («красный», «зеленый», «синий»)
если «красный» в T:
    распечатать('да')
# Проверить отсутствие
T = («красный», «зеленый», «синий»)
если «желтый» не в T:
    print('yes') 

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

Чтобы перебрать элементы кортежа, используйте простой цикл for.

 T = («красный», «зеленый», «синий»)
для элемента в T:
    печать (элемент)
# Печатает красный зеленый синий 

Сортировка кортежа

Существует два метода сортировки кортежа.

Метод 1 : Используйте встроенный метод sorted(), который принимает любой объект последовательности.

 T = ('cc', 'aa', 'dd', 'bb')
печать (кортеж (отсортировано (T)))
# Выводит ('aa', 'bb', 'cc', 'dd') 

Метод 2 : Преобразование кортежа в изменяемый объект, такой как список (используя конструктор списка), получение доступа к вызову метода сортировки (sort ()) и преобразовать его обратно в кортеж.

 T = ('cc', 'aa', 'dd', 'bb')
tmp = list(T) # преобразовать кортеж в список
tmp.