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

К этому моменту вы уже работали с числами int и float, присваивали значения переменным и выводили результаты через print(). Все эти операции производили конкретные значения — числа или строки. Теперь появляется ещё один тип данных, который возникает каждый раз, когда Python отвечает на вопрос «это так?» — и ответ всегда один из двух.

Тип bool и значение None

В Python есть специальный тип данных для хранения логических значений — bool. У него ровно два возможных значения: True (истина) и False (ложь). Оба пишутся с заглавной буквы — это принципиально: true или TRUE Python не поймёт.

flag = True
print(flag)   # True

flag = False
print(flag)   # False

Значения True и False — не строки и не числа. Это отдельный тип данных, который Python использует там, где нужно ответить «да» или «нет». В следующих секциях вы увидите, как они возникают из сравнений.

None — обозначение отсутствия значения

Отдельно стоит познакомиться со значением None. Оно означает «значения нет» — не ноль, не пустая строка, а именно отсутствие какого-либо результата.

result = None
print(result)   # None

None — самостоятельный объект, не равный ни False, ни 0, ни пустой строке. Путать его с ними не стоит: это просто способ сказать «здесь пока ничего нет».

С None вы будете встречаться позже — например, когда функция не возвращает явного значения. Пока достаточно знать, что такой объект существует и что он означает.

Операторы сравнения и логическое выражение

Теперь, когда понятно, что такое True и False, нужно разобраться, откуда они берутся в реальном коде. Чаще всего — из сравнений.

Python предоставляет шесть операторов сравнения:

• == — равно
• != — не равно
• < — меньше
• > — больше
• <= — меньше или равно
• >= — больше или равно

Каждый из них берёт два значения, сравнивает их и возвращает True или False. Именно возвращает — результат сравнения можно сохранить в переменную, вывести через print() или использовать дальше.

age = 20
print(age == 20)   # True
print(age != 18)   # True
print(age < 18)    # False
print(age >= 18)   # True

В каждой строке Python вычисляет выражение внутри print() и получает bool. Это и есть логическое выражение — любое выражение, результатом которого является True или False. Сравнение — самый простой способ его получить.

Операторы сравнения работают не только с числами. Строки тоже сравниваются — по алфавитному порядку:

print("apple" == "apple")   # True
print("banana" > "apple")   # True  ("b" идёт после "a")

Ошибка, которую делают почти все в начале: = вместо ==

Знак = в Python — это присваивание. Он записывает значение в переменную и не возвращает bool. Знак == — это сравнение, которое возвращает True или False.

Сравните две строки:

x = 5          # записали число 5 в переменную x
print(x == 5)  # сравнили x с числом 5 и получили True

Запомните разделение: = присваивает, а == проверяет равенство. Результат сравнения можно сохранить в переменную или сразу вывести.

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

Логические операторы and, or, not

Одиночное сравнение возвращает True или False, но часто нужно проверить сразу несколько условий одновременно. Для этого в Python есть три логических оператора: and, or и not.

and возвращает True, только если оба операнда истинны. Если хотя бы один ложный — результат False.

or возвращает True, если истинен хотя бы один из операндов. Ложный результат только тогда, когда оба ложные.

not работает с одним операндом и инвертирует его: not True даёт False, not False — True.

age = 20
print(age >= 18 and age < 65)   # True — возраст между 18 и 64
print(age < 18 or age >= 65)    # False — ни одно из условий не выполнено
print(not age == 20)            # False — age == 20 даёт True, not инвертирует

Приоритет операторов

Когда в одном выражении встречаются несколько логических операторов, Python применяет их в определённом порядке: сначала not, потом and, потом or.

result = True or False and False
# and выполняется первым: False and False → False
# затем or: True or False → True
print(result)  # True

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

age = 20
score = 85
print((age >= 18) and (score >= 80))  # True

Правило простое: если сомневаетесь в порядке вычисления — расставьте скобки явно.

Процедура построения логических выражений на практике

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

Предположим, нужно проверить, что пользователю можно смотреть фильм с возрастным ограничением 18+, и при этом он купил билет. Есть две переменные: age и has_ticket. Нужно получить True или False.

Шаг 1. Определить, что сравниваем

Возраст сравниваем с числом 18. Наличие билета — само по себе логическое значение (True/False), сравнивать его ни с чем не нужно.

Шаг 2. Выбрать операторы сравнения

Для возраста подходит >=: нужно проверить, что age >= 18.

Шаг 3. Объединить через логический оператор

Оба условия должны выполняться одновременно — значит, используем and.

Шаг 4. Сохранить или вывести результат

age = 20
has_ticket = True

can_watch = age >= 18 and has_ticket
print(can_watch)  # True

Python вычисляет age >= 18 — получает True. Затем проверяет has_ticket — тоже True. and двух истинных значений даёт True. Результат сохраняется в can_watch.

Теперь поменяем условия:

age = 15
has_ticket = True

can_watch = age >= 18 and has_ticket
print(can_watch)  # False

Здесь age >= 18 возвращает False. Выражение False and True даёт False.

Ещё один сценарий: инверсия через not

Допустим, нужно проверить, что пользователь не является администратором:

is_admin = False
print(not is_admin)  # True

Или объединить несколько условий с or — например, скидка действует для студентов или пенсионеров:

age = 67
is_student = False

has_discount = is_student or age >= 65
print(has_discount)  # True

Здесь is_student — False, но age >= 65 — True. or возвращает True, потому что хотя бы один операнд истинен.

Общая схема всегда одна и та же: выбрать значения → выбрать операторы сравнения → при необходимости объединить через and/or или инвертировать через not → получить bool. Всё, что получается на выходе, можно сохранить в переменную и использовать позже — именно это и произойдёт в уроке про if/else.