Как создать кортеж в python из 2 элементов

Кортежи (tuple)

Сегодня я расскажу о таком типе данных, как кортежи (tuple) и о том, где они применяются.

Кортеж, по сути — неизменяемый список.

Зачем нужны кортежи, если есть списки?

• Защита от дурака. То есть кортеж защищен от изменений, как намеренных (что плохо), так и случайных (что хорошо).
• Меньший размер. Дабы не быть голословным:

Как работать с кортежами?

С преимуществами кортежей разобрались, теперь встает вопрос — а как с ними работать. Примерно так же, как и со списками.

Создаем пустой кортеж:

    Создаем кортеж из одного элемента:

 
 
 
Ну и создать кортеж из итерируемого объекта можно с помощью все той же пресловутой функции tuple()
Операции с кортежами
Все операции над списками, не изменяющие список (сложение, умножение на число, методы index() и count() и некоторые другие операции). Можно также по-разному менять элементы местами и так далее.
Например, гордость программистов на python - поменять местами значения двух переменных:
Для вставки кода на Python в комментарий заключайте его в теги 




Модуль csv - чтение и запись CSV файлов
Создаём сайт на Django, используя хорошие практики. Часть 1: создаём проект
Онлайн-обучение Python: сравнение популярных программ


Книги о Python
GUI (графический интерфейс пользователя)
Курсы Python
Модули
Новости мира Python
NumPy
Обработка данных
Основы программирования
Примеры программ
Типы данных в Python
Видео
Python для Web
Работа для Python-программистов


Сделай свой вклад в развитие сайта!
Самоучитель Python
Карта сайта
Отзывы на книги по Python
Реклама на сайте

Как создать кортеж в python из 2 элементов
Кортеж (tuple) представляет последовательность элементов, которая во многом похожа на список за тем исключением, что кортеж является неизменяемым (immutable) типом. Поэтому мы не можем добавлять или удалять элементы в кортеже, изменять его.
Для создания кортежа используются круглые скобки, в которые помещаются его значения, разделенные запятыми:
tom = ("Tom", 23) print(tom) # ("Tom", 23)
Также для определения кортежа мы можем просто перечислить значения через запятую без применения скобок:
tom = "Tom", 23 print(tom) # ("Tom", 23)
Если вдруг кортеж состоит из одного элемента, то после единственного элемента кортежа необходимо поставить запятую:
tom = ("Tom",)
Для создания кортежа из другого набора элементов, например, из списка, можно передать список в функцию tuple() , которая возвратит кортеж:
data = ["Tom", 37, "Google"] tom = tuple(data) print(tom) # ("Tom", 37, "Google")
С помощью встроенной функции len() можно получить длину кортежа:
tom = ("Tom", 37, "Google") print(len(tom)) # 3
Обращение к элементам кортежа
Обращение к элементам в кортеже происходит также, как и в списке, по индексу. Индексация начинается также с нуля при получении элементов с начала списка и с -1 при получении элементов с конца списка:
tom = ("Tom", 37, "Google", "software developer") print(tom[0]) # Tom print(tom[1]) # 37 print(tom[-1]) # software developer
Но так как кортеж - неизменяемый тип (immutable), то мы не сможем изменить его элементы. То есть следующая запись работать не будет:
tom[1] = "Tim"
При необходимости мы можем разложить кортеж на отдельные переменные:
name, age, company, position = ("Tom", 37, "Google", "software developer") print(name) # Tom print(age) # 37 print(position) # software developer print(company) # Google
Получение подкортежей
Как и в списках, можно получить часть кортежа в виде другого кортежа
tom = ("Tom", 37, "Google", "software developer") # получем подкортеж с 1 по 3 элемента (не включая) print(tom[1:3]) # (37, "Google") # получем подкортеж с 0 по 3 элемента (не включая) print(tom[:3]) # ("Tom", 37, "Google") # получем подкортеж с 1 по послдений элемент print(tom[1:]) # (37, "Google", "software developer")
Кортеж как параметр и результат функций
Особенно удобно использовать кортежи, когда необходимо возвратить из функции сразу несколько значений. Когда функция возвращает несколько значений, фактически она возвращает в кортеж:
def get_user(): name = "Tom" age = 22 company = "Google" return name, age, company user = get_user() print(user) # ("Tom", 37, "Google")
При передаче кортежа в функцию с помощью оператора * его можно разложить на отдельные значения, которые передаются параметрам функции:
def print_person(name, age, company): print(f"Name: Age: Company: ") tom = ("Tom", 22) print_person(*tom, "Microsoft") # Name: Tom Age: 22 Company: Microsoft bob = ("Bob", 41, "Apple") print_person(*bob) # Name: Bob Age: 41 Company: Apple
Перебор кортежей
Для перебора кортежа можно использовать стандартные циклы for и while . С помощью цикла for:
tom = ("Tom", 22, "Google") for item in tom: print(item)
С помощью цикла while:
tom = ("Tom", 22, "Google") i = 0 while i < len(tom): print(tom[i]) i += 1
Проверка наличия значения
Как для списка с помощью выражения элемент in кортеж можно проверить наличие элемента в кортеже:
user = ("Tom", 22, "Google") name = "Tom" if name in user: print("Пользователя зовут Tom") else: print("Пользователь имеет другое имя")
Кортежи в Python


