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

Оглавление

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

В этом руководстве вы узнаете, как:

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

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

Работа с логической логикой в Python

В далеком 1854 году Джордж Буль написал "Законы мышления", в котором содержится то, что известно как Булева алгебра. Эта алгебра основана на двух значениях: истина и ложь. Он также определяет набор логических операций, также известных как логические операции, обозначаемых универсальными операторами AND, OR, и NOT.

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

В Python логический тип bool является подклассом int и может принимать значения True или False:

>>> issubclass(bool, int)
True
>>> help(bool)
Help on class bool in module builtins:

class bool(int)
    ...

>>> type(True)
<class 'bool'>
>>> type(False)
<class 'bool'>

>>> isinstance(True, int)
True
>>> isinstance(False, int)
True

>>> int(True)
1
>>> int(False)
0

Как вы можете видеть из этого кода, Python реализует bool как подкласс int с двумя возможными значениями True и False. Эти значения являются встроенными константами в Python. Они внутренне реализованы как целые числа со значением 1 для True и 0 для False. Обратите внимание, что и True, и False должны быть написаны с заглавной буквы.

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

Оператор Логическая операция
and Коньюкция
or Дизньюкция
not Отрицание

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

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

Начало работы с and Оператором Python

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

>>> True and True
True

>>> False and False
False

>>> True and False
False

>>> False and True
False

Эти примеры показывают, что выражение and возвращает True только в том случае, если оба операнда в выражениях равны true. Поскольку оператор and использует два операнда для построения выражения, это бинарный оператор .

Приведенные выше краткие примеры показывают то, что известно как таблица истинности оператора and:

operand1 operand2 operand1 and operand2
True True True
True False False
False False False
False True False

В этой таблице суммируется результирующее значение истинности логического выражения, подобного operand1 and operand2. Результат выражения зависит от значений истинности его операндов. Оно будет истинным, если оба значения равны true. В противном случае оно будет ложным. Такова общая логика, лежащая в основе оператора and. Однако в Python этот оператор может выполнять гораздо больше функций.

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

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

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

Сравнения и проверки на равенство являются типичными примерами выражений такого типа:

>>> 5 == 3 + 2
True
>>> 5 > 3
True
>>> 5 < 3
False
>>> 5 != 3
True

>>> [5, 3] == [5, 3]
True

>>> "hi" == "hello"
False

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

>>> 5 > 3 and 5 == 3 + 2
True

>>> 5 < 3 and 5 == 5
False

>>> 5 == 5 and 5 != 5
False

>>> 5 < 3 and 5 != 5
False

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

expression1 and expression2

Если оба подвыражения expression1 и expression2 равны True, то составное выражение равно True. Если хотя бы одно подвыражение принимает значение False, то результатом будет False.

Количество операторов and, которые вы можете использовать при построении составного выражения, не ограничено. Это означает, что вы можете объединить более двух подвыражений в одно выражение, используя несколько операторов and:

>>> 5 > 3 and 5 == 3 + 2 and 5 != 3
True

>>> 5 < 3 and 5 == 3 and 5 != 3
False

Опять же, если все подвыражения равны True, то вы получите True. В противном случае вы получите False. Особенно по мере того, как выражения становятся длиннее, вам следует иметь в виду, что Python вычисляет выражения последовательно слева направо.

Короткое замыкание при оценке

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

Чтобы определить конечный результат выражения and, Python начинает с вычисления левого операнда. Если он равен false, то все выражение является ложным. В этой ситуации нет необходимости вычислять операнд справа. Python уже знает конечный результат.

Наличие левого операнда false автоматически делает все выражение ложным. Вычисление оставшегося операнда было бы пустой тратой процессорного времени. Python предотвращает это, прерывая вычисление.

В отличие от этого, оператор and вычисляет операнд справа только в том случае, если первый операнд равен true. В этом случае конечный результат зависит от значения истинности правого операнда. Если оно истинно, то все выражение истинно. В противном случае выражение ложно.

Чтобы продемонстрировать функцию защиты от короткого замыкания, взгляните на следующие примеры:

>>> def true_func():
...     print("Running true_func()")
...     return True
...

>>> def false_func():
...     print("Running false_func()")
...     return False
...

>>> true_func() and false_func()  # Case 1
Running true_func()
Running false_func()
False

>>> false_func() and true_func()  # Case 2
Running false_func()
False

>>> false_func() and false_func()  # Case 3
Running false_func()
False

>>> true_func() and true_func()  # Case 4
Running true_func()
Running true_func()
True

