Выберите методы которые есть у кортежей

Кортежи

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

>>> a = (10, 2.13, "square", 89, 'C') >>> a (10, 2.13, 'square', 89, 'C')

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

>>> a[3] 89 >>> a[1:3] (2.13, 'square')

Однако изменять его элементы нельзя:

>>> a[0] = 11 Traceback (most recent call last): File "", line 1, in TypeError: 'tuple' object does not support item assignment

Также у типа tuple нет методов для добавления и удаления элементов.

Возникает резонный вопрос. Зачем в язык программирования был введен этот тип данных, по-сути представляющий собой неизменяемый список? Дело в том, что иногда надо защитить список от изменений. Преобразовать же кортеж в список, если это потребуется, как и выполнить обратную операцию легко с помощью встроенных в Python функций list() и tuple() :

>>> a = (10, 2.13, "square", 89, 'C') >>> b = [1, 2, 3] >>> c = list(a) >>> d = tuple(b) >>> c [10, 2.13, 'square', 89, 'C'] >>> d (1, 2, 3)

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

def add_num(seq, num): for i in range(len(seq)): seq[i] += num return seq origin = [3, 6, 2, 6] changed = add_num(origin, 3) print(origin) print(changed)

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

[6, 9, 5, 9] [6, 9, 5, 9]

То есть исходный список был также изменен. Параметр seq содержал ссылку не на свой локальный список, а на список-оригинал. Таким образом, в операторе return здесь нет смыла. Если функция замысливалась как изменяющая глобальный список, то программа должна выглядеть так:

def add_num(seq, num): for i in range(len(seq)): seq[i] += num origin = [3, 6, 2, 6] add_num(origin, 3) print(origin)

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

def add_num(seq, num): new_seq = [] for i in seq: new_seq.append(i + num) return new_seq origin = [3, 6, 2, 6] changed = add_num(origin, 3) print(origin) print(changed)

[3, 6, 2, 6] [6, 9, 5, 9]

Исходный список в функции не меняется. Его элементы лишь перебираются.

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

Хотя преобразовывать к кортежу можно как при передаче в функцию, так и в самой функции, лучше сразу делать глобальный список кортежем. Поскольку неизменяемые объекты передаются по значению, а не по ссылке, то в функцию будет поступать копия структуры, а не оригинал. Даже если туда передается оригинал, изменить его невозможно. Можно лишь, как вариант, скопировать его и/или изменить тип, создав тем самым локальную структуру, и делать с ней все, что заблагорассудится.

def add_num(seq, num): seq = list(seq) for i in range(len(seq)): seq[i] += num return seq origin = (3, 6, 2, 6) changed = add_num(origin, 3) print(origin) print(changed)

Списки в кортежах

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

>>> nested = (1, "do", ["param", 10, 20])

Как вы думаете, можем ли мы изменить список [«param», 10, 20] вложенный в кортеж nested ? Список изменяем, кортеж – нет. Если вам кажется, что нельзя, то вам кажется неправильно. На самом деле можно:

>>> nested[2][1] = 15 >>> nested (1, 'do', ['param', 15, 20])

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

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

Чтобы было проще понять, перепишем кортеж так:

>>> l = ["param", 10, 20] >>> t = (1, "do", l) >>> t (1, 'do', ['param', 10, 20])

Кортеж содержит переменную-ссылку. Поменять ее на другую ссылку нельзя. Но кортеж не содержит самого списка. Поэтому его можно менять как угодно:

>>> l.pop(0) 'param' >>> t (1, 'do', [10, 20])

Однако такой номер не проходит с неизменяемыми типами:

>>> a = "Kat" >>> t = (a, l) >>> t ('Kat', [10, 20]) >>> a = "Bat" >>> t ('Kat', [10, 20])

Они передаются в кортеж как и в функцию – по значению. То есть их значение копируется в момент передачи.

Практическая работа

1. Чтобы избежать изменения исходного списка, не обязательно использовать кортеж. Можно создать его копию с помощью метода списка copy() или взять срез от начала до конца [:] . Скопируйте список первым и вторым способом и убедитесь, что изменение копий никак не отражается на оригинале.
2. Заполните один кортеж десятью случайными целыми числами от 0 до 5 включительно. Также заполните второй кортеж числами от -5 до 0. Для заполнения кортежей числами напишите одну функцию. Объедините два кортежа с помощью оператора +, создав тем самым третий кортеж. С помощью метода кортежа count() определите в нем количество нулей. Выведите на экран третий кортеж и количество нулей в нем.