Понятие кортежа в Python
Создание кортежей в Python
Доступ по индексу и срезы кортежей
Операторы кортежей в Python
Функции и методы кортежей в Python
Зачем нужны кортежи, если есть списки?
Краткие итоги параграфа
Вопросы и задания для самоконтроля

Понятие кортежа в Python
Еще одной упорядоченной коллекцией объектов в Python являются кортежи, которые практически во всем похожи на списки. Однако в отличие от списков кортежи не могут изменяться непосредственно, поэтому многие операции применимые к спискам, становятся недоступными для кортежей. Кроме того, литералы кортежей записываются не в квадратных, а в круглых скобках. Итак, что же такое кортеж?
(от англ. tuple) – это неизменяемая упорядоченная коллекция объектов произвольного типа. Сами объекты называются , а доступ к ним может быть получен при помощи целочисленного индекса или среза.
Поскольку кортежи очень похожи на списки, дальнейшее изложение материала будет практически полностью дублировать содержание параграфа о списках. Однако пренебрегать чтением и решением задач не стоит, т.к. это хорошая возможность еще раз повторить и закрепить основные понятия, связанные с упорядоченными последовательностями.
Создание кортежей в Python
Проще всего литерал кортежа в Python создается при помощи круглых скобок, внутри которых элементы кортежа перечисляются через запятую (см. пример №1 ). В случае необходимости последний элемент кортежа можно также завершать запятой. Это никак не повлияет на количество элементов кортежа, а значит и его длину. Однако, если кортеж состоит из одного элемента, то запятую после него нужно указывать обязательно, иначе интерпретатор не сможет отличить кортеж от простого значения или выражения.
Код Результат pythonCodes
# Получаем пустой кортеж. tpl_1 = () # Выведет (). print(tpl_1, end='\n\n') # Получаем кортеж с одним элементом. # (3) нельзя, т.к. это просто число 3. tpl_2 = (3,) # Выведет (3,). print(tpl_2, end='\n\n') # Элементы перечисляем через запятую. tpl_3 = (15, "Иван", None, 34.5, True) # Выведет (15, 'Иван', None, 34.5, True). print(tpl_3, end='\n\n') # Последнюю запятую можно не опускать. tpl_4 = (1, 2, 3,) # Выведет (1, 2, 3). print(tpl_4, end='\n\n') # Эл-ми могут быть любые объекты, любой вложенности. tpl_5 = ( , 0.3, ) # Выведет (, 0.3). print(tpl_5)
() (3,) (15, 'Иван', None, 34.5, True) (1, 2, 3) (, 0.3) 
Пример №1. Создание кортежей в Python (часть 1).
Как видим, внутри кортежей действительно разрешается использовать объекты любого типа данных, создавая при этом любые их комбинации и уровни вложенности. А благодаря наличию в синтаксисе круглых скобок, сложные и объемные литералы кортежей можно без проблем записывать на нескольких строках, придавая исходному коду удобочитаемый вид.
Создать кортеж можно также при помощи встроенного конструктора типа tuple() . Если использовать его без аргумента, то он вернет нам пустой кортеж. Если же передать ему итерируемый объект, например, строку или список, то конструктор вернет кортеж, элементами которого будут соответствующие элементы переданного объекта (см. пример №2 ).
Код Результат pythonCodes
# Получаем пустой кортеж. tpl_1 = tuple() # Выведет (). print(tpl_1, end='\n\n') # Получаем кортеж из строки. tpl_2 = tuple('123') # Выведет ('1', '2', '3'). print(tpl_2, end='\n\n') # Преобразуем список в кортеж. tpl_3 = tuple([15, "Иван", None, 34.5, True]) # Выведет (15, 'Иван', None, 34.5, True). print(tpl_3)
() ('1', '2', '3') (15, 'Иван', None, 34.5, True) 
Пример №2. Создание кортежей в Python (часть 2).
Что касается генераторов, то создать кортеж с их помощью не получится, т.к. как генераторы заключенные в круглые скобки сами являются «выражениями генераторами».
Доступ по индексу и срезы кортежей
Операции доступа по индексу и получения срезов для кортежей имеют практически тот же самый синтаксис и смысл, что и для списков (см. пример №3 ).
Код Результат pythonCodes
# Формируем кортеж из целых чисел. # Можно и без скобок, но лучше явно определять кортеж. tpl_1 = 1, 2, 3, 4, 5 # Получим 1, т.е. 1-й эл-т кортежа (нумерация начинается с нуля). print('tpl_1[0] ->', tpl_1[0], end='\n\n') # Выводим последний эл-т кортежа (кол-во эл-тов кортежа минус один). # Получим 5. print('tpl_1[len(tpl_1)-1] ->', tpl_1[len(tpl_1)-1], end='\n\n') # Можно использовать отрицательные индексы, тогда # нумерация будет идти с конца и начинаться с -1. # Опять же получим 5. print('tpl_1[-1] ->', tpl_1[-1])
tpl_1[0] -> 1 tpl_1[len(tpl_1)-1] -> 5 tpl_1[-1] -> 5 
Пример №3. Доступ к элементам кортежа по индексу (часть 1).
В принципе во многих случаях можно определять кортеж и без использования круглых скобок, т.к. для его определения важно именно наличие запятых между объектами, которые станут элементами кортежа. Однако все зависит от конкретной ситуации. Например, запись вида my_func(x, y) означает, что данной функции должно быть передано два аргумента, а запись my_func((x, y)) означает, что функции должен быть передан кортеж из двух элементов. Так что лучше всегда явно определять кортеж, используя для этого круглые скобки.
Поскольку в результате обращения к элементу кортежа по его индексу возвращается некоторый объект, расположенный по указанному смещению, то для получения доступа к элементам на более глубоком уровне вложенности может потребоваться целая цепочка из нескольких индексов (см. пример №4 ).
Код Результат pythonCodes
# Простой пример вложенных в кортеж списков. tpl_1 = (3.14, ['abc', [4, 5]], 'кот') # Выводим число 3.14 (1-й элемент кортежа). print('tpl_1[0] ->', tpl_1[0], end='\n\n') # Выводим 2-й символ строки 'кот'. print('tpl_1[2][1] ->', tpl_1[2][1], end='\n\n') # Выводим 3-й символ строки 'abc'. print('tpl_1[1][0][2] ->', tpl_1[1][0][2], end='\n\n') # Выводим число 5 вложенного списка [4, 5]. print('tpl_1[1][1][1] ->', tpl_1[1][1][1])
tpl_1[0] -> 3.14 tpl_1[2][1] -> о tpl_1[1][0][2] -> c tpl_1[1][1][1] -> 5 
Пример №4. Доступ к элементам кортежа по индексу (часть 2).
Следует отметить, что цепочка доступа к конкретному элементу может иметь и более сложную конструкцию, включающую не только квадратные скобки с индексами для доступа к элементам строк, кортежей или списков, но и квадратные скобки с ключами для доступа к элементам словарей, и точки для доступа к атрибутам объектов. Например, для кортежа tpl = (, 0.3) цепочка получения доступа ко второму элементу вложенного списка [4, 5] будет иметь вид tpl[0]['two'][1][1] .
Что касается получения срезов для кортежей, то для них справедлив тот же порядок, что и для других упорядоченных коллекций, т.е. строк и списков (см. пример №5 ).
Код Результат pythonCodes
# Формируем кортеж из целых чисел. tpl_1 = (1, 2, 3, 4, 5, 6, 7) # Получаем кортеж из первых двух эл-тов. print('tpl_1[0:2] ->', tpl_1[0:2], end='\n\n') # Можно и так, все равно получим (1, 2). print('tpl_1[:2] ->', tpl_1[:2], end='\n\n') # Получаем кортеж из посл-х двух эл-тов ((6, 7)). print('tpl_1[-2:] ->', tpl_1[-2:], end='\n\n') # Получаем кортеж (3, 4, 5) из эл-тов с 3-го по 5-й. print('tpl_1[2:5] ->', tpl_1[2:5], end='\n\n') # Получим (2, 3, 4, 5) (использ. отриц. индексы). print('tpl_1[-6:-2] ->', tpl_1[-6:-2], end='\n\n') # Убедимся, что кортеж не изменился. print('tpl_1 ->', tpl_1, end='\n\n') # Напоследок выведем копию кортежа. print('tpl_1[:] ->', tpl_1[:])
tpl_1[0:2] -> (1, 2) tpl_1[:2] -> (1, 2) tpl_1[-2:] -> (6, 7) tpl_1[2:5] -> (3, 4, 5) tpl_1[-6:-2] -> (2, 3, 4, 5) tpl_1 -> (1, 2, 3, 4, 5, 6, 7) tpl_1[:] -> (1, 2, 3, 4, 5, 6, 7) 
Пример №5. Операция взятия среза у кортежей.
Опять же, при извлечении срезов следует помнить, что нумерация элементов в кортежах начинается с нуля, а элемент с индексом второго предела, указанного в квадратных скобках, не будет присутствовать в срезе. Например, в срезе кортежа tpl_1[0:5] будут присутствовать первые пять элементов с индексами от 0 до 4 , но не включая элемент с индексом 5 .
Как и в случае со строками и списками, один или оба предела среза можно опускать. Если не указывать первый предел, интерпретатор будет начинать срез с первого элемента кортежа (с индексом 0 ), а при отсутствии второго предела срез будет идти до конца кортежа. Если опустить оба предела, мы получим копию кортежа. При необходимости разрешается указывать и третий предел, который будет задавать шаг среза (см. пример №6 ).
Код Результат pythonCodes
# Формируем кортеж из целых чисел. tpl_1 = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10) # Выводим его для наглядности. print('tpl_1 ->', tpl_1, end='\n\n') # Выводим каждый 2-й элемент среза (слева направо). # (1, 3, 5, 7). print('tpl_1[0:7:2] ->', tpl_1[0:7:2], end='\n\n') # Можно и так, получим опять (1, 3, 5, 7). print('tpl_1[:7:2] ->', tpl_1[:7:2], end='\n\n') # Выводим каждый третий элемент всего кортежа. # (1, 4, 7, 10). print('tpl_1[::3] ->', tpl_1[::3], end='\n\n') # Выводим каждый 2-й эл-т, считая с конца среза (-1, -2. ). # Сам срез берется справа налево, если шаг отрицательный. # (9, 7, 5). print('tpl_1[8:2:-2] ->', tpl_1[8:2:-2], end='\n\n') # Выводим каждый 3-й эл-т среза, считая справа налево. # (8, 5). print('tpl_1[-3:1:-3] ->', tpl_1[-3:1:-3], end='\n\n') # Выводим каждый 2-й эл-т, считая с конца кортежа. # (10, 8, 6, 4, 2). print('tpl_1[::-2] ->', tpl_1[::-2])
tpl_1 -> (1, 2, 3, 4, 5, 6, 7, 8, 9, 10) tpl_1[0:7:2] -> (1, 3, 5, 7) tpl_1[:7:2] -> (1, 3, 5, 7) tpl_1[::3] -> (1, 4, 7, 10) tpl_1[8:2:-2] -> (9, 7, 5) tpl_1[-3:1:-3] -> (8, 5) tpl_1[::-2] -> (10, 8, 6, 4, 2) 
Пример №6. Порядок использования шага среза у кортежей.
Как видим, шаг среза также может иметь отрицательное значение (аналогично спискам и строкам). В этом случае отсчет элементов кортежа и шагов ведется в противоположном направлении, а границы среза указываются справа налево, т.е. индекс элемента, стоящего правее в кортеже должен указываться первым. Например, в срезе примера tpl_1[-3:1:-3] отсчет ведется справа налево, начиная с 3 -го элемента, отсчитываемого с конца кортежа, до элемента с индексом 1 , который находится левее и в срез не включается.
Неизменяемость кортежей означает, что для них запрещены операции добавления новых элементов, а также удаления или замены уже существующих. При этом мы спокойно можем изменять конкретные элементы кортежа, если они это допускают (см. пример №7 ).
Код Результат pythonCodes
# Формируем кортеж из 3-х элементов. tpl_1 = ('и', ['b', [4, 5]], 0.3) # Изменяем 1-й эл-т вложенного списка [4, 5]. tpl_1[1][1][0] = 's' # Выведет ('и', ['b', ['s', 5]], 4). print('tpl_1[1][1][0] = \'s\' ->', tpl_1, end='\n\n') # А вот так уже не получится (кортеж неизменяем). tpl_1[0] = 7 # Выведет исключение. print('tpl_1[0] = 7 ->', tpl_1)
tpl_1[1][1][0] = 's' -> ('и', ['b', ['s', 5]], 0.3) 'tuple' object does not support item assignment 
Пример №7. Изменение элементов кортежей.
Операторы кортежей в Python
Поскольку кортежи относятся к упорядоченным последовательностям, операторы + , += , * и *= имеют для них практически тот же смысл, что и для списков и строк (см. пример №8 ).
Код Результат pythonCodes
# Формируем кортежи. tpl_1 = (1, 2, 3) tpl_2 = (4, 5, 6) # Осуществляем конкатенацию кортежей (т.е. объединение). # Выведет (1, 2, 3, 4, 5, 6). print('tpl_1 + tpl_2 ->', tpl_1 + tpl_2, end='\n\n') # Объединяем с самим собой 3 раза (tpl_1 + tpl_1 + tpl_1). # Выведет (1, 2, 3, 1, 2, 3, 1, 2, 3). print('tpl_1*3 ->', tpl_1*3, end='\n\n') # Тоже, что и tpl_1 = tpl_1 + tpl_2. tpl_1 += tpl_2 # Теперь tpl_1 == (1, 2, 3, 4, 5, 6). print('tpl_1 += tpl_2 ->', tpl_1)
tpl_1 + tpl_2 -> (1, 2, 3, 4, 5, 6) tpl_1*3 -> (1, 2, 3, 1, 2, 3, 1, 2, 3) tpl_1 += tpl_2 -> (1, 2, 3, 4, 5, 6) 
Пример №8. Использование операторов + и * применительно к кортежам.
Незабываем, что по обе стороны от оператора сложения должны находиться кортежи (в общем случае это должны быть последовательности одного и того же типа), т.к. интерпретатор не занимается автоматическим приведением типов и просто выдаст ошибку.
Далее. В отношении элементов кортежа мы можем использовать оператор проверки на вхождение in , который совершает поиск требуемого объекта (левый операнд) среди элементов целевого кортежа (правый операнд). Опять же, в случае успеха операция возвращает True , иначе – False (см. пример №9 ).
Код Результат pythonCodes
# Формируем кортеж. tpl_1 = (1, 2, 3, [4, 5]) # Проверяем наличие числа 8 в кортеже. answer = 8 in tpl_1 # Если операция вернула True, if answer: # выводим подтверждение на экран. print('Число 8 присутствует в кортеже tpl_1.', end='\n\n') # Иначе else: # выводим на экран отрицание. print('Числа 8 нет в кортеже tpl_1.', end='\n\n') # Проверим вхождение, используя not in. if 5 not in tpl_1[3]: # Выводим подтверждение на экран. print('Число 5 отсутствует в tpl_1[3].') # Иначе else: # Выводим на экран сообщение. print('Число 5 присутствует в tpl_1[3].')
Числа 8 нет в кортеже tpl_1. Число 5 присутствует в tpl_1[3]. 
Пример №9. Использование оператора in применительно к кортежам.
Напомним, что оператор in может использоваться не только самостоятельно, но и совместно с оператором отрицания not , который инверсирует возвращаемое логическое значение оператора in . Соответственно, например, операция 'крот' not in ('кот', 'кит') вернет True вместо False .
Если возникает необходимость в обходе элементов кортежа, то, по аналогии со строками и списками, можно смело использовать оператор цикла for (см. пример №10 ).
Код Результат pythonCodes
# Формируем кортеж. tpl_1 = (1, 2, 3, 4, 5) # Проверим все ли числа в кортеже целые. for elem in tpl_1: # Если эл-т не является целым числом, if type(elem) is not int: # выводим сообщение на экран print('Не все эл-ты кортежа целые числа.') # и прерываем цикл. break # Eсли цикл завершился успешно, else: # выводим положительный результат. print('Все эл-ты в кортеже - целые числа.')
Все эл-ты в кортеже - целые числа. 
Пример №10. Использование цикла for для обхода элементов кортежа.
Поскольку кортежи относятся к неизменяемым последовательностям, оператор удаления del к элементам кортежа неприменим, хотя сам кортеж данный оператор спокойно удаляет.
Функции и методы кортежей в Python
Что касается методов кортежей, то для них применимы общие методы упорядоченных последовательностей, которые не приводят к их изменению. Я насчитал всего два таких метода.

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

