TOC

Как использовать Python или оператор

Как использовать Python или оператор

В Python есть три логических оператора:and,or иnot. С их помощью вы можете протестировать условия и решить, какой путь выполнения выберут ваши программы. В этом руководстве вы узнаете об операторе Pythonor и о том, как его использовать.

К концу этого урока вы научитесь:

  • Как работает оператор Pythonor

  • Как использовать оператор Pythonor в логических и небулевых контекстах

  • Какие проблемы программирования вы можете решить, используяor в Python

  • Как читать и лучше понимать код других людей, когда они используют некоторые специальные функции оператора Pythonor

Вы узнаете, как использовать оператор Pythonor, построив несколько практических примеров. Даже если вы на самом деле не используете все возможности, которые предлагает оператор Pythonor, его освоение позволит вам писать лучший код.

Free Bonus:Click here to get access to a chapter from Python Tricks: The Book, который демонстрирует вам лучшие практики Python на простых примерах, которые вы можете мгновенно применить для написания более красивого кода Pythonic.

Логическая логика

George Boole (1815–1864) разработал то, что сейчас называетсяBoolean algebra, которое является основой цифровой логики компьютерного оборудования и языков программирования.

Булева алгебра построена наtruth value выражений и объектов (будь тоtrue илиfalse) и основана на логических операцияхAND,OR, иNOT. Эти операции реализуются с помощью логических или логических операторов, которые позволяют вам создаватьBoolean expressions, которые являются выражениями, которые оцениваются как истинные или ложные.

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

Давайте рассмотрим некоторые основные понятия, связанные с булевой логикой в ​​Python:

  • Boolean - это тип значения, которое может бытьTrue илиFalse. В Python логическим типом являетсяbool, который является подтипомint.

  • Boolean values - это значенияTrue илиFalse (с заглавной буквыT иF) в Python.

  • Boolean variable - это переменная, которая может бытьTrue илиFalse. Логические переменные обычно используются какflags, чтобы указать, существуют ли определенные условия.

  • Boolean expression - это выражение, которое возвращает либоTrue, либоFalse.

  • Boolean context может быть условиямиif и цикламиwhile, где Python ожидает, что выражение будет оцениваться как логическое значение. Вы можете использовать практически любое выражение или объект в логическом контексте, и Python попытается определить его значение истинности.

  • Operands - это подвыражения или объекты, входящие в выражение (логическое или нет) и связанные оператором.

  • Boolean or logical operators - этоAND (логическийAND или конъюнкция),OR (логическийOR или дизъюнкция) иNOT (логическийNOT или отрицание). Ключевые словаand,or иnot являются операторами Python для этих операций.

Теперь, когда у вас есть лучший контекст по булевой логике, давайте продолжим с некоторыми более специфичными для Python темами.

Булевы операторы Python

В Python есть три логических оператора, которые напечатаны как простые английские слова:

  1. and

  2. or

  3. not

Эти операторы соединяют логические выражения (и объекты) для создания составных логических выражений.

Логические операторы Python всегда принимают два логических выражения или два объекта или их комбинацию, поэтому они считаютсяbinary operators.

В этом руководстве вы познакомитесь с оператором Pythonor, который реализует логическую операциюOR в Python. Вы узнаете, как это работает и как его использовать.

Как работает оператор Pythonor

С помощью логического оператораOR вы можете соединить два логических выражения в одно составное выражение. По крайней мере одно подвыражение должно быть истинным, чтобы составное выражение считалось истинным, и не имеет значения, какое. Если оба подвыражения ложны, то выражение ложно.

Это общая логика оператораOR. Однако оператор Pythonor делает все это и многое другое, как вы увидите в следующих разделах.

Использованиеor с логическими выражениями

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

# Syntax for Boolean expression with or in Python
exp1 or exp2

Если хотя бы одно из подвыражений (exp1 илиexp2) оценивается какTrue, тогда выражение считаетсяTrue. Если оба подвыражения оцениваются какFalse, тогда выражение будетFalse. Это определение называетсяinclusive or, поскольку оно допускает обе возможности.

Вот краткое описание поведения оператора Pythonor:

Результатexp1 Результатexp2 Результатexp1 or exp2

True

True

True

True

False

True

False

True

True

False

False

False

Таблица 1. Логический оператор Pythonor: таблица истинности