Примеры решения и дополнительные уроки в pdf-версии курса

X Скрыть Наверх

Python. Введение в программирование

7. Кортежи

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

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

Где используется?

Кортежи — распространенная структура данных для хранения последовательностей в Python.

• .index() — используется для вывода индекса элемента.
• .count() — используется для подсчета количества элементов в кортеже.
• sum() — складывает все элементы кортежа.
• min() — показывает элемент кортежа с наименьшим значением.
• max() — показывает элемент кортежа с максимальным значением.
• len() — показывает количество элементов кортежа.

Рекомендации по работе с кортежами

1. Кортежи создаются с помощью круглых скобок: () ;
2. Элементы внутри кортежей разделяются запятыми;
3. Важно соблюдать особенности синтаксиса, характерные для каждого отдельного типа данных в кортеже — кавычки для строк, числа и булевые значения без кавычек и так далее.

Дальше — кортеж, включающий элементы разных типов:

 
>>> p_tup = ("Лондон", "Пекин", 44, True) 
>>> print(p_tup) 
('Лондон', 'Пекин', 44, True) 

Доступ к элементам: получить элементы кортежа можно с помощью соответствующего индекса в квадратных скобках.
Например, для получения элемента «Лондон» нужно использовать следующий индекс: p_tup[0]
А для 44: p_tup[2]
Последний элемент следующего кортежа — булево True . Доступ к нему мы получаем с помощью функции print .
 
>>> p_tup = ("Лондон", "Пекин", 44, True) 
>>> print(p_tup[3]) 
True 

Пример получения первого элемента кортежа.
 
>>> p_tup = ("Лондон", "Пекин", 44, True) 
>>> print(p_tup[0]) 
'Лондон' 


Обратное индексирование: по аналогии с элементами списка элементы кортежа также можно получить с помощью обратного индексирования. Оно начинается с -1. Это значение указывает на последний элемент.
Так, для получения последнего элемент p_tup нужно писать p_tup[-1] . p_tup[-2] вернет второй элемент с конца и так далее.
Главное отличие кортежей от списков — они неизменяемые. Кортежам нельзя добавлять или удалять элементы.
Поэтому эта структура используется, когда известно, что элементы не будут меняться в процессе работы программы.

 
>>> p_tup = ("Лондон", "Пекин", 44, True) 
>>> print(p_tup[-1]) 
True 

Функция .index()
.index() — полезный метод, используемый для получения индекса конкретного элемента в кортеже.
Посмотрим на примере.
 
>>> p_tup = ("Лондон", "Пекин", 44, True) 
>>> print(p_tup.index("Лондон")) 
0 

Функция .count()
Метод .count() подходит для определения количества вхождений определенного элемента в кортеже.
В примере ниже можно увидеть, что считается количество вхождений числа 101 в списке p_cup . Результат — 2.
 
>>> p_tup = (5, 101, 42, 3, 101) 
>>> print(p_tup.count(101)) 
2 

Функция sum()
Функция sum() возвращает общую сумму чисел внутри кортежа.
 
>>> lucky_numbers = (5, 55, 4, 3, 101, 42) 
>>> print(sum(lucky_numbers)) 
210 

Функция min()
Функция min() вернет элемент с самым маленьким значением в кортеже.
 
>>> lucky_numbers = (5, 55, 4, 3, 101, 42) 
>>> print(min(lucky_numbers)) 
5 

Функция max()
Функция max() вернет элемент с максимальным значением в кортеже.
 
>>> lucky_numbers = (5, 55, 4, 3, 101, 42) 
>>> print(max(lucky_numbers)) 
101 

