Использование логического оператора "or" в Python

Оглавление

• Логическая логика
• Логические операторы Python
• Как работает Python или оператор
  • Используя логические выражения или с их помощью
  • Использование обычных объектов или с ними
  • Смешивание логических выражений и объектов
  • Оценка короткого замыкания
  • Краткое изложение раздела
• Логические контексты
  • операторы if
  • в то время как циклы
• Небулевы контексты
  • Значения переменных по умолчанию
  • Возвращаемые значения по умолчанию
  • Изменяемые аргументы по умолчанию
  • Нулевое деление
  • Множественные выражения в лямбда-коде
• Заключение

Смотрите сейчас, к этому уроку прилагается соответствующий видеокурс, созданный командой Real Python. Просмотрите его вместе с письменным руководством, чтобы углубить свое понимание: Используя Python или Operator

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

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

• Как работает оператор Python or

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

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

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

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

<отметить класс="marker-highlight">Пройдите тест: Проверьте свои знания с помощью нашего интерактивного теста “Использование логического оператора" или "Логический оператор в Python”. По завершении вы получите оценку, которая поможет вам отслеживать прогресс в обучении:

<время работы/>

Интерактивная викторина

Использование логического оператора "or" в Python

Потренируйтесь использовать python или operator для оценки условий, установки значений по умолчанию и упрощения ветвления. Пройдите краткий тест, чтобы научиться.

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

Джордж Буль (1815-1864) разработал то, что сейчас называется Булевой алгеброй, которая является основой цифровой логики, лежащей в основе компьютерного оборудования и языков программирования.

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

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

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

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

• Логическими значениями являются значения True или False (с заглавной буквы T и F) на Python.

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

• Логическое выражение - это выражение, которое возвращает либо True, либо False.

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

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

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

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

Логические операторы Python

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

1. and
2. or
3. not

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

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

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

Как работает оператор Python or

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

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

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

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

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

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

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

Result of exp1	Result of exp2	Result of exp1 or exp2
True	True	True
True	False	True
False	True	True
False	False	False

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

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

Давайте проиллюстрируем полученные значения истинности, показанные в Таблице 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, должны иметь логические значения, как показано в таблице 1, и возвращать в результате значение истинности. Когда дело доходит до объектов, Python не очень строг в этом отношении и внутренне реализует набор правил, позволяющих решить, считать ли объект истинным или ложным:

По умолчанию объект считается истинным, если только его класс не определяет либо __bool__() метод, который возвращает False или __len__() метод, который возвращает ноль при вызове с объектом. Вот большинство встроенных объектов, которые считаются ложными:

• константы, определенные как ложные: None и False.
• ноль любого числового типа: 0, 0.0, 0j, Decimal(0), Fraction(0, 1)
• пустые последовательности и коллекции: '', (), [], {}, set(), range(0)

( Источник)

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

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

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

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

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

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

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

Left Object	Right Object	Result of x or y
x	y	x, if it evaluates to true, otherwise y.

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

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

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

a or b or c or d

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

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

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

Result of Expression	Result of Object	Result of exp or obj
True	True	True
True	False	True
False	False	obj
False	True	obj

Таблица 3. в Python or оператор поведение, когда объекты тестирования и логические выражения

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

>>> 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

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

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

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

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

>>> True or 4 < 3
True

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

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

>>> 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

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

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

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

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

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

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

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

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

Краткое описание раздела

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

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

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

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

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

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

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

Логические контексты

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

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

1. if инструкции: условное выполнение
2. while циклы: условное повторение

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

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

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

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

if Утверждения

Допустим, вы хотите убедиться, что выполняется одно из двух условий (или оба условия), прежде чем выбрать определенный способ выполнения. В этом случае вы можете использовать оператор Python or, чтобы связать условия в одно выражение, и использовать это выражение в инструкции 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 начинает проверять условия слева направо. Если хотя бы для одного из них вычисляется значение true, то выполняется блок кода if. Оператор elif выполняет то же самое.

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

Другим примером может быть ситуация, когда вы пытаетесь определить, находится ли число за пределами диапазона. В этом случае также можно использовать оператор Python or. Следующий код проверяет, находится ли 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. Затем оператор Python or выполняет вычисление короткого замыкания, и условие считается равным True. Основной блок выполнен, а значение находится за пределами диапазона.

while Циклы

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

Предположим, вам нужно измерить рабочую температуру какого-либо промышленного оборудования до тех пор, пока она не достигнет диапазона от 100°F до 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-140 °F. Если значение температуры выходит за пределы заданного диапазона, запускается основная часть цикла, и вы снова измеряете температуру. Как только measure_temp() возвращает значение в диапазоне от 100°F до 140°F, цикл завершается. Измерение температуры производится каждые 30 секунд с помощью sleep(30).

Примечание: В предыдущем примере кода вы использовали f-строки Python для форматирования строк, если вы хотите глубже разобраться в f-строках, то можете взглянуть на F-строка Python для интерполяции и форматирования строк.

Не логические контексты

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

Обратите внимание, что логические операторы (включая 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 работает так, как ожидалось, возвращая первый операнд true или последний операнд, если значение обоих операндов равно false.

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

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

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

>>> x = a or b or None

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

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

>>> x = a or default

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

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

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

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

>>> lst = []  # Empty list to test max() and min()
>>> max(lst)
Traceback (most recent call last):
  File "<input>", line 1, in <module>
    max(lst)
ValueError: max() arg is an empty sequence
>>> min(lst)
Traceback (most recent call last):
  File "<input>", line 1, in <module>
    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, если вы вызываете их с пустой итерацией. Однако, используя оператор Python or, вы задаете значение по умолчанию return для этих функций и переопределяете их поведение по умолчанию.

Примечание: В предыдущем примере кода вы видели, как Python создает исключения при возникновении некоторых проблем. Если вы хотите узнать больше об исключениях в Python, то можете ознакомиться с Введение в 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, а оператор Python or вернет пустой список справа:

>>> 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. Давайте посмотрим, как получить аналогичный результат, но на этот раз с помощью оператора Python or:

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

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

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

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

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

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

>>> 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, которое является тем же значением, возвращаемым логическим выражением.

Заключение

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

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

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

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

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

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

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

<отметить класс="marker-highlight">Пройдите тест: Проверьте свои знания с помощью нашего интерактивного теста “Использование логического оператора" или "Логический оператор в Python”. По завершении вы получите оценку, которая поможет вам отслеживать прогресс в обучении:

<время работы/>

Интерактивная викторина

Использование логического оператора "or" в Python

Потренируйтесь использовать python или operator для оценки условий, установки значений по умолчанию и упрощения ветвления. Пройдите краткий тест, чтобы научиться.

<статус завершения article-slug="python-or-operator" class="btn-group mb-0" data-api-article-bookmark-url="/api/v1/articles/python-or-operator/bookmark/" данные-api-статья-статус завершения-url="/api/v1/articles/python-or-operator/completion_status/"> <кнопка поделиться bluesky-text="Интересная статья #Python от @realpython.com :" email-body="Проверить эта статья о Python:%0A%0, в которой используется логический оператор "or" в Python' email-subject="Статья о Python для вас" twitter-text="Интересная статья о #Python от @realpython:" url="https://realpython.com/python-or-operator /" url-title='Использование логического оператора "или" в Python'>

Смотрите сейчас, к этому уроку прилагается соответствующий видеокурс, созданный командой Real Python. Просмотрите его вместе с письменным руководством, чтобы углубить свое понимание: Используя Python или Operator

Back to Top