Эта таблица суммирует результирующее значение истинности логического выражения, такого какexp1 or exp2, в зависимости от значений истинности его подвыражений.

Давайте проиллюстрируем результирующие значения истинности, показанные вTable 1, кодируя несколько практических примеров:

>>> 

>>> exp1 = 1 == 2
>>> exp1
False
>>> exp2 = 7 > 3
>>> exp2
True
>>> exp1 or exp2  # Return True, because exp2 is True
True
>>> exp2 or exp1  # Also returns True
True
>>> exp3 = 3 < 1
>>> exp1 or exp3  # Return False, because both are False
False

В предыдущих примерах, когда подвыражение оценивается какTrue, глобальным результатом будетTrue. С другой стороны, если оба подвыражения оцениваются какFalse, то глобальный результат также будетFalse.

Использованиеor с общими объектами

В общем, операнды выражения, включающего операциюOR, должны иметь логические значения, как показано вTable 1, и возвращать в результате значение истинности. Когда дело доходит до объектов, Python не очень строг к этому и внутренне реализует набор правил, чтобы решить, считается ли объект истинным или ложным:

По умолчанию объект считается истинным, если его класс не определяет методhttps://docs.python.org/3/reference/datamodel.html#object.bool [__bool__()], который возвращаетFalse илиhttps://docs.python.org/3/reference/datamodel.html#object.len [__len__()], который возвращает ноль при вызове с объектом. Вот большинство встроенных объектов, которые считаются ложными:

  • константы, определенные как ложные:None иFalse.

  • ноль любого числового типа:0,0.0,0j,Decimal(0),Fraction(0, 1)

  • пустые последовательности и коллекции:'',(),[],{},set(),range(0)

(Source)

Если операнды, участвующие в операцииor, являются объектами, а не логическими выражениями, тогда оператор Pythonor возвращает истинный или ложный объект, а не значенияTrue илиFalse как можно было ожидать. Значение истинности этого объекта определяется в соответствии с правилами, которые вы видели ранее.

Это означает, что Python не приводит результат операцииor к объектуbool. Если вы тестируете два объекта с помощьюor в Python, то оператор вернет первый объект, который оценивается как истинный, или последний объект в выражении, независимо от его истинного значения:

>>> 

>>> 2 or 3
2
>>> 5 or 0.0
5
>>> [] or 3
3
>>> 0 or {}
{}

В двух первых примерах первые операнды (2 и5) истинны (не равны нулю), поэтому оператор Pythonor всегда возвращает первый.

В последних двух примерах левый операнд имеет значение false (пустой объект). Оператор Pythonor оценивает оба операнда и возвращает объект справа, который может иметь значение true или false.

Note: Если вам действительно нужно получить одно из значенийTrue илиFalse из логического выражения, включающего объекты, вы можете использоватьbool(obj), который является встроенной функцией который возвращаетTrue илиFalse в зависимости от значения истинностиobj.

Вы можете суммировать поведение, показанное в предыдущем коде, следующим образом:

Левый объект Правый объект Результатx or y

x

y

x, если оно истинно, иначеy.

Таблица 2. Поведение оператора Pythonor при тестировании объектов вместо логических выражений

Короче говоря, оператор Pythonor возвращает первый объект, который оценивается как истинный, или последний объект в выражении, независимо от его истинного значения.

Вы можете обобщить это поведение, связав несколько операций в одном выражении, например: 

a or b or c or d

В этом примере оператор Pythonor возвращает первый истинный операнд, который он находит, или последний. Это практическое правило запоминания того, какor работает в Python.

Смешивание логических выражений и объектов

Вы также можете комбинировать логические выражения и общие объекты Python в операцииor. В этом случае оператор Pythonor по-прежнему будет возвращать первый истинный операнд или последний операнд, но возвращаемое значение может бытьTrue илиFalse или объект, который вы тестируете:

Результат выражения Результат объекта Результатexp or obj

True

True

True

True

False

True

False

False

obj

False

True

obj

Таблица 3 Поведение оператора Pythonor при тестировании объектов и логических выражений

Давайте посмотрим, как это работает на нескольких примерах:

>>> 

>>> 2 < 4 or 2  # Case 1
True
>>> 2 < 4 or []  # Case 2
True
>>> 5 > 10 or []  # Case 3
[]
>>> 5 > 10 or 4  # Case 4
4