Код Результат pythonCodes
# Создаем кортеж для манипуляций. tpl = ('a', 'b', 'c', 'a', 'b', 'c') # Ищем кол-во эл-тов со значением 'b' n_1 = tpl.count('b') # Получим 2. print('tpl.count("b") ->', n_1) # Ищем кол-во эл-тов со значением 23 n_2 = tpl.count(23) # Получим 0, т.к. эл-тов с таким значением нет в кортеже. print('tpl.count(23) ->', n_2, end='\n\n') # Ищем индекс 1-го встретившегося эл-та со значением 'c'. index_1 = tpl.index('c') # Выведет 2. print('tpl.index("c") ->', index_1) # Тоже самое, но ищем с 4-го элемента кортежа. index_2 = tpl.index('c', 3) # Получим индекс 5, т.к. ищем не сначала кортежа. print('tpl.index("c", 3) ->', index_2) 
tpl.count("b") -> 2 tpl.count(23) -> 0 tpl.index("c") -> 2 tpl.index("c", 3) -> 5 
Пример №11. Методы кортежей.
Применимы к кортежам и некоторые встроенные функции, которые получают доступ к элементам кортежа, но не изменяют его непосредственно: len() (возвращает количество элементов в кортеже), min() (возвращает элемент с минимальным значением, при этом элементы должны быть одного типа с возможностью сравнения), max() (возвращает элемент с максимальным значением, при этом элементы должны быть одного типа с возможностью сравнения), sum() (возвращает сумму элементов кортежа, при этом элементы должны быть числами) и т. д.
Зачем нужны кортежи, если есть списки?
«Ну, и зачем нам эти кортежи, если есть списки?» – часто спрашивают начинающие программисты. Действительно, кортежи копируют списки и при этом сильно ограничены в возможностях, да еще и неизменяемые. Однако ключевая мысль здесь – «неизменяемые». Благодаря этому мы можем быть уверены, что кортеж не будет изменен через другую ссылку в другом месте программы. Кроме того, встречаются ситуации, когда использование списков недопустимо, например, в качестве ключей словаря кортежи можно использовать, а списки нет. Именно поэтому, когда в программе нужно использовать упорядоченные коллекции объектов с возможностью их изменения в будущем, нужно выбирать списки; если же нужны фиксированные коллекции объектов, следует выбирать кортежи.
Хотя сами кортежи и неизменяемы, они могут содержать элементы изменяемых типов (например, списки или словари), а те могут быть изменены программой. Такие кортежи использовать в качестве ключей словаря не получится.
Второй важной особенностью кортежей является то, что за счет неизменяемости, а значит и более простой внутренней структуры, кортежи в общем случае занимают в памяти меньше места, чем списки (см. пример №12 ). Как следствие, операции с кортежами являются более производительными, хотя и не такими гибкими.
Код Результат pythonCodes
# Импортируем модуль sys. import sys # Создаем кортеж и список. tpl = (1, 2, 3, 4, 5) li = [1, 2, 3, 4, 5] # Получаем размеры. print('Размер tpl:', sys.getsizeof(tpl)) print('Размер li:', sys.getsizeof(li))
Размер tpl: 80 Размер li: 120 
Пример №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» стандартной библиотеки.
Благодаря своей неизменяемости кортежи занимают в памяти меньше места, чем списки, а операции с ними являются более производительными. При этом следует помнить, что хотя сами кортежи и неизменяемы, их элементы изменяемых типов (например, списки или словари) могут быть изменены программой (такие кортежи использовать в качестве ключей словаря не получится).

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

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