Задачи к уроку
Попробуйте решить задачи к этому уроку для закрепления знаний.
1. Создайте кортеж с цифрами от 0 до 9 и посчитайте сумму.
# данный код numbers = print(sum(numbers)) # требуемый вывод: # 45
2. Введите статистику частотности букв в кортеже.
# данный код long_word = ( 'т', 'т', 'а', 'и', 'и', 'а', 'и', 'и', 'и', 'т', 'т', 'а', 'и', 'и', 'и', 'и', 'и', 'т', 'и' ) print("Количество 'т':", ) print("Количество 'a':", ) print("Количество 'и':", ) # требуемый вывод: # Колличество 'т': 5 # Колличество 'а': 3 # Колличество 'и': 11

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

# данный код week_temp = (26, 29, 34, 32, 28, 26, 23) sum_temp = days = mean_temp = sum_temp / days print(int(mean_temp)) # требуемый вывод: # 28
Тест по кортежам
Пройдите тест к этому уроку для проверки знаний. В тесте 5 вопросов, количество попыток неограниченно.
Python. Урок 8. Кортежи (tuple)
 
Данный урок посвящен кортежам (tuple) в Python. Основное внимание уделено вопросу использования кортежей, почему иногда лучше применять их, а не списки, рассмотрены способы создания и основные приемы работы с кортежами. Также затронем тему преобразования кортежа в список и обратно.
Что такое кортеж (tuple) в Python?
Кортеж (tuple) – это неизменяемая структура данных, которая по своему подобию очень похожа на список. Как вы наверное знаете, а если нет, то, пожалуйста, ознакомьтесь с седьмым уроком, список – это изменяемый тип данных. Т.е. если у нас есть список a = [1, 2, 3] и мы хотим заменить второй элемент с 2 на 15, то мы может это сделать, напрямую обратившись к элементу списка.
>>> a = [1, 2, 3] >>> print(a) [1, 2, 3] >>> a[1] = 15 >>> print(a) [1, 15, 3]
С кортежем мы не можем производить такие операции, т.к. элементы его изменять нельзя.
>>> b = (1, 2, 3) >>> print(b) (1, 2, 3) >>> b[1] = 15 Traceback (most recent call last): File "", line 1, in module> b[1] = 15 TypeError: 'tuple' object does not support item assignment
Зачем нужны кортежи в Python?
Существует несколько причин, по которым стоит использовать кортежи вместо списков. Одна из них – это обезопасить данные от случайного изменения. Если мы получили откуда-то массив данных, и у нас есть желание поработать с ним, но при этом непосредственно менять данные мы не собираемся, тогда, это как раз тот случай, когда кортежи придутся как нельзя кстати. Используя их в данной задаче, мы дополнительно получаем сразу несколько бонусов – во-первых, это экономия места. Дело в том, что кортежи в памяти занимают меньший объем по сравнению со списками.
>>> lst = [10, 20, 30] >>> tpl = (10, 20, 30) >>> print(lst.__sizeof__()) 32 >>> print(tpl.__sizeof__()) 24 
Во-вторых – прирост производительности, который связан с тем, что кортежи работают быстрее, чем списки (т.е. на операции перебора элементов и т.п. будет тратиться меньше времени). Важно также отметить, что кортежи можно использовать в качестве ключа у словаря.
Создание, удаление кортежей и работа с его элементами
Создание кортежей
Для создания пустого кортежа можно воспользоваться одной из следующих команд.
>>> a = () >>> print(type(a)) 'tuple'> >>> b = tuple() >>> print(type(b)) 'tuple'>
Кортеж с заданным содержанием создается также как список, только вместо квадратных скобок используются круглые.
>>> a = (1, 2, 3, 4, 5) >>> print(type(a)) class 'tuple'> >>> print(a) (1, 2, 3, 4, 5)
При желании можно воспользоваться функцией tuple().
>>> a = tuple((1, 2, 3, 4)) >>> print(a) (1, 2, 3, 4)
Доступ к элементам кортежа
Доступ к элементам кортежа осуществляется также как к элементам списка – через указание индекса. Но, как уже было сказано – изменять элементы кортежа нельзя!
>>> a = (1, 2, 3, 4, 5) >>> print(a[0]) 1 >>> print(a[1:3]) (2, 3) >>> a[1] = 3 Traceback (most recent call last): File "", line 1, in module> a[1] = 3 TypeError: 'tuple' object does not support item assignment
Удаление кортежей
Удалить отдельные элементы из кортежа невозможно.
>>> a = (1, 2, 3, 4, 5) >>> del a[0] Traceback (most recent call last): File "", line 1, in module> del a[0] TypeError: 'tuple' object doesn't support item deletion 
Но можно удалить кортеж целиком.
>>> del a >>> print(a) Traceback (most recent call last): File "", line 1, in module> print(a) NameError: name 'a' is not defined
Преобразование кортежа в список и обратно
На базе кортежа можно создать список, верно и обратное утверждение. Для превращения списка в кортеж достаточно передать его в качестве аргумента функции tuple().
>>> lst = [1, 2, 3, 4, 5] >>> print(type(lst)) 'list'> >>> print(lst) [1, 2, 3, 4, 5] >>> tpl = tuple(lst) >>> print(type(tpl)) 'tuple'> >>> print(tpl) (1, 2, 3, 4, 5)
Обратная операция также является корректной.
>>> tpl = (2, 4, 6, 8, 10) >>> print(type(tpl)) 'tuple'> >>> print(tpl) (2, 4, 6, 8, 10) >>> lst = list(tpl) >>> print(type(lst)) 'list'> >>> print(lst) [2, 4, 6, 8, 10]
P.S.
Если вам интересна тема анализа данных, то мы рекомендуем ознакомиться с библиотекой Pandas. На нашем сайте вы можете найти вводные уроки по этой теме. Все уроки по библиотеке Pandas собраны в книге “Pandas. Работа с данными”.  
Раздел: Python Уроки по Python Метки: Python, Уроки Python
Python. Урок 8. Кортежи (tuple) : 5 комментариев