ВCase 1 иCase 2 подвыражение2 < 4 было оценено какTrue, а возвращенное значение былоTrue. С другой стороны, вCase 3 иCase 4 подвыражение5 > 10 было оценено какFalse, поэтому был возвращен последний операнд, и вы получили пустой список ([]) и целое число (4) вместоTrue илиFalse.

В качестве упражнения вы можете попробовать расширитьTable 3, изменив порядок выражений в третьем столбце на обратный, то есть использоватьobj or exp и попытаться предсказать результаты.

Оценка короткого замыкания

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

>>> 

>>> True or 4 < 3
True

Если первый операнд в выраженииor имеет значение истина, независимо от значения второго операнда (4 < 3 равноFalse), то выражение считается истинным, а второе операнд никогда не оценивается. Это называетсяshort-circuit (lazy) evaluation.

Давайте рассмотрим другой пример:

>>> 

>>> def true_func():
...     print('Running true_func()')
...     return True
...
>>> def false_func():
...     print('Running false_func()')
...     return False
...
>>> true_func() or false_func()  # Case 1
Running true_func()
True
>>> false_func() or true_func()  # Case 2
Running false_func()
Running true_func()
True
>>> false_func() or false_func()  # Case 3
Running false_func()
Running false_func()
False
>>> true_func() or true_func()  # Case 4
Running true_func()
True

ВCase 1 Python оценилtrue_func(). Поскольку он возвращаетTrue, следующий операнд (false_func()) не оценивается. Обратите внимание, что фразаRunning false_func() никогда не печатается. Наконец, все выражение считаетсяTrue.

Case 2 оценивает обе функции, потому что первый операнд (false_func()) равенFalse. Затем оператор возвращает второй результат, то есть значение, возвращаемоеtrue_func(), то естьTrue.

Case 3 оценивает обе функции, потому что обе возвращаютFalse. Операция возвращает значение, возвращаемое последней функцией, то естьFalse, а выражение считаетсяFalse.

ВCase 4 Python оценивает только первую функцию, то естьTrue, а выражение -True.

Вshort-circuit (lazy) evaluation второй операнд логического выражения не оценивается, если значение выражения может быть определено только по первому операнду. Python (как и другие языки) обходит эту вторую оценку в пользу производительности, потому что оценка второго операнда была бы ненужной тратой процессорного времени.

Наконец, когда дело доходит до производительности при использовании оператора Pythonor, примите во внимание следующее:

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

  • Условие, которое с большей вероятностью будет истинным, может быть крайним левым условием. Такой подход может сократить время выполнения ваших программ, потому что таким образом Python может определить, выполняется ли условие, просто оценив первый операнд.

Раздел Резюме

Вы узнали, как работает оператор Pythonor, и познакомились с некоторыми из его основных функций и поведения. Теперь вы знаете достаточно, чтобы продолжить выравнивание, научившись использовать оператора в решении реальных задач.

Перед этим давайте вспомним некоторые важные моменты оor в Python:

  • Он удовлетворяет общим правилам, которым должен следовать логический операторOR. Если одно или оба логических подвыражения имеют значение true, то результат равен true. В противном случае, если оба подвыражения ложны, то результат ложен.

  • Он возвращает объекты вместо значенийTrue илиFalse при тестировании объектов Python. Это означает, что выражениеx or y возвращаетx, если оно оценивается как истина, а в противном случае возвращаетy (независимо от его истинного значения).

  • Он следует заранее определенному набору внутренних правил Python для определения истинного значения объекта.

  • Он перестает оценивать операнды, как только находит то, что считается истинным. Это называется коротким замыканием или ленивой оценкой.

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

Булевы контексты

В этом разделе вы увидите несколько практических примеров использования оператора Pythonor и узнаете, как использовать преимущества его несколько необычного поведения для написания лучшего кода Python.

Существует две основные ситуации, когда вы можете сказать, что работаете в логическом контексте в Python:

  1. if statements: условное исполнение

  2. while loops: условное повторение

С помощью оператораif вы можете определить путь выполнения ваших программ в зависимости от истинности некоторых условий.

С другой стороны, циклыwhile позволяют повторять фрагмент кода, пока данное условие остается верным.

Эти две структуры являются частью того, что вы бы назвалиcontrol flow statements. Они помогают вам определить путь выполнения ваших программ.

Вы можете использовать оператор Pythonor для построения логических выражений, подходящих для использования как с операторомif, так и с цикламиwhile, как вы увидите в следующих двух разделах.