На страницу подписки 
Вопросы и задания для самоконтроля
1. Какие из утверждений относятся к кортежам: коллекция объектов, упорядоченная последовательность, неизменяемая и неупорядоченная последовательность, изменяемая неупорядоченная коллекция объектов, неизменяемая упорядоченная последовательность элементов? Показать решение.
Ответ. Кортежи – это неизменяемые упорядоченные коллекции объектов (последовательности элементов) произвольного типа. Значит по отношению к ним верны утверждения: коллекция объектов, упорядоченная последовательность, неизменяемая упорядоченная последовательность элементов.
2. Разрешается ли использовать в качестве элементов кортежа списки? Показать решение.
Ответ. Кортежи – это неизменяемые упорядоченные коллекции объектов произвольного типа. Значит мы можем использовать в качестве их элементов и списки, и словари и любые другие изменяемые объекты.
3. Для чего нужны кортежи, если есть списки? Показать решение.
Ответ. Кортежи неизменяемы, поэтому они могут использоваться в качестве ключей словаря (пусть и с ограничениями на неизменяемость вложенных элементов), а также хорошо подходят для случаев, когда нужно быть уверенным в целостности данных. Кроме того, кортежи занимают меньше памяти, чем списки, а значит с кортежами производительность операций будет выше.
4. Какие из представленых литералов относятся к типу tuple : ('tuple', 'list') , '(3, 4)' , (5,) , 'Питон, Python' ? Проверьте типы программно. Показать решение.
Ответ. Тип tuple : ('tuple', 'list') , (5,) .
Решение Результат pythonCodes
# Выводим типы представленных литералов. print("Тип ('tuple', 'list'):", type(('tuple', 'list'))) print("Тип '(3, 4)':", type('(3, 4)')) print("Тип (5,):", type((5,))) print("Тип 'Питон, Python':", type('Питон, Python'))
Тип ('tuple', 'list'): Тип '(3, 4)': Тип (5,): Тип 'Питон, Python':
5. Дан кортеж (([1, 2], ['012', 'abc']), [4, 3]) . Как получить доступ к символу 'c' строки 'abc' ? Показать решение.
Ответ. Доступ к элементам вложенных последовательностей вроде списков, строк или кортежей можно получить через последовательную цепочку обращений по индексу.
Решение Результат pythonCodes
# Сохраняем кортеж в переменной. tpl = (([1, 2], ['012', 'abc']), [4, 3]) # Используем цепочку доступа по индексу. print(tpl[0][1][1][2])
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] ? Проверьте свой ответ программно. Показать решение.
Условие Решение pythonCodes
# Получаем срезы. 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) . Как это сделать, ведь кортежи неизменяемы? Показать решение.
Ответ. Да, кортежи относятся к неизменяемым типам данных. Поэтому изменить их непосредственно не получится, но никто не запрещает нам создать новый кортеж с желаемым значением.
Решение Результат pythonCodes
# Сохраним кортеж в переменной. 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]) попытаться изменить в списке одно из значений? Объясните свой ответ. Показать решение.
Ответ. Мы не можем изменять сами кортежи, т.е. удалять, добавлять или перемещать его элементы, которые представляют собой объекты произвольного типа. Однако изменять значения элементов кортежа, которые являются объектами изменяемых типов мы можем. Поэтому мы можем свободно изменить любое из значений списка данного кортежа.
Решение Результат pythonCodes
# Целевой кортеж. 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 в контексте кортежей? Показать решение.
Ответ. Кортежи, как и строки, относятся к неизменяемым типам данных. Поэтому у них отсутствуют методы split и clear , которые связаны с изменением кортежей.
10. Дополнительные тесты по теме расположены в разделе «Кортежи» нашего сборника тестов.
11. Дополнительные упражнения и задачи по теме расположены в разделе «Кортежи» нашего сборника задач и упражнений.
Быстрый переход к другим страницам

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


