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

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

Индексирование с отрицательными числами начнется с последнего элемента как -1:

x[-1] # 3 x[-2] # 2 x[-3] # 1 x[-4] # IndexError: tuple index out of range 

Индексирование ряда элементов

print(x[:-1]) # (1, 2) print(x[-1:]) # (3,) print(x[1:3]) # (2, 3) 

Кортежи неизменны

Одним из основных отличий между list s и tuple с в Python является то , что кортежи являются неизменяемыми, то есть, один не может добавлять или изменять элементы , как только кортеж инициализируются. Например:

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

Точно так же, кортежи не имеют .append и .extend методы , как list делает. Используя += возможно, но он изменяет связывание переменной, а не сам кортеж:

>>> t = (1, 2) >>> q = t >>> t += (3, 4) >>> t (1, 2, 3, 4) #output >>> q (1, 2) #output 

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

>>> t = (1, 2, 3, [1, 2, 3]) (1, 2, 3, [1, 2, 3]) #output >>> t[3] += [4, 5] 

Будет как поднимать ошибку и изменить содержимое списка в кортеже:

TypeError: 'tuple' object does not support item assignment >>> t (1, 2, 3, [1, 2, 3, 4, 5]) #output 

Вы можете использовать += оператору «добавить» в кортеж — это работает, создавая новый кортеж с новым элементом вы «добавленным» и назначить его в текущей переменной; старый кортеж не изменен, но заменен!

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

Кортеж является элементарным измеримым и уравновешенным

hash( (1, 2) ) # ok hash(([], ) # не ок, поскольку списки и множества не хешируемы 

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

 < (1, 2) ># ок <([], <"hello">) ) # не ок

Кортеж

Синтаксически, кортеж — это список значений через запятую:

t = 'a', 'b', 'c', 'd', 'e' 

Хотя это и необязательно, обычно заключать кортежи в скобки:

t =('a', 'b', 'c', 'd', 'e') 

Создайте пустой кортеж с круглыми скобками:

t0 = () type(t0) #

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

t1 = 'a', type(t1) #

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

t2 =('a') type(t2) #

Для создания одноэлементного кортежа необходимо использовать завершающую запятую.

t2 =('a',) type(t2) #

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

t2 =('a',) # нотация одобрена PEP8 t2 = 'a', # использовать эту нотацию PEP8 не рекомендует t2 =('a', ) # использовать эта нотацию PEP8 не рекомендует 

Другой способ создать кортеж является встроенной функцией tuple .

t = tuple('lupins') print(t) #('l', 'u', 'p', 'i', 'n', 's') t = tuple(range(3)) print(t) # (0, 1, 2) 

Эти примеры основаны на материалах из книги Think Python Аллен B. Дауни.

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

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

a = 1, 2, 3 # a является кортежем (1, 2, 3) 

a = (1, 2, 3) # a является кортежем (1, 2, 3) 

эквивалентны. Присваивания a = 1, 2, 3 также называют упаковки , потому что пакеты значения вместе в кортеже.

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

a = 1 # a имеет значение 1 a = 1, # a это кортеж (1,) 

Запятая нужна также, если вы используете скобки

a = (1,) # a это кортеж (1,) a = (1) # a имеет значение 1 и не является кортежем 

Для распаковки значений из кортежа и выполнения нескольких назначений используйте

# unpacking AKA multiple assignment x, y, z = (1, 2, 3) # x == 1 # y == 2 # z == 3 

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

 a = 1, 2, 3, 4 _, x, y, _ = a # x == 2 # y == 3 

x, = 1, # x это означение 1 x = 1, # x это кортеж (1,) 

В Python 3 целевой переменной с * префикс может быть использован в качестве вдогонку всех переменных:

first, *more, last = (1, 2, 3, 4, 5)
#first == 1
#more == [2, 3, 4]
#last == 5

Реверсивные элементы

Обратные элементы в кортеже

colors = "red", "green", "blue" rev = colors[::-1] # rev: ("blue", "green", "red") colors = rev # colors: ("blue", "green", "red") 

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

rev = tuple(reversed(colors)) # rev: ("blue", "green", "red") colors = rev # colors: ("blue", "green", "red") 

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

Кортежи поддерживают следующие встроенные функции

сравнение

Если элементы одного типа, python выполняет сравнение и возвращает результат. Если элементы разных типов, он проверяет, являются ли они числами.

• Если числа, проведите сравнение.
• Если один из элементов является числом, то возвращается другой элемент.
• В противном случае типы сортируются по алфавиту.

Если мы достигли конца одного из списков, более длинный список будет «больше». Если оба списка одинаковы, возвращается 0.

