Как распаковать кортеж в python

Упаковка данных в Python — кортеж tuple

Вас зовут get_contacts и вы умеете находить контакты человека по email-адресу: его адрес, имя и номер телефона. Вы не прочь поделиться информацией с другими, но Python вам это запрещает. Нельзя возвращать так много данных разом, результат у функции может быть только один. Вы можете выбрать что-то одно, самое важное: адрес, имя, или телефон человека. Или можете проявить изобретательность и упаковать все свои данные в одну переменную.

Как упаковать данные в кортеж

Для функции get_contacts(email) доступны несколько способов упаковки данных в более сложную структуру: словарь dict() , кортеж tuple() и еще несколько других. Рассмотрим подробнее последний вариант — tuple , или по-русски кортеж.

Предположим, вы вызвали функцию get_contacts(‘dmitry@example.com’) , она нашла такого человека и хочет вернуть его контакты:

full_name = 'Никифоров Дмитрий Анатольевич' city = 'Москва' phone_number = '929-876-54-32'

Функция создает кортеж — tuple() —, чтобы поместить в него все контакты:

contacts = (full_name, city, phone_number)

Круглые скобки и запятые указывают Python, что из перечисленных переменных full_name , city и phone_number нужно создать новую структуру данных:

print(type(contacts)) # выведет print(contacts)

Последний вызов print() выведет на экран такое:

('Никифоров Дмитрий Анатольевич', 'Москва', '929-876-54-32')

Теперь функция get_contacts сможет вернуть любое количество данных. Все они будут упакованы в один кортеж — tuple .

Что делать, если получили tuple

Разберем как работать с tuple на примере стандартной функции divmod . Она возвращает результат деления с остатком:

divmod(100, 3) # выведет (33, 1) divmod(2, 3) # выведет (0, 2)

Функция divmod возвращает кортеж из двух чисел — результата целочисленного деления и остаток от деления.

Мы можем сохранить результат в переменную:

div_tuple = divmod(100, 3) print(div_tuple) # выведет (33, 1)

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

div_tuple = divmod(100, 3) print(div_tuple[0]) # выведет 33 print(div_tuple[1]) # выведет 1

Индексы в коде [0] и [1] сильно осложняют чтение, поэтому полезно давать говорящие названия:

div_tuple = divmod(100, 3) int_division = div_tuple[0] remainder = div_tuple[1] print(int_division) # выведет 33 print(remainder) # выведет 1

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

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

int_division = div_tuple[0] remainder = div_tuple[1]

Это встречается настолько часто, что в Python ввели упрощенную короткую запись:

(int_division, remainder) = divmod(100, 3) print(int_division) # выведет 33 print(remainder) # выведет 1

Запись похожа на создание кортежа — те же скобки и запятые, но работает это в обратную сторону. Называется “распаковкой”.

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

int_division, remainder = divmod(100, 3) print(int_division) # выведет 33 print(remainder) # выведет 1

Последняя форма записи распаковки наиболее распространена и рекомендуется к использованию.

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

contacts = full_name, city, phone_number

В коде внутри функций часто встречается еще более короткая запись:

return full_name, city, phone_number

Вызов return сообщает интерпретатору Python, что функция завершает свою работу и хочет вернуть результат. А все перечисленное справо от return будет упаковано в кортеж — tuple .

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

Добавить в кортеж ничего нельзя. Он неизменяемый, однажды созданный кортеж никак нельзя изменить. Зато можно создать новый:

old_tuple = (1, 2) new_tuple = old_tuple + (3, 4) print(new_tuple) # Выведется (1, 2, 3, 4)

Если вы хотите добавить только один элемент, то велик соблазн написать так:

old_tuple = (1, 2) new_tuple = old_tuple + 3

TypeError: can only concatenate tuple (not "int") to tuple