Владимир 15.01.2019 Сорян за глупый вопрос, но я только начинаю изучать Python. 
И так, есть два или более кортежей и нужно найти элементы, общие для этих кортежей, т е. взять пересечение множеств. Существует ли в питоне для этого оператор (функция, метод, …) или нужно самому “городить” такую функцию? Или может есть какая-нибудь подключаемая библиотека с такой функцией?


writer 09.02.2019 Добрый день! 
Если вы хотите выполнять операции пересечения и т.п. лучше для этих целей использовать тип данных не кортеж (tuple), а множество (set)


Андрей 24.10.2020 f(*opt)

Кортежи (tuple) и их методы
На этом занятии мы с вами познакомимся с еще одной новой коллекцией данных – кортежами. Что такое кортеж? Это упорядоченная, но неизменяемая коллекция произвольных данных. Они, в целом, аналогичны спискам, но в отличие от них, элементы кортежей менять нельзя – это неизменяемый тип данных.
 
Для задания кортежа достаточно перечислить значения через запятую:
a = 1,2
или, что то же самое, в круглых скобках:
a = (1, 2, 3)
Но, обратите внимание, при определении кортежа с одним значение, следует использовать такой синтаксис:
Здесь висячая запятая указывает, что единицу следует воспринимать как первый элемент кортежа, а не как число 1. Без запятой – это будет уже просто число один. Вот это нужно очень хорошо запомнить, начинающие программисты здесь часто делают ошибку, не прописывая висячую запятую.
Далее, мы можем переменным сразу присвоить соответствующие значения из кортежа, перечисляя их через запятую:
x, y = (1, 2)
но, если число переменных не будет совпадать с числом элементов кортежа:
x, y = (1, 2, 3)
то возникнет ошибка.
Длину кортежа (число его элементов) можно определить с помощью известной уже вам функции:
len(a)

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