if Заявления

Допустим, вы хотите убедиться, что одно из двух условий (или оба) выполняется, прежде чем выбрать определенный путь выполнения. В этом случае вы можете использовать оператор Pythonor, чтобы связать условия в одном выражении, и использовать это выражение в оператореif.

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

>>> 

>>> def answer():
...     ans = input('Do you...? (yes/no): ')
...     if ans.lower() == 'yes' or ans.lower() == 'y':
...         print(f'Positive answer: {ans}')
...     elif ans.lower() == 'no' or ans.lower() == 'n':
...         print(f'Negative answer: {ans}')
...
>>> answer()
Do you...? (yes/no): y
Positive answer: y
>>> answer()
Do you...? (yes/no): n
Negative answer: n

Здесь вы получаете ввод пользователя и назначаете егоans. Затем операторif начинает проверку условий слева направо. Если хотя бы один из них оценивается как истина, он выполняет блок кодаif. Операторelif делает то же самое.

При первом вызовеanswer() пользователь ввелy, что удовлетворяет первому условию, и был выполнен блок кодаif. Во втором вызове ввод пользователя (n) удовлетворял второму условию, поэтому блок кодаelif был выполнен. Если пользовательский ввод не удовлетворяет никакому условию, тогда блок кода не выполняется.

Другим примером может служить попытка определить, находится ли число вне диапазона. В этом случае также можно использовать оператор Pythonor. Следующий код проверяет, находится лиx вне диапазона от20 до40:

>>> 

>>> def my_range(x):
...     if x < 20 or x > 40:
...         print('Outside')
...     else:
...         print('Inside')
...
>>> my_range(25)
Inside
>>> my_range(18)
Outside

Когда вы вызываетеmy_range() с помощьюx=25, операторif проверяет25 < 20, то естьFalse. Затем он проверяетx > 40, который также являетсяFalse. Конечный результат -False, поэтому блокelse был выполнен.

С другой стороны,18 < 20 оценивается какTrue. Затем оператор Pythonor выполняет оценку короткого замыкания, и условие считается равнымTrue. Основной блок выполняется, а значение выходит за пределы диапазона.

while Циклы

Циклыwhile - еще один пример логического контекста, в котором вы можете использовать оператор Pythonor. Используяor в заголовке цикла, вы можете проверить несколько условий и запустить тело до тех пор, пока все условия не станут ложными.

Предположим, вам необходимо измерить рабочую температуру некоторого промышленного оборудования, пока оно не достигнет диапазона от 100 до 140 ºF. Для этого вы можете использовать циклwhile: 

from time import sleep

temp = measure_temp()  # Initial temperature measurement

while temp < 100 or temp > 140:
    print('Temperature outside the recommended range')
    print('New Temperature measure in 30 seconds')
    sleep(30)
    print('Measuring Temperature...')
    temp = measure_temp()
    print(f'The new Temperature is {temp} ºF')

Это игрушечный пример почти в псевдокоде, но он иллюстрирует идею. Здесь циклwhile выполняется до тех пор, покаtemp не окажется между 100 ºF и 140 ºF. Если значение температуры выходит за пределы диапазона, то тело цикла запускается, и вы будете снова измерять температуру. Как толькоmeasure_temp() возвращает значение от 100 ºF до 140 ºF, цикл завершается. Измерение температуры выполняется каждые 30 секунд вusing sleep(30).

Note: В предыдущем примере кода вы использовали f-строки Python для форматирования строк, если вы хотите глубже погрузиться в f-строки, вы можете взглянуть наPython 3’s f-Strings: An Improved String Formatting Syntax (Guide).

Небулевы контексты

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

Обратите внимание, что логические операторы (включаяor) оцениваются перед оператором присваивания (=), поэтому вы можете присвоить результат логического выражения переменной так же, как и с обычным выражением :

>>> 

>>> a = 1
>>> b = 2
>>> var1 = a or b
>>> var1
1
>>> a = None
>>> b = 2
>>> var2 = a or b
>>> var2
2
>>> a = []
>>> b = {}
>>> var3 = a or b
>>> var3
{}

Здесь операторor работает, как ожидалось, возвращая первый истинный операнд или последний операнд, если оба были оценены как ложные.