tuple1 =('a', 'b', 'c', 'd', 'e') tuple2 =('1','2','3') tuple3 =('a', 'b', 'c', 'd', 'e') cmp(tuple1, tuple2) # 1 cmp(tuple2, tuple1) # -1 cmp(tuple1, tuple3) # 0 

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

Функция len возвращает общую длину кортежа

len(tuple1) # 5 

Max кортежа

Функция max возвращает элемент из кортежа с максимальным значением

max(tuple1) #'e' max(tuple2) # '3' 

Min кортежа

Функция min возвращает элемент из кортежа со значением min

min(tuple1) # 'a' min(tuple2) # '1' 

Преобразовать список в кортеж

Встроенная функция tuple преобразует список в кортеж.

list = [1,2,3,4,5] tuple(list) >>>Out: (1, 2, 3, 4, 5) 

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

Используйте + для конкатенации двух кортежей

tuple1 + tuple2 >>>Out:('a', 'b', 'c', 'd', 'e', '1', '2', '3') 

Кортежи (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)

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

Получаю вот такой вот кортеж из бд: [(1, ‘Петрова Анастасия Ивановна’, ‘+78005553535’, ‘123456237562\n’)] Вопрос, как я могу определить номер элемента в кортеже под которым прячется номер? Пробовал через цикл for, но ничего не вышло

for i in numbers: if "+" in numbers[0][i]: tmp = numbers[0][i] 

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

Отслеживать
задан 29 июн 2022 в 15:32
Антон Александрович Антон Александрович
99 5 5 бронзовых знаков
А напечатать, что у вас в i получается и посмотреть? ) Там кортеж как-раз.
29 июн 2022 в 15:34
Да, я получил кортеж но как из него вырезать элемент ‘+78005553535’, и узнать его номер?
29 июн 2022 в 15:36

1 ответ 1

Сортировка: Сброс на вариант по умолчанию

Можно так всё перебрать — сначала кортежи в списке, а потом элементы кортежа:

numbers = [(1, 'Петрова Анастасия Ивановна', '+78005553535', '123456237562\n')] for record in numbers: for item in record: if '+' in str(item): print(item) 

+78005553535 

Если нужны «координаты» элемента — можете использовать enumerate :

for n_rec, record in enumerate(numbers): for n_item, item in enumerate(record): if '+' in str(item): print(n_rec, n_item, item) 

0 2 +78005553535 

Т.е. это кортеж с индексом 0 в списке и в самом кортеже это элемент с индексом 2 .

Кортежи в Python

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

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

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

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

# Разные типы кортежей # Пустой кортеж my_tuple = () print(my_tuple) # Кортеж с целыми числами my_tuple = (1, 2, 3) print(my_tuple) # Кортеж с разными типами данных my_tuple = (1, "Привет", 3.4) print(my_tuple) # Вложенный кортеж my_tuple = ("мышь", [8, 4, 6], (1, 2, 3)) print(my_tuple)

Вывод:

()
(1, 2, 3)
(1, 'Привет', 3.4)
('мышь', [8, 4, 6], (1, 2, 3))

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

# упаковываем кортеж my_tuple = 3, 4.6, "собака" print(my_tuple) # точно так же можно распаковать кортеж a, b, c = my_tuple print(a) # 3 print(b) # 4.6 print(c) # собака

Вывод:

(3, 4.6, 'собака')
3
4.6
собака

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

my_tuple = ("привет") print(type(my_tuple)) # # Создаем кортеж с одним элементом my_tuple = ("привет",) print(type(my_tuple)) # # Можно и без скобок my_tuple = "привет", print(type(my_tuple)) #

Вывод:

Как получить элемент кортежа

1. По индексу

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

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

Кортеж из 9 элементов будет иметь индексы от 0 до 8. Попытка получить доступ к индексу за пределами диапазона индексов кортежа (в нашем случае 9, 10 и т. д.) приведет к ошибке IndexeError.

Индекс должен быть целым числом, поэтому мы не можем использовать float или другие типы в качестве индекса. Это приведет к ошибке TypeError.

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

my_tuple = ('c', 'o', 'd', 'e', 'c', 'h', 'i', 'c', 'k') print(my_tuple[0]) # 'c' print(my_tuple[5]) # 'h' # Вызов print(my_tuple[9]) приведет к ошибке # IndexError: list index out of range # Вызов my_tuple[2.0] приведет к ошибке # TypeError: list indices must be integers, not float # Индекс должен быть целым числом # вложенный кортеж n_tuple = ("мышь", [8, 4, 6], (1, 2, 3)) # вложенное индексирование print(n_tuple[0][3]) # 'ь' print(n_tuple[1][1]) # 4

