Понимание булевых значений в Python

boolean — это тип данных, который может принимать ровно два значения: True или False. Булевые значения в Python управляют каждым решением, которое принимает ваш код — от операторов if до циклов while и генераторов списков. В этой главе рассматривается, как работают булевые значения, как Python оценивает любое значение как truthy или falsy, а также практические паттерны, которые вы будете использовать каждый день.

Что такое булевые значения в Python?

В Python True и False являются ключевыми словами (с заглавной буквы). Они принадлежат встроенному типу bool, который является подклассом int. Это означает, что True ведёт себя как 1, а False — как 0 в арифметических контекстах.

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

print(True == 1)    # True
print(False == 0)   # True
print(True + True)  # 2  (bool is a subclass of int)

Последняя строка — True + True равно 2 — удивляет многих новичков. Это корректный Python, и иногда полезный (например, для подсчёта количества истинных условий в списке), но использование булевых значений в арифметике должно быть намеренным и чётко прокомментированным.

Создание булевых переменных

Вы можете напрямую присвоить True или False переменной:

Python define boolean variable

По соглашению имена булевых переменных часто начинаются с is_, has_, can_ или should_, чтобы их назначение было понятно с первого взгляда.

Булевые значения из операторов сравнения

Каждый оператор сравнения возвращает булевый результат:

Python compare two integers

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

Использование булевых значений в условных операторах

Булевые значения — это движущая сила решений if/else. Python вычисляет выражение после if и выполняет блок с отступом только тогда, когда результат равен True:

Python compare two integers and print the result

Вы также можете использовать булевую переменную напрямую без какого-либо оператора сравнения:

is_raining = True
if is_raining:
    print("Bring an umbrella")
else:
    print("Enjoy the sunshine")

Использование if is_raining: более питонично, чем if is_raining == True:. Второй вариант не добавляет никакой информации и считается признаком плохого кода.

Значения truthy и falsy

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

Falsy-значения

Следующие значения всегда являются falsy в Python:

Всё остальное является truthy — включая ненулевые числа, непустые строки и непустые коллекции.

# All of these print "empty" because the values are falsy
for value in [0, 0.0, "", [], {}, (), None]:
    if not value:
        print(f"{repr(value)} is falsy")

Truthy-значения на практике

name = input("Enter your name: ")
if name:                   # truthy if name is not an empty string
    print(f"Hello, {name}!")
else:
    print("No name provided.")

items = [1, 2, 3]
if items:                  # truthy if list is not empty
    print(f"Processing {len(items)} items")

Этот паттерн — прямая проверка коллекции вместо len(items) > 0 — является идиоматическим Python.

Преобразование значений в boolean с помощью bool()

Встроенная функция bool() преобразует любое значение в его булевый эквивалент, что удобно, когда вы хотите проверить, является ли что-то truthy или falsy:

Python casting into boolean

Ещё примеры:

print(bool(0))        # False
print(bool(0.0))      # False
print(bool(""))       # False
print(bool([]))       # False
print(bool(None))     # False

print(bool(1))        # True
print(bool(-1))       # True
print(bool("hello"))  # True
print(bool([0]))      # True  — list with one element is truthy

Обратите внимание, что bool([0]) равно True, даже несмотря на то, что единственный элемент внутри является falsy. Python проверяет, пуст ли контейнер, а не значения внутри него.

Логические операторы с булевыми значениями

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

and

Возвращает True только если оба операнда истинны:

print(True and True)   # True
print(True and False)  # False
print(False and True)  # False
print(False and False) # False

or

Возвращает True, если хотя бы один операнд истинен:

print(True or False)   # True
print(False or False)  # False
print(True or True)    # True

not

Инвертирует булевое значение:

print(not True)   # False
print(not False)  # True
print(not 0)      # True  (0 is falsy, so not 0 is True)
print(not "hi")   # False ("hi" is truthy, so not "hi" is False)

Ленивые вычисления

Python вычисляет and и or лениво — он останавливается, как только результат определён. Это называется ленивыми (короткими) вычислениями:

• False and <anything> — Python никогда не вычисляет правую часть, так как результат уже равен False.
• True or <anything> — Python никогда не вычисляет правую часть, так как результат уже равен True.

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

items = []

# Safe: the second condition is only evaluated if items is truthy
if items and items[0] > 10:
    print("First item exceeds 10")

Без ленивых вычислений items[0] на пустом списке вызвал бы IndexError. Поскольку items является falsy (пустой список), Python полностью пропускает правую часть.

Оператор is против == с булевыми значениями

== проверяет, являются ли два значения равными. is проверяет, ссылаются ли два имени на один и тот же объект в памяти.

print(1 == True)   # True  (equal in value)
print(1 is True)   # False (different objects)

Всегда используйте == (или полагайтесь на truthy/falsy) при сравнении значений. Зарезервируйте is для проверок идентичности — чаще всего это is None:

value = None
if value is None:
    print("No value provided")

Использование == None работает, но is None — это идиоматическая и чуть более быстрая форма.

Подсчёт с булевыми значениями

Так как True == 1 и False == 0, вы можете использовать sum() для подсчёта количества элементов в списке, удовлетворяющих условию:

scores = [85, 42, 91, 67, 55, 78]
passed = sum(score >= 60 for score in scores)
print(f"{passed} out of {len(scores)} students passed")
# 4 out of 6 students passed

Это лаконичнее, чем цикл с ручным счётчиком, и является распространённой идиомой Python.

Распространённые ошибки

1. Явное сравнение с True/False

# Avoid
if is_valid == True:
    ...

# Prefer
if is_valid:
    ...

2. Путаница между = (присваивание) и == (равенство)

x = 5
if x = 5:   # SyntaxError — use == for comparison
    print("equal")

3. Предположение, что пустой список внутри списка является falsy

outer = [[]]       # a list containing one empty list
if outer:
    print("truthy")  # This prints! outer has one element.

Внешний список содержит один элемент (внутренний пустой список), поэтому outer сам по себе является truthy. Только внутренний список outer[0] является falsy.

Итоги

• Булевые значения Python — это True и False, всегда с заглавной буквы.
• Каждое значение в Python является либо truthy, либо falsy. К falsy-значениям относятся 0, "", [], {}, () и None.
• Используйте bool() для явного преобразования значения в булевый эквивалент.
• Объединяйте условия с помощью and, or и not. Python вычисляет их лениво по правилам коротких вычислений.
• Используйте is None (не == None) при проверке на None.
• Поскольку bool является подклассом int, True + True равно 2 — удобно для подсчёта.

Далее изучите Операторы Python, чтобы увидеть, как операторы сравнения и логические операторы создают булевые значения, рассмотренные здесь. Также вы можете изучить, как булевые значения управляют потоком программы, в разделе Python If...Else.

Практика