Вы можете воспользоваться этим несколько особенным поведениемor в Python, чтобы реализовать решение Pythonic для некоторых довольно распространенных проблем программирования. Давайте посмотрим на некоторые примеры из реальной жизни.

Значения по умолчанию для переменных

Один из распространенных способов использования оператора Pythonor - выбрать объект из набора объектов в соответствии с его значением истинности. Вы можете сделать это с помощью оператора присваивания:

>>> 

>>> x = a or b or None

Здесь вы присвоилиx первый истинный объект в выражении. Если все объекты (в данном случаеa иb) являются ложными объектами, то оператор Pythonor возвращаетNone, который является последним операндом. Это работает, потому что операторor возвращает один из своих операндов в зависимости от их истинного значения.

Вы также можете использовать эту функцию, чтобы назначить значение по умолчанию для ваших переменных. В следующем примереx устанавливается вa, еслиa истинно, и вdefault в противном случае:

>>> 

>>> x = a or default

В предыдущем коде вы назначаетеax, только еслиa оценивается как истина. В противном случаеx назначаетсяdefault.

Значения по умолчаниюreturn

Вы можете управлять значениемreturn некоторых встроенных функций во время вызова. Такие функции, какmax() иmin(), которые принимают итерацию в качестве аргумента и возвращают единственное значение, могут быть вашим идеальным кандидатом для такого рода взлома.

Если вы предоставите пустую итерацию дляmax() илиmin(), то вы получитеValueError. Однако вы можете изменить это поведение с помощью оператора Pythonor. Давайте посмотрим на следующий код:

>>> 

>>> lst = []  # Empty list to test max() and min()
>>> max(lst)
Traceback (most recent call last):
  File "", line 1, in 
    max(lst)
ValueError: max() arg is an empty sequence
>>> min(lst)
Traceback (most recent call last):
  File "", line 1, in 
    min(lst)
ValueError: min() arg is an empty sequence
>>> # Use Python or operator to modify this behavior
>>> max(lst or [0])  # Return 0
0
>>> min(lst or [0])  # Return 0
0

По умолчаниюmax() иmin() поднимаютValueError, если вы вызываете их с пустой итерацией. Однако, используя оператор Pythonor, вы предоставляете значениеreturn по умолчанию для этих функций и переопределяете их поведение по умолчанию.

Note: В предыдущем примере кода вы видели, как Python вызывает исключения при возникновении некоторых проблем. Если вы хотите узнать больше об исключениях в Python, вы можете взглянуть наIntroduction to Python Exceptions.

Изменяемые аргументы по умолчанию

Обычная проблема, с которой сталкиваются программисты на Python, состоит в том, чтобы пытаться использовать изменяемые объекты в качестве аргументов по умолчанию для функций.

Изменяемые значения аргументов по умолчанию могут сохранять состояние между вызовами. Это часто неожиданно. Это происходит потому, что значения аргументов по умолчанию оцениваются и сохраняются только один раз, то есть при запуске оператораdef, а не при каждом вызове результирующей функции. Вот почему вы должны быть осторожны при изменении изменяемых настроек по умолчанию внутри функций.

Рассмотрим следующий пример:

>>> 

>>> def mutable_default(lst=[]):  # Try to use a mutable value as default
...     lst.append(1)  # Change same object each time
...     print(lst)
...
>>> mutable_default(lst=[3, 2])  # Default not used
[3, 2, 1]
>>> mutable_default()  # Default used
[1]
>>> mutable_default()  # Default grows on each call
[1, 1]
>>> mutable_default()
[1, 1, 1]

Здесь каждый вызовmutable_default() добавляет1 в конецlst, потому чтоlst содержит ссылку на тот же объект (по умолчанию[]). Вы не получите новыйlist каждый раз при вызове функции, как вы ожидали.

Если это не то поведение, которое вам нужно, тогда традиционное (и самое безопасное) решение - переместить значение по умолчанию в тело функции:

>>> 

>>> def mutable_default(lst=None):  # Use None as formal default
...     if lst is None:
...         lst = []  # Default used? Then lst gets a new empty list.
...     lst.append(1)
...     print(lst)
...
>>> mutable_default(lst=[3, 2])  # Default not used
[3, 2, 1]
>>> mutable_default()  # Default used
[1]
>>> mutable_default()
[1]

В этой реализации вы гарантируете, чтоlst будет установлен на пустойlist каждый раз, когда вы вызываетеmutable_default() без аргументов, полагаясь на значение по умолчанию дляlst.

