Понимание работы логических операций and, or и not
Важно! Операторы and и or закорачивают вычисление своих операндов (т.е. используют замыкания): правый операнд вычисляется лишь в том случае, если его значение необходимо для получения истинного значения в операциях and или or . Другими словами, замыкания в логических операциях используются для запуска второй части или последующих частей логического выражения только в том случае, если это актуально!
- or — оценивает второй аргумент, только если первый равен False . Если какой либо операнд в цепочке or является истиной, немедленно возвращается результат — первое истинное значение.
- and — оценивает второй аргумент, только если первый равен True . Если в цепочке and все операнды являются истиной, результатом будет последнее значение. А если какой-либо из операндов является False , результатом будет первое ложное значение.
- not имеет более низкий приоритет, чем операторы сравнения, так not a == b интерпретируется как not (a == b) , а выражение a == not b вовсе является синтаксической ошибкой. Единственный логический оператор с одним аргументом. Он принимает один аргумент x и возвращает противоположный результат: False для истинного значения и True для ложного значения.
Операторы and и or не приводят свои результаты принудительно к значениям True или False , а возвращают один из своих операндов. Такой подход позволяет использовать эти операторы в более общих, а не только булевых операциях. Если другие операторы, прежде чем выполнить операцию, вычисляют все свои операнды, то в случае операторов and и or с их семантикой закорачивания необходимость вычисления правого операнда определяется результатом вычисления левого.
Из булевых операторов, not имеет самый высокий приоритет, а or самый низкий, так что A and not B or C эквивалентно (A and (not B)) or C . Как всегда, скобки могут быть использованы для выражения желаемого приоритета в операциях.
Логические операции, упорядоченные по приоритету выполнения:
- not x — если x ложно, то возвращается True , иначе False .
- x and y — если x ложно, то возвращается x , иначе у .
- x or y — если x ложно, то возвращается у , иначе x
Объяснение работы замыкания c оператором and :
a = 'a' b = 'b' c = 'c' >>> a and b # 'b' >>> '' and b # '' >>> a and b and c # 'c'
Пояснения к примеру выше с оператором and :
- Оператор and вычисляет значения в булевом контексте слева направо. Значения 0 , » , [] , () , <> и None являются ложью, все остальное является истиной. Если у and оба операнда являются истиной, результатом будет последнее значение.
- Если какой-либо из операндов является ложью, результатом будет первое такое значение. В данном случает это » — пустая строка, первое значение которое является ложью.
- Все значения являются истиной, так что в результате мы получаем последнее c .
Объяснение работы замыкания c оператором or :
a = 'a' b = 'b' >>> a or b # 'a' >>> '' or b # 'b' >>> '' or [] or <> # <> >>> def func(): . return 1 >>> a or func() # 'a'
Пояснения к примеру выше с оператором or :
- Оператор or вычисляет значения в булевом контексте слева направо. Если операнд является истиной, or немедленно возвращает результат. В данном случае a , первое истинное значение.
- or вычисляет выражение » , которое является ложью, затем b, которое является истиной, и возвращает его значение.
- Если все значения являются ложью, or возвращает последнее.
- Обратите внимание, что or вычисляет операнды до тех пор, пока не найдет истинное значение, остальное игнорируется. Это имеет значение, когда вычисление операнда дает сторонние эффекты. В данном случае функция func() не вызывается, так как для получения результата выражения с оператором or достаточно того, что первый операнд a является истиной.
Другие примеры с and и or :
>>> a = 'one' >>> b = 'two' >>> 1 and a or b # 'one' >>> 0 and a or b # 'two' >>> a = '' >>> b = 'two' # 'a' - пустая строка, которую Python считает ложью, # следовательно 1 and '' дает '', а '' or 'two' дает 'two'. >>> 1 and a or b # 'two'
Практическое использование замыканий and и or в кодовой базе.
Внимание! Замыкания в операциях and и or можно использовать с пользой в вычислениях для экономии ресурсов, сокращения времени выполнения и т.д., только будьте осторожны! Необходимо четко понимать как работают замыкания в операторах and и or .
- Экономия ресурсов и времени выполнения при помощи and ;
- Проверка предварительных условий перед выражением;
- Определение значения по умолчанию при помощи or ;
- Пример использования замыканий в функциях all() и any() .
Экономия ресурсов и времени выполнения при помощи and .
Рассмотрим реальный пример из модуля base64 стандартной библиотеки Python, который использует замыкание в оператора if . Исследуем функцию b64decode , которая берет строку (или объект, подобный байтам) и декодирует ее:
# взято из Lib/base64.py def b64decode(s, altchars=None, validate=False): """Decode the Base64 encoded bytes-like object or ASCII string s. [docstring cut for brevity] """ s = _bytes_from_decode_data(s) if altchars is not None: altchars = _bytes_from_decode_data(altchars) assert len(altchars) == 2, repr(altchars) s = s.translate(bytes.maketrans(altchars, b'+/')) # использование замыкания с оператором `and` if validate and not re.fullmatch(b'[A-Za-z0-9+/]*=', s): raise binascii.Error('Non-base64 digit found') return binascii.a2b_base64(s)
Смотрим на оператор if , который помечен комментарием. В условии сначала проверяется аргумент validate , а только потом результат работы функции re.fullmatch() . Аргумент validate сообщает функции, хочет ли пользователь вообще проверять строку, которую нужно декодировать. Обратите внимание, что если validate=False то сопоставление регулярного выражения не запускается (срабатывает замыкание). Если порядок операндов поменять, то результат остался такой же, но было бы потрачено гораздо больше времени.
Проверка предварительных условий перед выражением.
Другой типичный шаблон использования замыканий проявляется, когда перед определенной операцией, которая может вызвать исключение, нужно что-то проверить.
Допустим есть последовательность и нужно взять элемент по индексу, но последовательность может оказаться пустой или ее длина может быть меньше индекса. Например:
>>> lst = [0, 1, 2] >>> lst[3] # Traceback (most recent call last): # File "", line 1, in # IndexError: list index out of range
Используем проверку предварительных условий:
>>> lst = [0, 1, 2] >>> if lst and len(lst) >=3: . lst[3]
Здесь, в условии сначала проверяется что список НЕ пустой и только после этого вычисляется длинна этого списка. Если список пустой, то его длина проверяться не будет и условие if завершиться.
Еще один пример из модуля enum :
# взято из Lib/enum.py def _create_(cls, class_name, names, *, module=None, qualname=None, type=None, start=1): """ Convenience method to create a new Enum class. """ # [сокращено для краткости] # special processing needed for names? if isinstance(names, str): names = names.replace(',', ' ').split() # смотрим на следующие условие if isinstance(names, (tuple, list)) and names and isinstance(names[0], str): original_names, names = names, [] last_values = [] # [сокращено для краткости]
Более длинный оператор if содержит три выражения, разделенных операторами and , и первые два выражения нужны для того, чтобы убедиться, можно ли безопасно выполнить последнее.
- isinstance(names, (tuple, list)) — проверяет, является ли names кортежем или списком. Если не является то условие завершается.
- далее names проверяется пусто оно или нет. Если элементов нет то условие завершается.
- если names не пустой, то можно безопасно выполнить последнюю проверку, связанную с индексацией names[0] , а именно isinstance(names[0], str) .
Определение значения по умолчанию при помощи or .
Замыкание с помощью логического оператора or может использоваться для присвоения переменным значений по умолчанию. Вот пример:
# test.py greet = input("Ваше имя >> ") or "незнакомец" print(f"Привет, greet>!") # $python3 -i test.py # Ваше имя >> # Привет, незнакомец!
Если запустить этот пример и ничего не вводя нажать Enter, то получим вывод «Привет, незнакомец!». Что тут происходит? Если ничего не вводить и нажать Enter, то функция input() вернет пустую строку » , что является False . Следовательно, оператор or видит ложное значение слева и должен оценить правый операнд. Для определения окончательное значение выражения or оценивает правый операнд и если он True , то возвращает его значение.
Еще пример присвоения значение по умолчанию (используя or ) для изменяемого аргумента из стандартной библиотеки Python.
# взято из Lib/cgitb.py class Hook: """A hook to replace sys.excepthook that shows tracebacks in HTML.""" def __init__(self, display=1, logdir=None, context=5, file=None, format="html"): self.display = display # send tracebacks to browser if true self.logdir = logdir # log tracebacks to files if not None self.context = context # number of source code lines per frame self.file = file or sys.stdout # self.format = format
Этот код взят из модуля cgitb и определяет sys.stdout как значение по умолчанию для переменной self.file . Определение функции __init__ имеет file=None в качестве ключевого аргумента, так почему бы просто не написать file=sys.stdout ?
Проблема в том, что sys.stdout может быть изменяемым объектом, поэтому использование file=sys.stdout в качестве ключевого аргумента со значением по умолчанию не будет работать так, как ожидается. Это легче продемонстрировать со списком в качестве аргумента по умолчанию, хотя принцип тот же:
>>> def addend(val, l=[]): . l.append(val) . print(l) >>> addend(3, [1, 2]) # [1, 2, 3] >>> addend(5) # [5] >>> addend(5) # [5, 5] >>> addend(5) # [5, 5, 5]
Обратите внимание на три последовательных вызова addend(5) . Ожидается, что вызов addend(5) со значением по умолчанию l=[] будет вести себя одинаково, но т.к. список является изменяемым объектом, то вызовы добавляют значения val к значению по умолчанию [] , при этом список растет! Дополнительно смотрите материал «Список Python как аргумент по умолчанию».
Пример использования замыканий or и and в функциях all() и any() .
Если в выражении генератора использовать оператор моржа := , и принимать во внимание тот факт, что функции all() и any() также используют замыкания, то можно использовать следующую конструкцию для извлечения первого истинного элемента.
any(predicate(witness := item) for item in items)
Другими словами, если какой-либо элемент item удовлетворяет условию в функции predicate() , то переменная witness сохранит его значение!
Например, если последовательность содержит много целых чисел, как выяснить, есть ли там какие-либо нечетные числа, и как вывести первое из них?
items = [14, 16, 18, 20, 35, 41, 100] any_found = False for item in items: any_found = item % 2 if any_found: print(f"Найдено нечетное число item>.") break
Теперь все это сравним со следующим кодом:
>>> items = [14, 16, 18, 20, 35, 41, 100] >>> is_odd = lambda x: x % 2 >>> if any(is_odd(witness := item) for item in items): . print(f"Найдено нечетное число witness>.") # Найдено нечетное число 35.
Логическое ИЛИ (||)
Логический оператор ИЛИ ( || ) (дизъюнкция) для набора операндов истинен будет true только в случае, если один или несколько его операндов имеют значение true .
Обычно используется с булевыми (логическими) значениями. Тогда возвращается булевое значение. Однако фактически оператор || возвращает значение одного из операндов, поэтому если этот оператор используется с небулевыми значениями, он вернет небулевое значение.
Интерактивный пример
Синтаксис
|| expr2;
Описание
Если expr1 может быть преобразовано в true , то вернётся expr1 ; в противном случае возвращается expr2 .
Если значение может быть преобразовано в true , то оно рассматривается как истиноподобное (truthy). Если же значение может быть преобразовано в false , то оно называется ложноподобным (falsy).
Примеры выражений, которые могут быть преобразованы в false :
- null ;
- NaN ;
- 0 ;
- пустая строка ( «» , » , « );
- undefined .
Несмотря на то, что оператор || может использоваться с операндами без логических значений, это всё равно булевый оператор, поскольку его возвращаемое значение всегда можно преобразовать в булевый примитив. Чтобы явно преобразовать возвращаемое значение этого оператора (или вообще любое выражение) в соответствующее значение булевого типа, используйте двойной оператор НЕ или конструктор Boolean (en-US).
Сокращённое вычисление
Оператор логического ИЛИ вычисляется слева направо, делая возможным сокращённое вычисление выражения, согласно следующему правилу:
(истинноподобное выражение) || следующее выражение — вычисление останавливается на истинноподобном выражении;
Сокращенное вычисление хорошо тем, что следующее выражение не будет вычислено, т.е. всё, связанное с ним, будет проигнорировано (например, если следующее выражение представляет собой вызов функции, то он никогда не произойдёт). Всё потому, что значение оператора известно уже после вычисления первого операнда. Посмотрите на пример:
function A() console.log("вызвана функция A"); return false; > function B() console.log("вызвана функция B"); return true; > console.log(B() || A()); // В результате вызова функции B, в консоли будет выведено "вызвана функция B", // а далее в консоли появится false (это результат оператора)
Приоритет операторов
Следующие выражения могут показаться эквивалентными, но это не так, потому что оператор && выполняется до оператора || (см. приоритет операторов).
true || (false && false); // вернёт true, поскольку сначала вычисляется && (true || false) && false; // вернёт false, поскольку у группировки выше приоритет
Примеры
Использование оператора ИЛИ
В следующем коде показаны примеры использования оператора || (логическое ИЛИ).
= true || true; // t || t вернёт true o2 = false || true; // f || t вернёт true o3 = true || false; // t || f вернёт true o4 = false || 3 == 4; // f || f вернёт false o5 = "Cat" || "Dog"; // t || t вернёт "Cat" o6 = false || "Cat"; // f || t вернёт "Cat" o7 = "Cat" || false; // t || f вернёт "Cat" o8 = "" || false; // f || f вернёт false o9 = false || ""; // f || f вернёт "" o10 = false || varObject; // f || object вернёт varObject
Примечание: Если вы используете этот оператор, чтобы задать значение по умолчанию для некоторой переменной, имейте в виду, что любое ложноподобное будет проигнорировано. Если вам нужно исключить только null или undefined , попробуйте воспользоваться оператором нулевого слияния.
Правила конвертации для булевых значений
Конвертация И в ИЛИ
Следующая операция с булевыми значениями:
Для чего могут использоваться операторы и или
В языке Python операторы and и or, как вы и ожидали, выполняют булевы операции, но они не возвращают булевы значения: результатом всегда является значение одного из операндов.
Пример 2.16. Оператор and
>>> 'a' and 'b' 'b' >>> '' and 'b' '' >>> 'a' and 'b' and 'c' 'c'
| При использовании оператора and, значения вычисляются в булевом контексте слева напрво. Значения 0, '', [], (), <> и None являются ложью, все остальное является истиной [3] . Если у and оба операнда являются истиной, результатом будет последнее значение. В данном случае вычисляется выражение 'a', которое является истиной, затем 'b', которое также является истиной, и возвращается 'b'. | |
| Если какой-либо из операндов является ложью, результатом будет первое такое значение. В данном случает '' — первое значение, являющееся ложью. | |
| Все значения являются истиной, так что в результате мы получаем последнее — 'c'. |
Пример 2.17. Оператор or
>>> 'a' or 'b' 'a' >>> '' or 'b' 'b' >>> '' or [] or <> <> >>> def sidefx(): . print "in sidefx()" . return 1 >>> 'a' or sidefx() 'a'
| Как и для and опреранды or вычисляются в булевском контексте слева направо. Если операнд является истиной, or немедленно возвращает результат. В данном случае 'a' — первое истинное значение. | |
| or вычисляет выражение '', которое является ложью, затем 'b', которое является истиной, и возвращает 'b'. | |
| Если все значения являются ложью, or возвращает последнее. or вычисляет '' (ложь), [] (ложь), затем <> (ложь) и возвращает <>. | |
| Обратите внимание, что or вычисляет операнды до тех пор, пока не найдет истинное значение, остальное игнорируется. Это имеет значение, когда вычисление операнда дает сторонние эффекты. В данном случае функция sidefx не вызывается, так как для получения результата выражения с опереатором or достаточно того, что первый операнд, 'a', является истиной. |
Если вы используете C, то, наверное, знакомы с выражением bool ? a : b, которое дает a, если bool является истиной, b, если bool ложно. Благодаря особенностям работы операторов and и or в Python, вы можете достигнуть анологичного эффекта.
Пример 2.18. Прием с and-or
>>> a = "first" >>> b = "second" >>> 1 and a or b 'first' >>> 0 and a or b 'second'
| Синтаксис bool ? a : b в языке Python выглядит похоже. Все выражение вычисляется слева направо, так что оператор and применяется первым. 1 and 'first' дает 'first', затем 'first' or 'second' дает 'first'. | |
| 0 and 'first' дает 0, тогда 0 or 'second' дает 'second'. |
Однако, так как такое выражение выполняет обычные логические операции, а не является специальной конструкцией языка, существует очень важная разница между приемом с and-or в языке Python и конструкцией bool ? a : b в C. Если значение a является ложью, это прием не будет работать так как вы могли ожидать. (Вы можете сказать, что обожгись на этом? Более одного раза?)
Пример 2.19. Когда прием с and-or не работает
>>> a = "" >>> b = "second" >>> 1 and a or b 'second'
| Так как a — пустая строка, которую Python считает ложью в булевом контексте, 1 and '' дает '', а '' or 'second' дает 'second'. Ой! Это не то, что мы хотели получить. |
| Прием с and-or, bool and a or b, не будет работать так же, как конструкция bool ? a : b в C, если a является ложью. | |
Для безопасного использования приема с and-or необходимо сделать так, чтобы a всегда было истинным. Один из самых распространенных способо это сделать — заменить a на [a] и b на [b], тогда первый элемент получаемого списка будет либо a, либо b.
Пример 2.20. Безопасное использование приема с and-or
>>> a = "" >>> b = "second" >>> (1 and [a] or [b])[0] ''
| Так как выражение [a] является непустым списком, оно никогда не будет ложно. Даже если a равно 0, '' или другому значению, являющемуся ложью, список [a] всегда будет являться истиной, потому что содержит один элемент. |
Кажется, этот прием не стоит того, чтобы его использовать. В конце концов вы всегда можете воспользоваться интсрукцией if. Тогда зачем вся эта суета? Конечно, в большинстве случаев выбирая между двумя константами вы можете использовать простой синтаксис и не беспокоиться, потому что значение a всегда будет истинным. И даже если придется использовать более сложный синтакс, на это могут найтись весские причины: в некоторых случаях в языке Python использование инструкции if не допускается, например в lambda-функциях.
- В Python Cookbook обсуждаются альтернативы приему с and-or.
[3] Ну, почти все. По умолчанию экземпляры классов являются истиной, но вы можете определить специальные методы в классе, чтобы его экземпляры могли быть ложью. Вы узнаете все о классах и специальных методах в главе 3.
Copyright © 2000, 2001, 2002 Марк Пилгрим
Copyright © 2001, 2002 Перевод, Денис Откидач
Операторы * и ** в Питоне. Что это и как использовать
Операторы (operators) * и ** встречаются в питоне очень часто. Иногда они немного непонятны и новичкам, и опытным ребятам, переходящим на питон с ряда других языков программирования (в которых операторы могут использоваться немного иначе). Статья известного питон-коуча Трея Ханнера (Trey Hunner), который помогает девелоперам расширять свои знания. Дата написания статьи: 10.11.2018.
Функционал операторов * и ** развивается уже много лет. Я хочу рассмотреть все способы их использования по состоянию на текущий момент. Буду указывать, что конкретно работает только в современных версиях питона. Поэтому, если вы изучали операторы * и ** еще во времена питона 2 (Python 2), советую хотя бы проглядеть данную статью, потому что в питоне 3 (Python 3) этим операторам добавили много новых возможностей.
Если вы начали изучать питон недавно и еще не освоили аргументы ключевых слов (keyword arguments; также известные как именованные аргументы, named arguments), предлагаю сперва прочитать мою статью про аргументы ключевых слов в питоне.
Что мы обсуждать не будем
В данной статье, говоря про операторы * и **, я имею в виду операторы-префиксы (prefix operators), а не инфиксы (infix). То есть, функции умножения и возведения в степень не входят в тему статьи.
Тогда про что же мы говорим
Мы говорим про операторы-префиксы * и **, которые используются перед переменной (variable). Например:
>>> numbers = [2, 1, 3, 4, 7]
>>> more_numbers = [*numbers, 11, 18]
>>> print(*more_numbers, sep=’, ‘)
2, 1, 3, 4, 7, 11, 18
В данном коде можно увидеть два способа использования оператора *. Оператор ** отсутствует.
В сферу применения рассматриваемых операторов входит:
1. Операторы * и **: передача аргументов в функцию.
2. Операторы * и **: захват аргументов, переданных в функцию.
3. Оператор *: принятие аргументов, содержащих только ключевые слова.
4. Оператор *: захват элементов во время распаковки кортежа (tuple).
5. Оператор *: распаковка итерируемых объектов в списке или кортеже.
6. Оператор **: + распаковка словарей в других словарях.
Даже если вам кажется, что вы освоили все эти способы, позволяющие использовать операторы * и **, рекомендую посмотреть на все нижеприведенные блоки кода, чтобы убедиться, что они все вам знакомы. Последние несколько лет разработчики ядра питона продолжают добавлять этим операторам новые возможности, поэтому какие-то из новых применений можно проглядеть.
Операторы * и ** при распаковке во время вызова функции
При вызове функции оператор * можно задействовать для распаковки итерируемого объекта в аргументах, введенных для вызова:
>>> fruits = [‘lemon’, ‘pear’, ‘watermelon’, ‘tomato’]
>>> print(fruits[0], fruits[1], fruits[2], fruits[3])
lemon pear watermelon tomato
>>> print(*fruits)
lemon pear watermelon tomato
В строке print(*fruits) производится вызов всех элементов списка fruits в функции print. Они становятся отдельными аргументами. При этом нам даже не надо знать, сколько всего аргументов окажется в списке.
В данном примере оператор * – не просто синтактический выверт (syntactic sugar). Без * отправить все элементы конкретного итерируемого объекта в качестве отдельных аргументов было бы невозможно (это не касается списков с сфиксированной длиной).
Еще один пример:
def transpose_list(list_of_lists):
return [
list(row)
for row in zip(*list_of_lists)
]
В данном случае мы принимаем список со списками в качестве элементов и возвращаем «преобразованный» список со списками:
>>> transpose_list([[1, 4, 7], [2, 5, 8], [3, 6, 9]])
[[1, 2, 3], [4, 5, 6], [7, 8, 9]]
Функционал оператора ** примерно такой же, просто он применяется к аргументам ключевых слов. Он позволяет нам взять словарь, содержащий пары из ключей и значений, и распаковать его в аргументы ключевых слов при вызове функции.
>>> date_info = <'year': "2020", 'month': "01", 'day': "01">
>>> filename = «—.txt».format(**date_info)
>>> filename
‘2020-01-01.txt’
Скажу из своего опыта. Оператор ** не часто используется для распаковки аргументов ключевых слов при вызове функции. Чаще всего я вижу такие примеры при работе с наследованием: вызовы super() часто включают в себя оба оператора.
Операторы * и ** можно использовать неоднократно при вызове функции. Данная возможность появилась в питоне 3.5. Иногда это может оказаться очень уместным:
>>> fruits = [‘lemon’, ‘pear’, ‘watermelon’, ‘tomato’]
>>> numbers = [2, 1, 3, 4, 7]
>>> print(*numbers, *fruits)
2 1 3 4 7 lemon pear watermelon tomato
Неоднократное использование ** выглядит примерно так же:
Однако не нужно терять бдительности при неоднократном использовании операторов * и **. Неоднократное указание одного и того же аргумента ключевых слов не допускается в функциях питона. Поэтому, если использовать ** для словарей, то ключи должны быть уникальными. В противном случае возникнет исключение.
Операторы * и ** при упаковке аргументов, переданных функции
При определении тела функции можно использовать оператор *, чтобы захватывать неограниченное количество позиционных аргументов, переданных этой функции. Они оформляются в кортеж.
from random import randint
def roll(*dice):
return sum(randint(1, die) for die in dice)
Данная функция принимает любое количество аргументов.
>>> roll(20)
18
>>> roll(6, 6)
9
>>> roll(6, 6, 6)
8
Функции питона print и zip принимают любое количество позиционных аргументов. Такое использование оператора * при упаковке аргументов позволяет нам создавать свои функции, которые (аналогично print и zip) принимают любое количество аргументов.
Кроме того, для оператора ** в данном вопросе предусмотрена еще одна возможность: его можно использовать при определении тела функции, позволяющей захватить в словарь любые аргументы ключевых слов, переданные этой функции:
def tag(tag_name, **attributes):
attribute_list = [
f’=»»‘
for name, value in attributes.items()
]
return f» >»
В данном месте ** захватывает в словарь аргументы ключевых слов, которые мы передаем данной функции. Впоследствии аргументы атрибутов (attributes) данной функции смогут на него ссылаться.
>>> tag(‘a’, href=»http://treyhunner.com»)
>>> tag(‘img’, height=20, width=40, src=»https://kirill-sklyarenko.ru/face.jpg»)
Позиционные аргументы, содержащие аргументы только из ключевых слов
питон 3 ввел специальный синтаксис для передачи аргументов, содержащих только ключевые слова, в функцию. Они представляют собой такие аргументы функции, которые можно определить только с помощью синтаксиса для ключевых слов. Это означает, что их нельзя определить позиционно.
Чтобы принимать аргументы, содержащие только ключевые слова, мы можем поместить именованные аргументы после оператора * при определении тела функции:
def get_multiple(*keys, dictionary, default=None):
return [
dictionary.get(key, default)
for key in keys
]
Данную функцию можно использовать так:
Аргументы dictionary и default поставлены после *keys. То есть, их можно только в качестве аргументов ключевых слов. Если мы попытаемся определить их позиционно, то увидим ошибку:
>>> fruits = <'lemon': 'yellow', 'orange': 'orange', 'tomato': 'red'>
>>> get_multiple(‘lemon’, ‘tomato’, ‘squash’, fruits, ‘unknown’)
Traceback (most recent call last):
+ File «», line 1, in
TypeError: get_multiple() missing 1 required keyword-only argument: ‘dictionary’
Данное поведение внедрено в питон с помощью предложения PEP 3102.
Аргументы, содержащие только ключевые слова и не содержащие позиционные аргументы
Аргументы, содержащие только ключевые слова, – неплохое средство. Но что если вы хотите требовать ввода аргументов, содержащих только ключевые слова, не захватывая неограниченное количество позиционных аргументов?
питон позволяет сделать это с помощью немного странного синтаксиса, когда оператор * как бы сам по себе:
def with_previous(iterable, *, fillvalue=None):
«»»Yield each iterable item along with the item before it.»»»
previous = fillvalue
for item in iterable:
yield previous, item
previous = item
Данная функция принимает аргумент, содержащий итерируемый объект (iterable). Его можно определить позиционно (то есть, первым) или с помощью названия и аргумента fillvalue, который входит в число аргументов, допускающих только ключевые слова. Это означает, что мы можем вызвать функцию with_previous вот так:
>>> list(with_previous([2, 1, 3], fillvalue=0))
[(0, 2), (2, 1), (1, 3)]
>>> list(with_previous([2, 1, 3], 0))
Traceback (most recent call last):
File «», line 1, in
TypeError: with_previous() takes 1 positional argument but 2 were given
Данная функция принимает два аргумента. Один из них, fillvalue, обязательно определяется как аргумент, содержащий ключевое слово.
Обычно я использую аргументы, допускающие только ключевые слова, при захвате неопределенного количества позиционных аргументов. Но иногда я использую данную возможность оператора *, чтобы форсировать исключительно позиционное определение аргумента.
На самом деле, данный подход используется встроенной функцией питона sorted. Если посмотреть справку для sorted, можно увидеть следующее:
>>> help(sorted)
Help on built-in function sorted in module builtins:
sorted(iterable, /, *, key=None, reverse=False)
Return a new list containing all items from the iterable in ascending order.
A custom key function can be supplied to customize the sort order, and the reverse flag can be set to request the result in descending order.
Пример использования оператора * как самого по себе прямо в документации по аргументам функции sorted.
Операторы * и ** при распаковке кортежа
Дополнительно к вышенаписанному, в питоне 3 добавлен новый способ применения *, который некоторым образом связан с вышеописанными возможностями этого оператора при определении тела функции и при вызове функции.
Оператор * теперь можно использовать при распаковке кортежа:
>>> fruits = [‘lemon’, ‘pear’, ‘watermelon’, ‘tomato’]
>>> first, second, *remaining = fruits
>>> remaining
[‘watermelon’, ‘tomato’]
>>> first, *remaining = fruits
>>> remaining
[‘pear’, ‘watermelon’, ‘tomato’]
>>> first, *middle, last = fruits
>>> middle
[‘pear’, ‘watermelon’]
Если вы задаете себе вопрос: как же мне использовать это в своем коде, посмотрите примеры в моей статье про распаковку кортежей в питоне. В этой статье я показал, каким образом такое использование оператора * может, в некоторых случаях, стать альтернативой для срезания последовательностей (sequence slicing).
Обычно во время своих лекций об операторе * я говорю, что можно использовать только одно выражение с ним в отдельном вызове многократного присвоения (multiple assignment). Технически это некорректно, потому что можно его использовать два раза при вложенной распаковке (nested unpacking). Данный вопрос я рассмотрел подробно в статье про распаковку кортежей.
>>> fruits = [‘lemon’, ‘pear’, ‘watermelon’, ‘tomato’]
>>> ((first_letter, *remaining), *other_fruits) = fruits
>>> remaining
[‘e’, ‘m’, ‘o’, ‘n’]
>>> other_fruits
[‘pear’, ‘watermelon’, ‘tomato’]
Правда, я никогда не встречал хорошего примера такого использования. Не думаю, что стал бы его рекомендовать, даже если бы удалось найти. Он выглядит немного непонятно.
Данная возможность добавлена в питон на основе предложения PEP 3132. Следует отметить, что оно не относится к очень длинным.
Операторы * и ** в литерале списка
В питоне 3.5 добавлено очень много возможностей, связанных с оператором *, на основе предложения PEP 448. Одной из самых заметных новых возможностей стало использование * для вывода итерируемого объекта в новый список.
Допустим, у вас есть функция, которая принимает любые последовательности и возвращает список, содержащий каскад из последовательности и ее реверсивного варианта:
def palindromify(sequence):
return list(sequence) + list(reversed(sequence))
Данная функция должна пару раз провести конвертацию в список, чтобы объединить списки и вернуть результат. Начиная с питона 3.5, мы можем, вместо вышеприведенного примера, написать следующее:
def palindromify(sequence):
return [*sequence, *reversed(sequence)]
В данном коде больше нет нескольких ненужных вызовов списков. Поэтому он стал эффективнее и лучше читается.
def rotate_first_item(sequence):
return [*sequence[1:], sequence[0]]
Данная функция возвращает новый список, в котором первый элемент переданного списка (или другой последовательности) перенесен в конец нового списка.
Это очень удачная возможность, позволяющая с помощью оператора * объединять итерируемые объекты различных типов. Оператор * работает с любыми итерируемыми объектами, а оператор + работает только с определенными последовательностями, при чем все из объединяемых должны быть одного типа.
Отмечу, что данная возможность не ограничивается только созданием списков. Мы можем выводить итерируемые объекты в новые кортежи или множества (set):
Обратите внимание, что последняя строка принимает список и генератор (generator), а потом выводит их в новое множество. Перед появлением этой возможности для оператора * было непросто сделать это в одну строку кода. Разумеется, способ сделать это существовал, но его было непросто вспомнить или обнаружить:
>>> set().union(fruits, uppercase_fruits)
Оператор ** в литерале словаря
Помимо вышеприведенного на основе предложения PEP 448 в функционал ** добавлен вывод пар ключ/значение (key/value) из словаря в новый словарь:
>>> date_info =
>>> track_info =
>>> all_info = <**date_info, **track_info>
>>> all_info
Про это я написал еще одну статью. Сейчас ее можно найти под новым названием про идиоматический способ сливать словари в питоне. Данную возможность можно использовать не только для сливания двух словарей. Например, можно скопировать словарь, параллельно добавляя в него новые значения:
>>> date_info =
>>> event_info = <**date_info, 'group': "Python Meetup">
>>> event_info
Еще можно скопировать или слить словари, переписывая определенные значения:
>>> event_info =
>>> new_info = <**event_info, 'day': "14">
>>> new_info
Операторы * и ** обладают немалыми возможностями в питоне
В питоне операторы * и ** – не просто синтактический выверт. Некоторые из их возможностей реализуются и другими средствами, но доступные альтернативы обычно более громоздкие и потребляют больше ресурсов. Кроме того, некоторые элементы в функционале этих операторов попросту не доступны без их использования. Например, без помощи * невозможно передать в функцию неопределенное количество позиционных аргументов.
Прочитав обо всех возможностях * и **, вы, возможно, удивитесь названиям, под которыми используются эти странные операторы. К сожалению, для них нет лаконичных названий. Я слышал, как * называли оператором для упаковки и распаковки. Еще слышал, как его называли «splat» (это из мира Руби) и просто звездой.
Чаще всего я называю их звездой (star) и двойной звездой (double star) (или звездой-звездой (star star)). В данном случае разделения с их функциями как инфиксов не проводится (речь идет про операции умножения и возведения в степень). Но обычно из контекста очевидно, о чем идет речь, про префиксы или инфиксы.
Если вы не понимаете операторы * и ** или боитесь не запомнить все их возможности, не нужно беспокоиться. Способов использования много, и запоминать каждую конкретную возможность для каждого из них не так важно. Лучше будет осознать, в каких случаях к ним можно обратиться. Предлагать использовать данную статью как чек-лист или создать свой чек-лист, который поможет вам использовать операторы * и ** в питоне.
- перевод с английского
- python
- операторы