распаковка кортежа
Получаю вот такой вот кортеж из бд: [(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
Распаковка ( unpacking , также называемая Деструктуризация ) представляет разложение коллекции (кортежа, списка и т.д.) на отдельные значения.
Так, как и многие языки программирования, Python поддерживает концепцию множественного присваивания. Например:
x, y = 1, 2 print(x) # 1 print(y) # 2
В данном случае присваивем значения сразу двум переменным. Присвоение идет по позиции: переменная x получает значение 1, а переменная y — значени 2.
Данный пример в действительности уже представляет деструктуризацию или распаковку. Значения 1, 2 фактически являются кортежом, поскольку именно запятые между значениями говорят о том, что это кортеж. И мы также могли бы написать следующим образом:
x, y = (1, 2) print(x) # 1 print(y) # 2
В любом случае мы имеем дело с деструктуризацией, когда первый элемент кортежа передается первой переменной, второй элемент — второй переменной и так далее. То есть разложение идет по позиции.
Подобным образом можно разложить другие кортежи, например:
name, age, company = ("Tom", 38, "Google") print(name) # Tom print(age) # 38 print(company) # Google
Только кортежами мы не ограничены и можем «распаковывать» и другие коллекции, например, списки:
people = ["Tom", "Bob", "Sam"] first, second, third = people print(first) # Tom print(second) # Bob print(third) # Sam
При разложении словаря переменные получают ключи словаря:
dictionary = r, b, g = dictionary print(r) # red print(b) # blue print(g) # green # получаем значение по ключу print(dictionary[g]) # зеленый
Деструктуризация в циклах
Циклы в Python позволяют разложить коллекции на отдельные составляющие:
people = [ ("Tom", 38, "Google"), ("Bob", 42, "Microsoft"), ("Sam", 29, "JetBrains") ] for name, age, company in people: print(f"Name: , Age: , Company: ")
Здесь мы перебираем список кортежей people. Каждый кортеж состоит из трех элементов, соответственно при переборе мы можем их передать в переменные name, age и company.
Другой пример — функция enumerate() . Она принимает в качестве параметра коллекцию, создает для каждого элемента кортеж и возвращает набор из подобных кортежей. Каждый кортеж содержит индекс, который увеличивается с каждой итерацией:
people = ["Tom", "Bob", "Sam"] for index, name in enumerate(people): print(f".") # результат # 0.Tom # 1.Bob # 2.Sam
Игнорирование значений
Если какой-то элемент коллекции не нужен, то обычно для него определяется переменная с именем _ (прочерк):
person =("Tom", 38, "Google") name, _, company = person print(name) # Tom print(company) # Google
Здесь нам не важен второй элемент кортежа, поэтому для него определяем переменную _. Хотя в реальности _ — такое же действительное имя, как name и company:
name, _, company = person print(_) # 38
Упаковка значений и оператор *
Оператор * упаковывает значение в коллекцию. Например:
num1=1 num2=2 num3=3 *numbers,=num1,num2,num3 print(numbers) #[1, 2, 3]
Здесь мы упаковываем значения из кортежа (num1,num2,num3) в список numbers. Причем, чтобы получить список, после numbers указывается запятая.
Как правило, упаковка применяется для сбора значений, которые остались после присвоения результатов деструктуризации. Например:
head, *tail = [1, 2, 3, 4, 5] print(head) # 1 print(tail) # [2, 3, 4, 5]
Здесь переменная head в соответствии с позицией получае первый элемент списка. Все остальные элементы передаются в переменную tail . Таким образом, переменная tail будет представлять список из оставшихся элементов.
Аналогичным образом можно получить все кроме последнего:
*head, tail = [1, 2, 3, 4, 5] print(head) # [1, 2, 3, 4] print(tail) # 5
Или элементы по середине, кроме первого и последнего:
head, *middle, tail = [1, 2, 3, 4, 5] print(head) # 1 print(middle) # [2, 3, 4] print(tail) # 5
Или все кроме первого и второго:
first, second, *other = [1, 2, 3, 4, 5] print(first) # 1 print(second) # 2 print(other) # [3, 4, 5]
Вообщем, таким образом мы можем получать различные комбинации элементов коллекции. Причем не только списков, но и кортежей, словарей и других коллекций.
Другой пример — нам надо получить только первый, третий и последний элемент, а остальные элементы нам не нужны. В общем случае мы должны предоставить переменные для всех элементов коллекции. Однако если коллекция имеет 100 элементов, а нам нужно только три, не будем же мы определять все сто переменных. И в этом случае опять же можно применить упаковку:
first, _, third, *_, last = [1, 2, 3, 4, 5, 6, 7, 8] print(first) # 1 print(third) # 3 print(last) # 8
Также можно получить ключи словаря:
red, *other, green = print(red) # red print(green) # green print(other) # ['blue', 'yellow']
Распаковка и операторы * и **
Оператор * вместе с оператором ** также может применяться для распаковки значений. Оператор * используется для распаковки кортежей, списков, строк, множеств, а оператор ** — для распаковки словарей. Особенно это может быть полезно, когда на основе одних коллекций создаются другие. Например, распаковка кортежей и списков:
nums1 = [1, 2, 3] nums2 = (4, 5, 6) # распаковываем список nums1 и кортеж nums2 nums3 = [*nums1, *nums2] print(nums3) # [1, 2, 3, 4, 5, 6]
Здесь распаковывем значения из списка nums1 и кортежа nums2 и помещаем их в список nums3.
Подобным образом раскладываются словари, только применяется оператор ** :
dictionary1 = dictionary2 = # распаковываем словари dictionary3 = <**dictionary1, **dictionary2>print(dictionary3) #
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.
Любой из приведенных выше примеров можно использовать в качестве справочника для работы над своим личным кодом в соответствии с требованиями, а также очень важно иметь знания обо всех различных методах распаковки ключей словаря в кортеж и их преимуществах, поскольку это может помочь им во время любую часть их карьеры программиста и помочь им стать эффективными программистами.
Все права защищены. © Linux-Console.net • 2019-2024
Распаковка кортежей в 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 позволяет распаковывать кортежи и любые другие итерируемые объекты в любом месте кода, где вам может потребоваться дать описательные имена к элементам внутри данных объектов.