Операторif в этом примере почти можно заменить присваиваниемlst = lst or []. Таким образом, если в функцию не передан аргумент, тогдаlst по умолчанию будетNone, а оператор Pythonor вернет пустой список справа:

>>> 

>>> def mutable_default(lst=None):  # Use None as formal default
...     lst = lst or []  # Default used? Then lst gets an empty list.
...     lst.append(1)
...     print(lst)
...
>>> mutable_default(lst=[3, 2])  # Default not used
[3, 2, 1]
>>> mutable_default()  # Default used
[1]
>>> mutable_default()
[1]

Тем не менее, это не совсем то же самое. Например, если передается пустойlist, то операцияor приведет к тому, что функция изменит и напечатает вновь созданныйlist, вместо того, чтобы изменять и печатать первоначально переданный list, как версияif.

Если вы уверены, что будете использовать только непустые объектыlist, то можете использовать этот подход. В противном случае придерживайтесь версииif.

Нулевой дивизион

Нулевое деление может быть распространенной проблемой, когда вы работаете с числовыми вычислениями. Чтобы избежать этой проблемы, вы, вероятно, в конечном итоге проверите, равен ли знаменатель0 или нет, используя операторif.

Давайте посмотрим на пример:

>>> 

>>> def divide(a, b):
...     if not b == 0:
...         return a / b
...
>>> divide(15, 3)
5.0
>>> divide(0, 3)
0.0
>>> divide(15, 0)

Здесь вы проверили, не равен ли знаменатель (b)0, а затем вернули результат операции деления. Еслиb == 0 оценивается какTrue, тоdivide() неявно возвращаетNone. Давайте посмотрим, как получить аналогичный результат, но на этот раз с помощью оператора Pythonor:

>>> 

>>> def divide(a, b):
...     return b == 0 or a / b
...
>>> divide(15, 3)
5.0
>>> divide(0, 3)
0.0
>>> divide(15, 0)
True

В этом случае оператор Pythonor оценивает первое подвыражение (b == 0). Только если это подвыражениеFalse, оценивается второе подвыражение (a / b), и конечным результатом будет делениеa иb.

Отличие от предыдущего примера в том, что еслиb == 0 оценивается какTrue, тоdivide() возвращаетTrue вместо неявногоNone.

Несколько выражений вlambda

Python предоставляетlambda expressions, которые позволяют создавать простые анонимные функции. Выражениеlambda parameters: expression возвращает объект функции. Этот тип функции может быть полезен, если вы хотите определить простой обратный вызов и ключевые функции.

Наиболее распространенный шаблон для написания функцииlambda - использование одногоexpression в качестве возвращаемого значения. Однако вы можете изменить это и позволитьlambda выполнять несколько выражений с помощью оператора Pythonor:

>>> 

>>> lambda_func = lambda hello, world: print(hello, end=' ') or print(world)
>>> lambda_func('Hello', 'World!')
Hello World!

В этом примере вы заставилиlambda запустить два выражения (print(hello, end=' ') иprint(world)). Но как работает этот код? Что ж, здесьlambda запускает логическое выражение, в котором выполняются две функции.

Когдаor оценивает первую функцию, он получаетNone, которое является неявным возвращаемым значением дляprint(). ПосколькуNone считается ложным,or продолжает вычислять свой второй операнд и, наконец, возвращает его как результат для логического выражения.

В этом случае значение, возвращаемое логическим выражением, также является значением, возвращаемымlambda:

>>> 

>>> result = lambda_func('Hello', 'World!')
Hello World!
>>> print(result)
None

Здесьresult содержит ссылку на значение, возвращаемоеlambda, которое является тем же значением, которое возвращает логическое выражение.

Заключение

Теперь вы знаете, как работает оператор Pythonor, а также как его использовать для решения некоторых распространенных проблем программирования на Python.

Теперь, когда вы знаете основы оператора Pythonor, вы сможете:

  • Используйте оператор Pythonor в логическом и небулевом контекстах

  • Решите несколько проблем программирования, эффективно используя оператор Pythonor

  • Пишите лучше и больше кода Pythonic, пользуясь некоторыми особенностямиor в Python

  • Читать и лучше понимать код других людей, когда они используют оператор Pythonor

Кроме того, вы немного узнали о булевой логике, а также о некоторых ее основных понятиях в Python.

Related