Эта статья возникла из личного публичного аккаунта:TechFlow, оригинальность это не просто, прошу внимания
Все мы знаем, что Python — такой гибкий язык, что, если это не ваш первый язык, вы обнаружите, что он всегда преподносит вам всевозможные сюрпризы, которым вы не можете не удивляться: woc, и это операция. Тем более, что я пришел из бэкэнда Java до систематического изучения Python, поэтому почти каждый этап кажется мне открытием нового мира. Сегодня я познакомлю вас с самой простой операцией, которая очень проста в использовании, но многие люди о ней не знают.
распаковать переменную
Все мы знаем, что Python позволяет присваивать несколько переменных, например знаменитый обмен двумя элементами.Если это на языке C++ или Java, если это не реализовано через функции, необходимо ввести третью переменную, например:
# swap a, b
c = a
a = b
b = c
Чтобы поменять местами a и b, мы должны ввести c, потому что, когда мы присваиваем b значению a, исходное значение a будет потеряно, поэтому мы должны сначала «кэшировать» его. Однако, поскольку Python поддерживает операции присваивания с несколькими переменными, это можно сделать без введения других переменных, поэтому замена двух элементов может быть выполнена всего одной строкой в Python:
a, b = b, a
Интерпретатор Python будет напрямую вычислять следующее значение, а затем перезаписывать левую часть.Присваивание выполняется одновременно, поэтому нет необходимости вводить другие переменные, и это выглядит очень гиковски.
Кроме того, Python также поддерживает распаковку кортежей и списков.
Например, предположим, что у нас есть двоичный массив: [1, 2], и мы хотим использовать две переменные для получения его 0-го и 1-го битов, мы, конечно, можем написать это так:
l = [1, 2]
a, b = l[0], l[1]
На самом деле, это не так хлопотно, потому что, когда Python обнаруживает, что слева от знака равенства есть несколько переменных, а справа — список или кортеж, он автоматически распаковывает список и кортеж и по очереди присваивает их соответствующим элементам. , поэтому приведенный выше код может упроститься до:
l = [1, 2]
a, b = l
Что, если l — двумерный массив, и мы хотим выполнить итерацию по нему? Его также можно использовать в цикле:
l = [[1, 2], [3, 4], [5, 6]]
for i, j in l:
print(i, j)
Это работает даже в комбинациях переменных:
a, b, c = 1, 3, (4, 5)
print(c)
Когда мы выполним этот код, что будет выведено на экран? Сообщит об ошибке? Или он распаковывает кортеж (4, 5) и присваивает 4 переменной c?
Ни то, ни другое не является правильным, выходным результатом является (4, 5), что означает, что после того, как Python обнаружит, что количество переменных не совпадает, он автоматически присвоит кортеж целиком. Не только это, но даже в следующих случаях Python может автоматически распознавать:
a, b, (c, d), e = 1, 3, (4, 5), 7
print(c, d)
В приведенном выше присваивании есть как кортеж, так и обычные элементы, а также наши переменные объединены в кортеж.В это время Python также распознает, что (4, 5) должно быть присвоено целому (c, d), что означает, что 4 и 5 присвоены c и d соответственно.
элемент по умолчанию
Иногда, когда мы получаем элементы, в исходных данных есть поля, которые нам не нужны. Хотя автоматическая распаковка в Python очень удобна, нам все равно приходится устанавливать переменные для данных, которые нам не нужны. В некоторых случаях это приводит к пустой трате памяти, и это не соответствует норме нашего программирования, что все переменные должны пригодиться. Чтобы решить эту проблему, Python предоставляет методы для элементов по умолчанию. Мы можем использовать _ для представления значения по умолчанию, и данные, соответствующие _, не будут храниться, просто для удобства «группировки» элементов.
Например, используя приведенный выше пример в качестве примера, предположим, что формат исходных данных: 1, 3, (4, 5), 7, но нам нужен только средний кортеж, и мы можем получить его так:
_, _, (c, d), _ = 1, 3, (4, 5), 7
В другом примере, когда мы просматриваем словарь, возможно, мы не обращаем внимания на ключ словаря, а только хотим получить его значение, В это время мы также можем использовать символ по умолчанию:
a = {}
for _, v in a.items():
print(v)
Сжатые переменные
Поскольку переменные можно распаковывать, естественно, их можно и сжимать. Представьте себе сценарий, например, есть пакет данных об измерении заводских деталей.Помимо размера детали, эти данные также содержат другие атрибуты, такие как название детали, дата изготовления и название завода. . Предположим, мы сейчас хотим разобрать эти данные и сохранить размер части в массиве, что нам делать в это время?
Например, спецификация данных детали выглядит следующим образом: колесо, завод1, 3, 4, 5, 6, 2020-02-02.
Python также предоставляет решение этой проблемы, которое представляет собой компрессор переменных *. Для вышеуказанной проблемы мы можем написать:
data = ['wheel', 'factory1', 3, 4, 5, 6, '2020-02-02']
name, factory, *inch, date = data
print(inch)
Наконец, дюйм, который мы печатаем, равен [3, 4, 5, 6], что означает, что, используя *, мы успешно присваиваем данные, представляющие размер части в середине, в массив. Эта операция очень важна, потому что возможно, что количество разных размеров частей разное, с чем сложно справиться, если мы пишем парсинг сами. И с помощью оператора * в Python мы можем очень хорошо решить эту проблему.
совместное использование
До сих пор мы ввели использование символов по умолчанию и использование сжатых символов.Вопрос в том, можем ли мы использовать эти два символа в комбинации, чтобы получить любое значение по умолчанию в данных?
Конечно, это возможно, сейчас та же проблема, если предположить, что сейчас нас не волнует размер частей и мы хотим их отфильтровать, нам просто нужно внести небольшое изменение в приведенный выше код:
data = ['wheel', 'factory1', 3, 4, 5, 6, '2020-02-02']
name, factory, *_, date = data
Таким образом, мы отфильтровываем некоторую информацию о размере в середине и сохраняем другую информацию только в начале и конце.
Другое использование
Это еще не конец. Не знаю, возникают ли у вас ассоциации, когда вы видите оператор *. Если вы немного знаете Python, вам следует подумать о Python. Если мы хотим, чтобы функция получала какие-либо параметры, мы можем написать ее как :
def func(*args, **kw):
pass
Среди них args на самом деле представляет собой массив, а kw представляет собой словарь, который мы все знаем. Но как насчет предыдущих * и ** , что они представляют?
* представляет собой распакованный массив, ** естественно представляет распакованный словарь. Давайте посмотрим на пример:
a = [1, 3, 5]
print(a)
print(*a)
В чем разница между print(a) и print(*a)? Если вы попробуете это сделать, вы обнаружите, что при прямой печати a результат будет [1, 3, 5], а если вы напечатаете *a, результат будет 1, 3, 5. Другими словами, первый выводит a как массив, который является переменной, а второй распаковывает a и выводит его как 3 переменные. Затем та же самая причина, **kw, также распаковывает kw как словарь и расширяет его в форме ключ: значение. Однако, если вы вызовете **kw напрямую, вы получите ошибку.Эту операцию можно использовать только тогда, когда функция передает параметры.
Итак, мы понимаем, почему *args и **kw могут представлять все параметры. Поскольку первый представляет обязательные параметры, которые передаются напрямую, а второй представляет параметры по умолчанию, которые предоставляют значения по умолчанию. Это также причина, по которой Python ограничивает размещение параметров по умолчанию после обязательных параметров, с одной стороны, для устранения двусмысленности, а с другой стороны, чтобы иметь возможность использовать *args, **kw для единообразного выражения.
Хотя сегодняшнее содержание простое, оно часто используется в реальном коде. При правильном использовании оно может значительно упростить сложность нашего кодирования и красоту кода. Поэтому, если вы интересуетесь Python, настоятельно рекомендуется узнать его.
На сегодняшней статье все, если вы найдете что-то полезное, пожалуйстаОтсканируйте код и обратите вниманиеЧто ж, твое маленькое усилие много значит для меня.
использованная литература Поваренная книга Python, третье издание
Википедия