Вот как работает этот код:

  • Пример 1: Python вычисляет true_func(), который возвращает True. Чтобы определить конечный результат, Python вычисляет false_func() и получает False. Вы можете убедиться в этом, просмотрев выходные данные обеих функций.
  • Пример 2: Python вычисляет false_func(), который возвращает False. Python уже знает, что конечный результат равен False, поэтому он не вычисляет true_func().
  • Пример 3: Python запускает false_func() и в результате получает False. Ему не нужно оценивать повторяющуюся функцию во второй раз.
  • Пример 4: Python вычисляет true_func() и в результате получает True. Затем он снова вычисляет функцию. Поскольку значение обоих операндов равно True, конечный результат равен True.

Python обрабатывает логические выражения слева направо. Он останавливается, когда ему больше не нужно вычислять какие-либо дополнительные операнды или подвыражения для определения конечного результата. Подводя итог этой концепции, вы должны помнить, что если левый операнд в выражении and равен false, то правый операнд вычисляться не будет.

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

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

Иногда вам может потребоваться избежать отложенного вычисления в определенном логическом выражении. Вы можете сделать это с помощью побитовых операторов (&, |, ~). Эти операторы также работают в логических выражениях, но они быстро вычисляют операнды :

>>> def true_func():
...     print("Running true_func()")
...     return True
...

>>> def false_func():
...     print("Running false_func()")
...     return False
...

>>> # Use logical and
>>> false_func() and true_func()
Running false_func()
False

>>> # Use bitwise and
>>> false_func() & true_func()
Running false_func()
Running true_func()
False

В первом выражении оператор and работает лениво, как и ожидалось. Он вычисляет первую функцию, и поскольку результат равен false, он не вычисляет вторую функцию. Однако во втором выражении побитовый оператор AND (&) вызывает обе функции с готовностью, даже если первая функция возвращает False. Обратите внимание, что в обоих случаях конечный результат равен False.

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

Использование оператора Python and С общими объектами

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

>>> 2 and 3
3

>>> 5 and 0.0
0.0

>>> [] and 3
[]

>>> 0 and {}
0

>>> False and ""
False

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

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

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

( Источник)

Помня об этих правилах, еще раз взгляните на приведенный выше код. В первом примере целое число 2 имеет значение true (отличное от нуля), поэтому and возвращает правильный операнд 3. Во втором примере значение 5 равно true, поэтому and возвращает правильный операнд, даже если его значение равно False.

В следующем примере в качестве левого операнда используется пустой список ([]). Поскольку значение пустых списков равно false, выражение and возвращает пустой список. Единственный случай, когда вы получаете True или False, - это когда вы явно используете логический объект в выражении.

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

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

object1 object2 object1 and object2
False False object1
False True object1
True True object2
True False object2

В общем случае, если операнды в выражении and являются объектами, а не логическими выражениями, то оператор возвращает объект слева, если его значение равно False. В противном случае он возвращает объект справа, даже если его значение равно False.

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

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

>>> 2 < 4 and 2
2
>>> 2 and 2 < 4
True

>>> 2 < 4 and []
[]
>>> [] and 2 < 4
[]

>>> 5 > 10 and {}
False
>>> {} and 5 > 10
{}

>>> 5 > 10 and 4
False
>>> 4 and 5 > 10
False

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

Вот таблица, в которой обобщено поведение оператора and при объединении логических выражений и обычных объектов Python:

expression object expression and object
True True object
True False object
False False False
False True False

Чтобы узнать, что возвращается, Python вычисляет логическое выражение слева, чтобы получить его логическое значение (True или False). Затем Python использует свои внутренние правила для определения истинного значения объекта справа.

В качестве упражнения для проверки вашего понимания вы могли бы попробовать переписать эту таблицу, изменив порядок следования операндов в третьем столбце на object and expression. Попробуйте предсказать, что будет возвращено в каждой строке.

Объединение логических операторов Python

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

Логические операторы Python имеют низкий приоритет по сравнению с другими операторами. Однако иногда полезно использовать пару круглых скобок (()), чтобы обеспечить согласованный и читаемый результат:

>>> 5 or 2 and 2 > 1
5

>>> (5 or 3) and 2 > 1
True

В этих примерах операторы or и and объединены в составное выражение. Как и оператор and, оператор or использует вычисление короткого замыкания. Однако, в отличие от and, оператор or останавливается, как только находит истинный операнд. Вы можете увидеть это в первом примере. Поскольку 5 равно true, подвыражение or немедленно возвращает 5 без вычисления остальной части выражения.

Напротив, если вы заключите подвыражение or в пару круглых скобок, то оно будет работать как единственный истинный операнд, и 2 > 1 также будет вычислено. Конечный результат таков True.

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

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