О срезах мы с вами уже подробно говорили, когда рассматривали списки, здесь все абсолютно также, кроме одной операции – взятия полного среза:
b = a[:]
В случае с кортежем здесь не создается его копии – это будет ссылка на тот же самый объект:
print(id(a), id(b))
Напомню, что для списков эта операция приводит к их копированию. Этот момент нужно также очень хорошо запомнить: для кортежей – возвращается тот же самый объект, а для списков – создается копия.
Некоторые из вас сейчас могут задаваться вопросом: зачем было придумывать кортежи, если списки способны выполнять тот же самый функционал? И даже больше – у них можно менять значения элементов, в отличие от кортежей? Да, все верно, по функциональности списки шире кортежей, но у последних все же есть свои преимущества.
Во-первых, то, что кортеж относится к неизменяемому типу данных, то мы можем использовать его, когда необходимо «запретить» программисту менять значения элементов списка. Например, вот такая операция:
a[1] = 100
приведет к ошибке. Менять значения кортежей нельзя. Во-вторых, кортежи можно использовать в качестве ключей у словарей, например, так:
d = {} d[a] = "кортеж"
Напомню, что списки как ключи применять недопустимо, так как список – это изменяемый тип, а ключами могут быть только неизменяемые типы и кортежи здесь имеют преимущество перед списками.
В-третьих, кортеж занимает меньше памяти, чем такой же список, например:
lst=[1,2,3] t = (1,2,3) print(lst.__sizeof__()) print(t.__sizeof__())
Как видите, размер кортежа меньше, чем списка. Здесь использован метод __sizeof__, который возвращает размер данных в байтах.
Из всего этого можно сделать такой общий вывод: если мы работаем с неизменяемым упорядоченным списком, то предпочтительнее использовать кортеж.
Теперь, когда мы поняли, что кортежи играют свою значимую роль в программах на Python, вернемся к их рассмотрению. Чтобы создать пустой кортеж можно просто записать круглые скобки:
или воспользоваться специальной встроенной функцией:
b = tuple() print(type(a), type(b))
Но здесь сразу может возникнуть вопрос: зачем создавать пустой кортеж, если он относится к неизменяемым типам данных? Слово неизменяемый наводит на мысль, что вид кортежа остается неизменным. Но это не совсем так. В действительности, мы лишь не можем менять уже существующие элементы в кортеже, но можем создавать новые, используя оператор +, например:
a = () a = a + (1,)
или для добавления данных в начало кортежа:
a = (2, 3) + a
Также можно добавить вложенный кортеж:
a += (("a", "hello"),)
или дублировать элементы кортежа через оператор *, подобно спискам:
b = (0,)*10 b = ("hello", "world") * 5
Как видите, все эти операции вполне допустимы. А вот удалять отдельные его элементы уже нельзя. Если мы попытаемся это сделать:
del a[1]
то возникнет ошибка. Правда, можно удалить объект целиком:
del a
тогда кортеж просто перестанет существовать, не будет даже пустого кортежа, здесь объект удаляется целиком.
Далее, с помощью функции tuple() можно создавать кортежи на основе любого итерируемого объекта, например, списков и строк:
a = tuple([1,2,3]) a = tuple("Привет мир")
А если нам нужно превратить кортеж в список, то подойдет известная нам функция list(), которая формирует список также из любого итерируемого объекта:
t = (1,2,3) lst = list(t)
Так как кортеж – это перебираемый, то есть, итерируемый объект, то никто не мешает нам превращать его в список.
Как я отмечал в самом начале, кортежи могут хранить самые разные данные:
a = (True, [1,2,3], "hello", 5, {"house": "дом"})
 
Причем, смотрите, если обратиться, например, к списку:
то это изменяемый объект, следовательно, его значение даже в кортеже мы можем спокойно менять:
a[1].append("5")
То есть, неизменность кортежа относится к его структуре элементов и значениям ссылок на объекты. Но, если сами объекты, при этом, могут меняться, то мы можем легко это делать. То есть, обращаясь ко второму элементу кортежа, мы, фактически, имеем список, с которым возможны все его операции без каких-либо ограничений. Я, думаю, это должно быть понятно?

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

a = ("abc", 2, [1,2], True, 2, 5)
И мы хотим определить число элементов со значениями:
a.count("abc") a.count(2)
Как видите, метод count() возвращает число таких элементов в кортеже. Если же элемент не будет найден:
a.count("a")
то возвращается 0. Следующий метод:
a.index(2)
возвращает индекс первого найденного элемента с указанным значением. Если значение не найдено:
a.index(3)
то этот метод приводит к ошибке. Поэтому, прежде чем его использовать, лучше проверить, а есть ли такое значение вообще в кортеже:
3 in a
Второй необязательный параметр
a.index(2, 3)
позволяет задавать индекс начала поиска. В данном случае поиск будет начинаться с третьего индекса. А последний третий аргумент:
a.index(2, 3, 5)
определяет индекс, до которого идет поиск (не включая его). Если же записать вот так:
a.index(2, 3, 4)
Читать:
Как снять печку на уаз фермер