Эта ошибка значит, что вы попытались сложить кортеж и число, а Python умеет складывать только кортежи. Поэтому придётся сделать из вашего элемента кортеж, но с одним элементом внутри:

old_tuple = (1, 2) new_tuple = old_tuple + (3,) print(new_tuple) # Выведется (1, 2, 3)

Что ещё почитать

Попробуйте бесплатные уроки по Python

Получите крутое код-ревью от практикующих программистов с разбором ошибок и рекомендациями, на что обратить внимание — бесплатно.

Переходите на страницу учебных модулей «Девмана» и выбирайте тему.

Распаковка кортежей в 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 — распаковка ключей словаря в кортеж

Python — это очень часто используемый язык программирования, используемый программистами по всему миру. Python имеет множество различных приложений, включая веб-разработку, обработку данных, машинное обучение и автоматизацию различных задач. Он предлагает широкий спектр функций, которые можно использовать по мере необходимости. Способность Python распаковывать ключи словаря в кортежи — одна из таких возможностей. Несколько наборов данных хранятся с помощью кортежей в виде одной переменной. Эта статья научит нас, как распаковать ключ словаря в кортеж.

Распаковка

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

unpacking_variable = tuple(dictionary.keys()) # The key method is used to return a view object that contains keys for the dictionary

Различные методы распаковки ключей словаря в кортеж

Базовый кортеж

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

Пример

Details = < 'Name': 'Sam', 'Age': 12, 'Standard': '5' ># This is the dictionary which to be unpacked unpacking_tuple = tuple(Details.keys()) # With the help of keys() we get the keys of dictionary and convert it into tuple print(unpacking_tuple) # The tuple is displayed

Выход

Вывод приведенного выше примера будет следующим:

('Name', 'Age', 'Standard')

Распаковка нескольких переменных

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

Пример

Details = < 'Name': 'Sam', 'Age': 12, 'Standard': 5 ># This is the dictionary to be unpacked Name, Age, Standard = Details.keys() # The dictionary is unpacked into three different variables print(f"Name: , Age: , Standard: ")

Выход

Вывод приведенного выше примера выглядит следующим образом:

Name: Name, Age: Age, Standard: Standard

Перебор словаря

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

Пример

Details = < 'Name': 'Sam', 'Age': 12, 'Standard': '5' ># This is the dictionary that is to be unpacked for key in Details.keys(): # For loop is used to iterate over each key in the dictionary print(f"Key: , Value: ")

Выход

Результат вышеизложенного будет следующим:

Key: Name, Value: Sam Key: Age, Value: 12 Key: Standard, Value: 5

Сортировка ключей

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

Пример

Details = < 'Name': 'Sam', 'Age': 12, 'Standard': '5' ># This is the dictionary that is to be unpacked unpacked_keys = sorted(Details.keys()) # Sorted function will be used to sort the keys print(unpacked_keys) # The sorted keys will be displayed as output

Выход

Вывод примера будет следующим:

['Age', 'Name', 'Standard']

Извлечение значений

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

Пример

Details = < 'Name': 'Sam', 'Age': 12, 'Standard': '5' ># This is the dictionary that is to be unpacked name, age, standard = [Details[key] for key in ('Name', 'Age', 'Standard')] # We will use the list comprehension to get the values of keys print(f"Name: , Age: , Standard: ")

Выход

Вывод приведенного выше примера выглядит следующим образом:

Name: Sam, Age: 12, Standard: 5

Игнорирование нежелательных ключей

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

Пример

Details = < 'Name': 'Sam', 'Age': 12, 'Standard': '5', 'Country' : 'USA' ># This is the dictionary that is to be unpacked name, age, *other_info = Details.keys() print(f"Name: , Age: ") # The required keys are unpacked separately print(f"Other Info: ") # The other keys are unpacked separately

Выход

Вывод приведенного выше примера выглядит следующим образом:

Name: Name, Age: Age Other Info: ['Standard', 'Country']

Заключение

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

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