Как и все логические операторы Python, оператор and особенно полезен в логических контекстах. Логические контексты - это то место, где вы найдете большинство реальных вариантов использования логических операторов.

Две основные структуры определяют логические контексты в Python:

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

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

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

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

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

Условные операторы Python следуют логике условных обозначений в грамматике английского языка. Если условие истинно, то выполняется блок кода if. В противном случае выполнение переходит к другому блоку кода:

>>> a = -8

>>> if a < 0:
...     print("a is negative")
... elif a > 0:
...     print("a is positive")
... else:
...     print("a is equal to 0")
...
a is negative

Поскольку a содержит отрицательное число, условие a < 0 истинно. Запустится блок кода if, и на вашем экране появится сообщение a is negative напечатано. Однако, если вы измените значение a на положительное число, то запустится блок elif и Python напечатает a is positive. Наконец, если вы установите a равным нулю, то будет выполнен блок кода else. Давайте поиграем с a и посмотрим, что произойдет!

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

Запустите свой любимый редактор кода или IDE и создайте следующий скрипт:

# age.py

age = int(input("Enter your age: "))

if age >= 0 and age <= 9:
    print("You are a child!")
elif age > 9 and age <= 18:
    print("You are an adolescent!")
elif age > 18 and age <= 65:
    print("You are an adult!")
elif age > 65:
    print("Golden ages!")

Здесь вы получаете возраст пользователя, используя input(), а затем преобразуете в целое число с помощью int(). Предложение if проверяет, является ли age больше или равно 0. В том же предложении проверяется, является ли age меньше или равно 9. Для этого вы создаете составное логическое выражение and.

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

Если вы запустите этот скрипт из командной строки, то получите что-то вроде этого:

$ python age.py
Enter your age: 25
You are an adult!

В зависимости от возраста, который вы вводите в командной строке, скрипт выполняет те или иные действия. В этом конкретном примере вы указываете возраст в 25 лет и получаете сообщение You are an adult!, напечатанное на вашем экране.

while Циклы

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

Допустим, вы создаете прототип системы управления для производителя. В системе есть важный механизм, который должен работать при давлении 500 фунтов на квадратный дюйм или ниже. Если давление превышает 500 фунтов на квадратный дюйм, оставаясь при этом ниже 700 фунтов на квадратный дюйм, система должна выполнить ряд стандартных мер безопасности. При давлении более 700 фунтов на квадратный дюйм система должна выполнить целый ряд новых мер безопасности.

Чтобы решить эту проблему, вы можете использовать цикл while с выражением and. Вот сценарий, который имитирует возможное решение:

 1# pressure.py
 2
 3from time import sleep
 4from random import randint
 5
 6def control_pressure():
 7    pressure = measure_pressure()
 8    while True:
 9        if pressure <= 500:
10            break
11
12        while pressure > 500 and pressure <= 700:
13            run_standard_safeties()
14            pressure = measure_pressure()
15
16        while pressure > 700:
17            run_critical_safeties()
18            pressure = measure_pressure()
19
20    print("Wow! The system is safe...")
21
22def measure_pressure():
23    pressure = randint(490, 800)
24    print(f"psi={pressure}", end="; ")
25    return pressure
26
27def run_standard_safeties():
28    print("Running standard safeties...")
29    sleep(0.2)
30
31def run_critical_safeties():
32    print("Running critical safeties...")
33    sleep(0.7)
34
35if __name__ == "__main__":
36    control_pressure()

Внутри control_pressure() вы создаете бесконечный цикл while в строке 8. Если система стабильна и давление ниже 500 фунтов на квадратный дюйм, условный оператор прерывает цикл и программа завершается.

В строке 12 первый вложенный while контур выполняет стандартные действия по обеспечению безопасности, пока давление в системе остается в диапазоне от 500 до 700 фунтов на квадратный дюйм. На каждой итерации контур получает новое измерение давления для повторной проверки состояния на следующей итерации. Если давление превышает 700 фунтов на квадратный дюйм, то второй контур на линии 16 выполняет критические действия по обеспечению безопасности.

Примечание: Реализация control_pressure() в приведенном выше примере предназначена для того, чтобы показать, как оператор and может работать в контексте цикла while.

Однако это не самая эффективная реализация, которую вы можете написать. Вы можете реорганизовать control_pressure(), чтобы использовать один цикл без использования and:

def control_pressure():
    while True:
        pressure = measure_pressure()
        if pressure > 700:
            run_critical_safeties()
        elif 500 < pressure <= 700:
            run_standard_safeties()
        elif pressure <= 500:
            break
    print("Wow! The system is safe...")