Вывод:

c
h
ь
4

2. По отрицательному индексу

Python допускает отрицательную индексацию коллекций (наборов значений). Она работает и с кортежами.

Индекс -1 отсылает к последнему элементу, -2 — ко второму элементу с конца и так далее.

my_tuple = ('c', 'o', 'd', 'e', 'c', 'h', 'i', 'c', 'k') # Вывод: 'k' print(my_tuple[-1]) # Вывод: 'c' print(my_tuple[-9])

Вывод:

3. С помощью срезов

Получить доступ к диапазону элементов в кортеже можно с помощью оператора срезов : .

Использование срезов еще называют слайсингом, от английского slicing — «нарезка».

my_tuple = ('c', 'o', 'd', 'e', 'c', 'h', 'i', 'c', 'k') # элементы со 2 по 4 # Вывод: ('o', 'd', 'e') print(my_tuple[1:4]) # элементы от начала и до второго элемента # Вывод: ('c', 'o') print(my_tuple[:-7]) # два последних элемента # Вывод: ('c', 'k') print(my_tuple[7:]) # все элементы от начала до конца # Вывод: ('c', 'o', 'd', 'e', 'c', 'h', 'i', 'c', 'k') print(my_tuple[:])

Вывод:

('o', 'd', 'e')
('c', 'o')
('c', 'k')
('c', 'o', 'd', 'e', 'c', 'h', 'i', 'c', 'k')

Как изменить кортеж

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

Переназначить кортеж тоже можно.

my_tuple = (4, 2, 3, [6, 5]) # my_tuple[1] = 9 # Эта строка приведет к ошибке # TypeError: 'tuple' object does not support item assignment # Значения изменяемого элемента менять можно my_tuple[3][0] = 9 # Вывод: (4, 2, 3, [9, 5]) print(my_tuple) # Можно переназначить кортеж my_tuple = ('c', 'o', 'd', 'e', 'c', 'h', 'i', 'c', 'k') # Вывод: ('c', 'o', 'd', 'e', 'c', 'h', 'i', 'c', 'k') print(my_tuple)

Вывод:

(4, 2, 3, [9, 5])
('c', 'o', 'd', 'e', 'c', 'h', 'i', 'c', 'k')

В Python кортежи можно объединить с помощью оператора + . Это называется конкатенацией.

С помощью оператора * можно повторить элементы в кортеже заданное количество раз.

Оба оператора + и * приводят к созданию нового кортежа.

# Конкатенация #Вывод: (1, 2, 3, 4, 5, 6) print((1, 2, 3) + (4, 5, 6)) # Повторение # Вывод: ('Повторить', 'Повторить', 'Повторить') print(("Повторить",) * 3)

Вывод:

(1, 2, 3, 4, 5, 6)
('Повторить', 'Повторить', 'Повторить')

Как удалить кортеж

Изменять элементы кортежа нельзя. Это значит, что удалять их тоже нельзя.

В Python можно только полностью удалить кортеж — с помощью ключевого слова del .

my_tuple = ('c', 'o', 'd', 'e', 'c', 'h', 'i', 'c', 'k') # нельзя удалить элементы кортежа # TypeError: 'tuple' object doesn't support item deletion # del my_tuple[3] # зато можно удалить кортеж полностью del my_tuple # вызов приведет к ошибке NameError: name 'my_tuple' is not defined print(my_tuple)

Вывод:

Traceback (most recent call last): 
File "", line 12, in 
NameError: name 'my_tuple' is not defined

Методы кортежа

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

Для кортежа существует только два метода: .count() и .index() .

my_tuple = ('я', 'б', 'л', 'о', 'к', 'о',) print(my_tuple.count('о')) # Вывод: 2 print(my_tuple.index('к')) # Вывод: 4

Вывод:

Другие операции с кортежами

1. Проверка на вхождение в кортеж

Мы можем проверить, существует ли тот или иной элемент в кортеже или нет, с помощью ключевого слова in и not in .

my_tuple = ('я', 'б', 'л', 'о', 'к', 'о',) print('я' in my_tuple) print('х' in my_tuple) print('п' not in my_tuple)

Вывод:

True
False
True

2. Итерирование по кортежу

Для перебора элементов кортежа можно использовать цикл for .

for name in ('Андрей', 'Маша'): print("Привет, ", name)

Вывод:

Привет, Андрей
Привет, Маша

Преимущества кортежа над списком

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

СodeСhick.io — простой и эффективный способ изучения программирования.

2023 © ООО «Алгоритмы и практика»