Кортежи (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') Распаковка кортежей в Python
Признайтесь честно, вас может прельстить использование индексов при работе с кортежами, списками и другими последовательностями, в случае, когда вам нужен доступ в них к вполне конкретному элементу, а вы и понятия не имеете под каким индексом этот элемент у вас находится? Ведь, куда лучше, чтоб этот необходимый вам элемент имел бы какое-то информативно-описательное имя, через которое вы запросто смогли бы обратиться к нему. Как раз с этой целью в программировании на Python и предусмотрен трюк, называемый «распаковкой кортежей» и, известный также как «множественное присваивание» или «итерируемая распаковка».
Вместе с тем этот трюк, который на самом деле имеет довольно большой потенциал в плане упрощения понимания логики и читабельности кода, достаточно редко используется особенно начинающими программистами. Именно поэтому, далее в этой статье мы с вами на практики постараемся рассмотреть принципы использования распаковки кортежей и выяснить основные ее преимущества.
Альтернатива неинформативным и жестко закодированным индексам
Допустим, мы имеем кортеж first_tuple , состоящий из 3-х элементов:
>>> first_tuple = (2, 1, 3) Тогда, для того чтобы получить доступ к каждому элементу данного кортежа, первое, что напрашивается на ум – обратиться к этим элементам через их индекс:
>>> print(first_tuple[0], first_tuple[1], first_tuple[2]) 2 1 3 В то же время, наш любимый Python за счет предельно простого синтаксиса запросто позволяет присваивать каждому элементу нашего кортежа необходимые информативно-описательные имена следующим образом:
>>> x, y, z = first_tuple Операция присваивания из вышеприведенного примера, как раз и называется распаковкой кортежа. Такое название прямо отражает сущность данной операции, в которой кортеж, состоящий из трех элементов просто, был распакован в три переменные ( x , y , и z ):
>>> print(x, y, z) 2 1 3 Зачастую, использование кортежей в Python коде обусловлено лишь необходимостью объединения каких-либо значений вместе. С этой точки зрения, распаковку кортежей можно воспринимать просто, как отмену предыдущего объединения вышеназванных значений. В принципе, с нашим кортежем first_tuple мы поступили абсолютно аналогичным образом, когда сначала объединили в нем три значения, а затем обратно распаковали эти значения в отдельные поименованные переменные.
Важно отметить, что если мы попытаемся распаковать наш кортеж из трех элементов не в три, а в меньшее или большее число переменных, то получим ошибку:
>>> x, y = first_tuple Traceback (most recent call last): File "", line 1, in ValueError: too many values to unpack (expected 2) При распаковке какого-либо картежа всегда необходимо, чтобы его структура и перемененных, в которые он распаковывается, совпадали. Проще говоря, количество переменных, в которые распаковывается ваш картеж должно соответствовать количеству элементов самого этого картежа.
Распаковка кортежей для доступа к каждому их элементу, прежде всего, позволяет предотвратить использование жестко закодированных индексов, а также обеспечивает доступ к элементам кортежей по понятным информативно-описательным именам.
Распаковка кортежей без применения знака равенства
На практике распаковка кортежей чаще всего используется не в операторах присваивания с применением знака равенства, а в for циклах.
Но, прежде чем рассматривать распаковку кортежей в циклах, давайте подготовим себе исходные данные для этой цели. В частности, давайте вызовем метод items() для словаря furniture с тем, чтобы получить итерацию кортежей из двух элементов:
>>> furniture = "tables": 2, "chairs": 3, "stands": 0> >>> furniture.items() dict_items([('tables', 2), ('chairs', 3), ('stands', 0)]) Каждый полученный нами таким образом двухэлементный кортеж на самом деле представляет собой пару ключ-значение для каждого элемента в нашем словаре. Давайте попробуем отобразить кортежи для каждого элемента этого словаря с помощью цикла for:
>>> for item in furniture.items(): . print(item) . ('tables', 2) ('chairs', 3) ('stands', 0) Из предыдущего раздела данной статьи мы уже знаем, что можем распаковать каждый элемент кортежа в соответствующую поименованную переменную. Давайте попробуем это сделать и с кортежами для элементов нашего словаря. Каждый из таких картежей, содержащий пару ключ-значение для соответствующего элемента словаря мы распакуем в переменную furniture и переменную amount соответственно:
>>> for item in furniture.items(): . furniture, amount = item . print(furniture, amount) . tables 2 chairs 3 stands 0 Фактически же распаковка наших кортежей в отдельной строке внутри тела цикла с использованием оператора присваивания ( = ) было излишеством. Ведь на самом деле при каждой итерации цикла for в самой строке с определением этого цикла происходит так называемое неявное присваивание, когда в переменную, находящуюся между for и in, присваивается результат выражения, находящегося справа от in.
Таким образом, вышеприведенный пример мы можем переписать в несколько более компактной форме, производя распаковку наших кортежей прямо в строке с определением for цикла:
>>> for furniture, amount in furniture.items(): . print(furniture, amount) . tables 2 chairs 3 stands 0 Следовательно, в строке с определением for цикла нам вообще не была нужна промежуточная переменная item поскольку все, что можно поместить слева от знака равенства в операторе присваивания, с таким же успехом мы можем разместить между for и in в цикле for. Вообще же, первая (определяющая) строка цикла for явится в вашей практике тем наиболее распространенным местом, куда вам потребуется распаковывать, как разнообразные кортежи, так и другие итерируемые объекты.
Выводы
В данной статье были изложены особенности распаковки последовательностей данных на примере кортежей. Однако распаковка может применяться не только к кортежам, но и к любым итерируемым объектам в Python. Именно поэтому распаковку кортежей также называют множественным присваиванием или итерируемой распаковкой.
Чаще всего вы будете сталкиваться именно с распаковками итерируемых двухэлементных или же трехэлементных кортежей при их переборе в for циклах. Хотя, на самом деле Python позволяет распаковывать кортежи и любые другие итерируемые объекты в любом месте кода, где вам может потребоваться дать описательные имена к элементам внутри данных объектов.
Python Распаковка кортежей
Когда мы создаем кортеж, мы обычно присваиваем ему значения. Это называется «упаковкой» кортежа:
Пример
fruits = («яблоко», «банан», «вишня»)
Но в Python нам также разрешено извлекать значения обратно в переменные. Это называется «распаковка»:
Пример
fruits = («яблоко», «банан», «вишня»)
(зеленый, желтый, красный) = fruits
print(зеленый)
print(желтый)
print(красный)
Примечание: Количество переменных должно совпадать с количеством значений в кортеже, в противном случае необходимо использовать звездочку, чтобы собрать оставшиеся значения в виде списка.
Использование звездочки *
Если количество переменных меньше количества значений, вы можете добавить * к имени переменной, и значения будут присвоены переменной в виде списка:
Пример
Назначьте остальные значения в виде списка под названием «красный»:
fruits = («яблоко», «банан», «вишня», «клубника», «малина»)
(зеленый, желтый, *красный) = fruits
print(зеленый)
print(желтый)
print(красный)
Если звездочка добавлена к другому имени переменной, чем последнее, Python будет присваивать значения переменной до тех пор, пока количество оставшихся значений не совпадет с количеством оставшихся переменных.
Пример
Добавьте список значений переменной «тропический»:
fruits = («яблоко», «манго», «папайа», «ананас», «вишня»)
(зеленый, *тропический, красный) = fruits
print(зеленый)
print(тропический)
print(красный)
Мы только что запустили
SchoolsW3 видео
ВЫБОР ЦВЕТА
курс сегодня!
Сообщить об ошибке
Если вы хотите сообщить об ошибке или внести предложение, не стесняйтесь отправлять на электронное письмо:
Ваше предложение:
Спасибо Вам за то, что помогаете!
Ваше сообщение было отправлено в SchoolsW3.
ТОП Учебники
ТОП Справочники
ТОП Примеры
Получить сертификат
SchoolsW3 оптимизирован для бесплатного обучения, проверки и подготовки знаний. Примеры в редакторе упрощают и улучшают чтение и базовое понимание. Учебники, ссылки, примеры постоянно пересматриваются, чтобы избежать ошибок, но не возможно гарантировать полную правильность всего содержания. Некоторые страницы сайта могут быть не переведены на РУССКИЙ язык, можно отправить страницу как ошибку, так же можете самостоятельно заняться переводом. Используя данный сайт, вы соглашаетесь прочитать и принять Условия к использованию, Cookies и политика конфиденциальности.
распаковка кортежа
Получаю вот такой вот кортеж из бд: [(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 .