В этой альтернативной реализации вместо использования and используется цепочечное выражение 500 < pressure <= 700, которое выполняет те же функции, что и pressure > 500 and pressure <= 700, но является более понятным и более питоническим. Еще одним преимуществом является то, что вы вызываете measure_pressure() только один раз, что в конечном итоге оказывается более эффективным.

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

$ python pressure.py
psi=756; Running critical safeties...
psi=574; Running standard safeties...
psi=723; Running critical safeties...
psi=552; Running standard safeties...
psi=500; Wow! The system is safe...

Результат на вашем экране должен немного отличаться от этого примера, но вы все равно сможете получить представление о том, как работает приложение.

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

Тот факт, что and может возвращать объекты не только True и False, является интересной особенностью. Например, эта функция позволяет вам использовать оператор and для условного выполнения. Допустим, вам нужно обновить переменную flag, если первый элемент в данном списке равен определенному ожидаемому значению. В этой ситуации вы можете использовать условный оператор:

>>> a_list = ["expected value", "other value"]
>>> flag = False

>>> if len(a_list) > 0 and a_list[0] == "expected value":
...     flag = True
...

>>> flag
True

Здесь условие проверяет, есть ли в списке хотя бы один элемент. Если да, то оно проверяет, соответствует ли первый элемент в списке строке "expected value". Если обе проверки пройдены, то flag изменяется на True. Вы можете упростить этот код, воспользовавшись оператором and:

>>> a_list = ["expected value", "other value"]
>>> flag = False

>>> flag = len(a_list) > 0 and a_list[0] == "expected value"

>>> flag
True

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

Код в приведенном выше примере более лаконичен, чем эквивалентный условный оператор, который вы видели ранее, но он менее удобочитаем. Чтобы правильно понять это выражение, вам нужно знать, как работает оператор and.

Приведение в действие оператора Python and

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

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

Сглаживание вложенных if Инструкций

Один из принципов “Дзен Питона” гласит, что "Плоский язык лучше вложенного". Например, в то время как код, содержащий два уровня вложенных инструкций if, является нормальным и абсолютно приемлемым, ваш код действительно начинает выглядеть беспорядочным и сложным, когда у вас более двух уровней вложенности.

Допустим, вам нужно проверить, является ли данное число положительным. Затем, как только вы подтвердите, что оно положительное, вам нужно проверить, не меньше ли это число заданного положительного значения. Если это так, вы можете приступить к конкретному расчету, используя имеющееся под рукой число:

>>> number = 7

>>> if number > 0:
...     if number < 10:
...         # Do some calculation with number...
...         print("Calculation done!")
...
Calculation done!

Круто! Эти два вложенных утверждения if решают вашу проблему. Сначала вы проверяете, положительное ли число, а затем проверяете, не меньше ли оно 10. В этом небольшом примере вызов print() является заполнителем для вашего конкретного вычисления, которое выполняется только при выполнении обоих условий.

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

>>> number = 7

>>> if number > 0 and number < 10:
...     # Do some calculation with number...
...     print("Calculation done!")
...
Calculation done!

Логические операторы, такие как оператор and, часто предоставляют эффективный способ улучшить ваш код, удаляя вложенные условные операторы. Используйте их по возможности.

В этом конкретном примере вы используете and для создания составного выражения, которое проверяет, находится ли число в заданном диапазоне или интервале. Python предоставляет еще лучший способ выполнить эту проверку, объединяя выражения в цепочки. Например, вы можете записать приведенное выше условие как 0 < number < 10. Это тема для следующего раздела.

Проверка числовых диапазонов

Внимательно рассмотрев пример в разделе ниже, вы можете сделать вывод, что оператор and в Python является удобным инструментом для проверки того, находится ли конкретное числовое значение внутри заданного интервала или диапазона. Например, следующие выражения проверяют, находится ли число x между 0 и 10 включительно:

>>> x = 5
>>> x >= 0 and x <= 10
True

>>> x = 20
>>> x >= 0 and x <= 10
False

В первом выражении оператор and сначала проверяет, является ли x больше или равно 0. Поскольку условие истинно, оператор and проверяет, меньше ли значение x или равно 10. Конечный результат является истинным, поскольку второе условие также истинно. Это означает, что число находится в пределах желаемого интервала.

Во втором примере первое условие истинно, а второе ложно. Общий результат равен false, что означает, что число не находится в целевом интервале.

Вы можете поместить эту логику в функцию и использовать ее повторно:

>>> def is_between(number, start=0, end=10):
...     return number >= start and number <= end
...