okpython.net Copyright © 2022-2023.
Как создать кортеж в python из 2 элементов

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 = "".format((t2 - t1)/t1) >>> print(f'Время копирования списка раз: ') Время копирования списка 1000000 раз: 0.5761922669999961 >>> print(f'Время копирования кортежа раз: ') Время копирования кортежа 1000000 раз: 0.22475764600000048 >>> print(f'Разница: ') Разница: -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)) >>> my_tuple = (5,) >>> print(type(my_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 = >>> print(tuple(my_set)) (2, 5, 6, 7) 
Однако при подобном преобразовании словаря в кортеж останутся только ключи:
>>> my_dict = >>> print(tuple(my_dict)) ('яблоки', 'апельсины') 
Число напрямую преобразовать в кортеж нельзя:
>>> num = 178394 >>> print(tuple(num)) Traceback (most recent call last): File "", line 1, in 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) 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 "", line 1, in TypeError: 'tuple' object doesn't support item deletion >>> my_tuple[2] = 9 Traceback (most recent call last): File "", line 1, in 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 элемента используется index() :
>>> 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 
Подсчет элементов
Для подсчета числа вхождений какого-либо значения в кортеже используется count() :
>>> 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))
>>> numbers = (3, 2, 1, 6, 7, 2, 2, 9) >>> print(set(numbers))
Сравнение кортежей
>>> 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'Кортеж состоит из положительных чисел') print(f'Кортеж состоит из положительных чисел') 
Задание 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'Минимальное число: ') print(f'Максимальное число: ') 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 
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) 
Подведем итоги
Кортежи во многом похожи на списки. Выбор в пользу кортежей стоит делать тогда, когда необходимо защитить данные от случайного изменения. Кроме того, многие операции с кортежами выполняются быстрее и занимают меньше памяти. В следующей статье будем изучать множества.

Особенности, сферы применения, установка, онлайн IDE
Все, что нужно для изучения Python с нуля – книги, сайты, каналы и курсы
Типы данных: преобразование и базовые операции
Методы работы со строками
Методы работы со списками и списковыми включениями
Методы работы со словарями и генераторами словарей
Методы работы с кортежами
Методы работы со множествами
Особенности цикла for
Условный цикл while
Функции с позиционными и именованными аргументами
Анонимные функции
Рекурсивные функции
Функции высшего порядка, замыкания и декораторы
Методы работы с файлами и файловой системой
Регулярные выражения
Основы скрапинга и парсинга
Основы ООП: инкапсуляция и наследование
Основы ООП – абстракция и полиморфизм
Графический интерфейс на Tkinter
Основы разработки игр на Pygame
Основы работы с SQLite
Основы веб-разработки на Flask
Основы работы с NumPy
Основы анализа данных с Pandas

Читать:
Куда доставляет яндекс маркет