and, or, not в Python: логические операторы, короткое замыкание и истинность

Три слова вместо символов

Логические операторы Python это английские слова and, or и not. В других языках они пишутся как &&, || и !. В Python && и || дают SyntaxError, а ! встречается только в составе != («не равно»).

has_ticket = True
is_adult = False

print(has_ticket and is_adult)   # False: both must be true
print(has_ticket or is_adult)    # True: at least one is true
print(not is_adult)              # True: flips the value

С True и False правила такие, каких ты и ждёшь:

and требует, чтобы истинными были обе стороны. or требует хотя бы одну. not принимает одно значение и инвертирует его.

В реальном коде сторонами обычно служат сравнения, а результат идёт в if или while:

age = 34
country = "CA"

if age >= 18 and country in ("US", "CA"):
    print("eligible")

if age < 13 or age > 65:
    print("discounted ticket")
else:
    print("standard ticket")

Вывод:

eligible
standard ticket

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

Truthy и falsy значения

and, or и not принимают любые значения, а не только булевы. Считать ли значение истинным, Python решает по его истинности (truthiness). Эти значения falsy:

• False и None
• ноль любого числового типа: 0, 0.0
• пустые контейнеры и строки: "", [], (), {}, set(), range(0)

Всё остальное truthy, в том числе "0", "False", [0] и -1. Как Python классифицирует значение, можно увидеть через bool():

for value in [0, 1, -1, "", "0", [], [0], None, 0.0]:
    print(repr(value), bool(value))

Вывод:

0 False
1 True
-1 True
'' False
'0' True
[] False
[0] True
None False
0.0 False

Строка "0" truthy, потому что это непустая строка. На этом попадаются те, кто читает числа из ввода и проверяет их до преобразования. Как bool связан с int, разобрано на странице про числа и булевы значения.

and и or возвращают операнд

Здесь Python отличается от большинства языков. and и or не создают новый True или False. Они возвращают одно из двух значений, которые ты им передал:

• x or y возвращает x, если x truthy, иначе возвращает y.
• x and y возвращает x, если x falsy, иначе возвращает y.

print(0 or 5)            # 5
print(3 or 5)            # 3
print("" or "guest")     # guest
print([] or None)        # None

print(0 and 5)           # 0
print(3 and 5)           # 5
print("a" and "b")       # b
print(None and 1 / 0)    # None, and no ZeroDivisionError

Когда оба операнда булевы, «вернуть операнд» и «вернуть булево значение» означают одно и то же, поэтому разницу не замечают, пока не подмешают другие типы.

not составляет исключение: он всегда возвращает True или False.

print(not 0)        # True
print(not "hi")     # False
print(not [])       # True

Если из выражения с and/or нужно настоящее булево значение, например чтобы сохранить его или вернуть из функции, которая обещает bool, оберни его в bool():

name = "Ada"
email = ""

print(name and email)         # prints an empty line: the value is ""
print(bool(name and email))   # False

Вычисление по короткой схеме

Python вычисляет and и or слева направо и останавливается, как только ответ известен:

• and останавливается на первом falsy значении, потому что ничто после него уже не сделает всё выражение истинным.
• or останавливается на первом truthy значении, потому что ничто после него уже не сделает всё выражение ложным.

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

def check(label, result):
    print(f"  checking {label}")
    return result

print("and:")
print(check("A", False) and check("B", True))

print("or:")
print(check("A", True) or check("B", False))

Вывод:

and:
  checking A
False
or:
  checking A
True

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

user = None
items = []

if user is not None and user.startswith("admin"):
    print("admin")
else:
    print("not an admin")

if items and items[0] > 10:
    print("first item is large")
else:
    print("no large first item")

Ставь дешёвую или защитную проверку первой. Если поменять порядок, user.startswith("admin") and user is not None выбросит AttributeError, когда user равен None.

Приёмы на основе or и and

Поскольку or возвращает свой первый truthy операнд, он даёт значение по умолчанию в одну строку:

def greet(name):
    name = name or "guest"
    print(f"Hello, {name}!")

greet("Ada")
greet("")
greet(None)

Вывод:

Hello, Ada!
Hello, guest!
Hello, guest!

Подвох в том, что or заменяет любое falsy значение, а не только None. Если 0, "" или [] допустимый ввод, or его выбросит:

volume = 0
print(volume or 50)                           # 50: the 0 was replaced

print(volume if volume is not None else 50)   # 0: only None is replaced

Используй x if x is not None else default, когда ноль или пустое значение допустимы. Это условное выражение разобрано на странице про if/else.

У and есть парный приём: «используй это значение, только если первое задано». Он встречается реже и часто понятнее в виде if, так что прибегай к нему нечасто:

user = {"name": "Ada"}
print(user and user["name"])   # Ada

user = None
print(user and user["name"])   # None

Приоритет: not, затем and, затем or

Когда выражение смешивает все три оператора, Python применяет сначала not, затем and, затем or. Сравнения вроде ==, < и in применяются раньше любого из них.

a, b, c = True, False, False

print(a or b and c)      # True: read as a or (b and c)
print((a or b) and c)    # False
print(not a or b)        # False: read as (not a) or b
print(not (a or b))      # False
print(not 1 == 2)        # True: read as not (1 == 2)

a or b and c и (a or b) and c дают разные ответы на одних и тех же значениях, поэтому смешанное условие стоит снабжать скобками, даже если порядок по умолчанию оказался правильным. Скобки ничего не стоят и снимают вопрос у следующего читателя.

and/or против &/|

& и | похожи на and и or и иногда дают тот же ответ, но это разные операторы.

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

print(6 and 3)   # 3: 6 is truthy, so and returns the second operand
print(6 & 3)     # 2: 110 & 011 = 010 in binary

print(6 or 3)    # 6
print(6 | 3)     # 7: 110 | 011 = 111

print({1, 2, 3} & {2, 3, 4})   # {2, 3}
print(True & False)             # False

У побитовых операторов к тому же приоритет выше, чем у сравнений, и условие, записанное через &, превращается в нечто совсем другое:

x, y = 5, 5

print(x > 1 and y > 1)     # True
print(x > 1 & y > 1)       # False: read as x > (1 & y) > 1
print((x > 1) & (y > 1))   # True, but the parentheses are required

1 & y это 1 & 5, то есть 1, поэтому средняя строка превращается в цепочку 5 > 1 > 1, а 1 > 1 ложно. В обычном коде на Python для условий используй and, or и not.

Единственное место, где &, | и ~ правильны для условий, это NumPy и pandas. Массив содержит много значений, поэтому у него нет единого значения истинности, и and выбрасывает ValueError: The truth value of an array ... is ambiguous. Библиотеки перегружают & и |, чтобы они работали поэлементно, поэтому фильтры в pandas выглядят как df[(df.age > 18) & (df.country == "CA")], со скобками вокруг каждого сравнения по той же причине приоритета.

any() и all(): and и or по списку

Чтобы объединить целую последовательность условий, используй встроенные функции all() (and по всем элементам) и any() (or по всем элементам). Обе вычисляются по короткой схеме точно так же:

scores = [72, 88, 95, 61]

print(all(s >= 60 for s in scores))   # True: every score passed
print(any(s >= 90 for s in scores))   # True: at least one A
print(any(s < 50 for s in scores))    # False

print(all([]))   # True: nothing failed
print(any([]))   # False: nothing passed

В отличие от and и or, any() и all() всегда возвращают булево значение.

Частые ошибки

Сравнение одной переменной с несколькими значениями через or. Это условие всегда истинно:

color = "green"

if color == "red" or "blue":
    print("matched (wrong!)")

if color == "red" or color == "blue":
    print("matched")
else:
    print("no match")

if color in ("red", "blue"):
    print("matched")
else:
    print("no match")

Python читает первое условие как (color == "red") or "blue". Сравнение даёт False, поэтому or возвращает "blue", непустую строку, а она truthy. Повтори сравнение с обеих сторон или, что лучше, проверь вхождение через in.

Запись && или ||. Оба дают SyntaxError. Используй and и or.

Ожидание булева значения от and/or. x = a or b сохраняет сам a или сам b. Часто это то, что нужно, но если функция должна вернуть True или False, преобразуй результат через bool().

Надежда на приоритет в смешанных условиях. a or b and c допустимо и однозначно определено, но добавь скобки, чтобы никому не пришлось вспоминать правило.