>>> is_between(5)
True
>>> is_between(20)
False

>>> is_between(20, 10, 40)
True

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

Ваша функция is_between() возвращает результат вычисления выражения and, которое проверяет, находится ли значение number между start и end, включительно.

Примечание: Непреднамеренное написание and выражений, которые всегда возвращают False, является распространенной ошибкой. Предположим, вы хотите написать выражение, которое исключает значения между 0 и 10 из данного вычисления.

Чтобы достичь этого результата, вы начинаете с двух логических выражений:

  1. number < 0
  2. number > 10

Взяв за отправную точку эти два выражения, вы можете использовать and, чтобы объединить их в одно составное выражение. Однако ни одно число не может быть меньше 0 и больше 10 одновременно, поэтому в итоге вы получаете всегда ложное условие:

>>> for number in range(-100, 100):
...     included = number < 0 and number > 10
...     print(f"Is {number} included?", included)
...
Is -100 included? False
Is -99 included? False

...

Is 0 included? False
Is 1 included? False

...

Is 98 included? False
Is 99 included? False

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

Несмотря на то, что использование оператора and позволяет вам корректно проверить, находится ли число в пределах заданного интервала, существует более понятный метод решения той же задачи на языке Python. В математике вы можете написать 0 < x < 10, чтобы обозначить, что x находится между 0 и 10.

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

>>> x = 5
>>> 0 < x < 10
True

>>> x = 20
>>> 0 < x < 10
False

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

Python внутренне переписывает выражение этого типа в эквивалентное and выражение, такое как x > 0 and x < 10. Затем он выполняет фактическую оценку. Вот почему вы получаете правильный результат в приведенном выше примере.

Точно так же, как вы можете связать несколько подвыражений с несколькими операторами and, вы также можете связать их без явного использования каких-либо операторов and:

>>> x = 5
>>> y = 15

>>> 0 < x < 10 < y < 20
True

>>> # Equivalent and expression
>>> 0 < x and x < 10 and 10 < y and y < 20
True

Вы также можете использовать этот трюк на Python, чтобы проверить, равны ли несколько значений:

>>> x = 10
>>> y = 10
>>> z = 10

>>> x == y == z
True

>>> # Equivalent and expression
>>> x == y and y == z
True

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

Объединение функций в цепочку Вызывает условные вызовы

Если вы когда-либо работали с Bash в системе Unix, то вы, вероятно, знаете о command1 && command2 конструировать. Это удобный прием, позволяющий выполнять несколько команд в цепочке. Каждая команда выполняется тогда и только тогда, когда предыдущая команда была успешной:

$ cd /not_a_dir && echo "Success"
bash: cd: /not_a_dir: No such file or directory

$ cd /home && echo "Success"
Success

В этих примерах используется оператор Bash short-circuit AND (&&), чтобы сделать выполнение команды echo зависимым от успешного выполнения команды cd.

Поскольку and в Python также реализована идея отложенного вычисления, вы можете использовать его для эмуляции этого трюка с Bash. Например, вы можете связать ряд вызовов функций в одно выражение and следующим образом:

func1() and func2() and func3() ... and funcN()

В этом случае Python вызывает func1(). Если возвращаемое функцией значение равно true, то Python вызывает func2() и так далее. Если одна из функций возвращает значение false, то Python не будет вызывать остальные функции.

Вот пример, в котором используются некоторые функции pathlib для управления текстовым файлом:

>>> from pathlib import Path
>>> file = Path("hello.txt")
>>> file.touch()

>>> # Use a regular if statement
>>> if file.exists():
...     file.write_text("Hello!")
...     file.read_text()
...
6
'Hello!'

>>> # Use an and expression
>>> file.exists() and file.write_text("Hello!") and file.read_text()
'Hello!'

Отлично! В одной строке кода вы выполняете три функции условно, не прибегая к инструкции if. В данном конкретном примере единственное видимое отличие заключается в том, что .write_text() возвращает количество байт, записанных в файл. Интерактивная оболочка автоматически отображает это значение на экране. Имейте в виду, что эта разница не видна, когда вы запускаете код в виде сценария.

Заключение

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

В этом руководстве вы узнали, как:

  • Работать с Python это and оператор
  • Построение логических и небулевых выражений с помощью оператора Python and
  • Определите порядок действий ваших программ, используя оператор and в логических контекстах
  • Сделайте свой код более кратким, используя оператор and в не логических контекстах

Ознакомление с практическими примерами в этом руководстве поможет вам получить общее представление о том, как использовать оператор and для принятия решений в вашем коде на Python.

Back to Top