Прошлый урок научил программу разговаривать с человеком: input() принимал числа и слова с клавиатуры, print() печатал ответ на экране. Однако программа, которая только слушает и отвечает, пока напоминает эхо. Настоящая сила появляется тогда, когда код сам решает, что напечатать, глядя на введённые числа и строки. За выбор отвечает связка if, elif и else вместе с операторами сравнения. Урок седьмой раскладывает её по полочкам, от самой простой проверки до тернарного оператора, а в следующем уроке эти знания начнут работать на цикл while, который повторяет блок кода, пока его условие остаётся истинным.

Синтаксис if с отступами и двоеточием

Любое условие в Python строится по одной схеме. Сначала пишется слово if, затем выражение, которое интерпретатор вычисляет в значение True или False, в конце строки ставится двоеточие, а на следующей строке с отступом в четыре пробела записывается код, который выполняется при истинной проверке. Круглые скобки вокруг условия не нужны, а фигурные скобки, отмечающие блок в других языках, здесь вообще отсутствуют. Вместо них группировку берут на себя отступы, и это не украшение, а полноправная часть синтаксиса.

Простой пример возвращает к прошлому уроку: число приходит из input(), превращается функцией int() в целое и попадает под проверку.

age = int(input("Сколько тебе лет? "))
if age >= 18:
    print("Взрослый")
    print("Можно заходить")
print("Эта строка вне блока, она выполняется всегда")

Две строки с отступом принадлежат блоку if и срабатывают только при возрасте от восемнадцати. Последняя строка прижата к левому краю, значит она вне блока и выполняется при любом раскладе. Именно так Python понимает, где заканчивается условный блок: отступы здесь заменяют и скобки, и лишние служебные слова.

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

| Оператор | Пример | Результат |
| --- | --- | --- |
| == | 5 == 5 | True, значения равны |
| != | 5 != 3 | True, значения не равны |
| > | 7 > 2 | True, левое число больше |
| < | 7 < 2 | False, левое число меньше |
| >= | 5 >= 5 | True, больше или равно |
| <= | 4 <= 5 | True, меньше или равно |

Проверку удобно испытывать и без всякого if: строка print(5 > 3) выведет True, а print(2 == 7) выведет False. Так операторы изучают по отдельности, подставляя разные числа и глядя на ответ интерпретатора. В настоящем коде результат сравнения почти всегда сразу попадает в заголовок условия, но привычка проверять выражения напрямую экономит время при отладке.

Пара правил оформления сбережёт нервы. Отступ делают ровно четырьмя пробелами, и это требование закреплено в стилистическом стандарте PEP 8. Смешивать пробелы с табуляцией нельзя: интерпретатор замечает разнобой и останавливает программу с сообщением TabError: inconsistent use of tabs and spaces in indentation. Забытое двоеточие в конце заголовка тоже даёт SyntaxError: expected ':', причём каретка в сообщении честно указывает на проблемное место.

Ветка else и проверка чётности через %

Ветка else ловит все случаи, которые не подошли условию if. Собственного выражения у неё нет, только слово и двоеточие, а стоит она всегда последней в конструкции. Срабатывает максимум одна ветка: либо if, либо else, и третьего варианта в такой паре не существует.

Классическая задача на else и оператор % выглядит так:

number = int(input("Введите целое число: "))
if number % 2 == 0:
    print("Число чётное")
else:
    print("Число нечётное")

Знак процента в Python не имеет отношения к бытовым процентам. Он берёт остаток от деления. Число 10 при делении на 2 даёт остаток 0, поэтому попадает в первую ветку. У числа 7 остаток равен 1, и оно уходит в else. Отсюда универсальный приём: нулевой остаток от деления на два безошибочно указывает чётное число. Тот же оператор проверяет кратность, например запись number % 3 == 0 отбирает числа, делящиеся на три нацело, как 3 и 9, но не 4 и 10. Попытка приписать else собственное условие в скобках закончится SyntaxError, ведь ветка ловит всё остальное автоматически, и уточнять ей нечего.

Цепочка elif на примере оценок

Слово elif сокращает сочетание else if и позволяет выстроить несколько проверок подряд. Количество веток не ограничено, а else в конце остаётся необязательным запасным выходом. Разберём превращение тестового балла в оценку:

score = int(input("Балл за тест от 0 до 100: "))
if score >= 90:
    print("Отлично")
elif score >= 75:
    print("Хорошо")
elif score >= 60:
    print("Удовлетворительно")
else:
    print("Нужно готовиться лучше")

Программа читает цепочку строго по порядку:

  1. Сначала проверяется верхний if, и если балл не дотянул до девяноста, интерпретатор спускается к первой ветке elif;
  2. Дальше проверки идут по очереди, пока одна из них не окажется истинной;
  3. Как только блок сработал, все остальные ветки пропускаются, даже если их условия тоже истинны;
  4. Когда ни одна проверка не прошла, исполняется ветка else, а при её отсутствии программа не печатает ничего.

Из этого поведения вытекает практический вывод: порядок веток определяет результат. Если поставить проверку score >= 60 выше остальных, отличник с баллом девяносто пять получит слабую оценку, ведь его балл пройдёт по первой же подошедшей категории. Общее правило звучит просто: сверху вниз располагают условия от строгих к мягким. Кстати, else в конце цепочки не обязателен, и программа без него просто молчит, когда ни одно условие не подошло.

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

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

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

| Левая часть | Правая часть | Результат |
| --- | --- | --- |
| True | True | True |
| True | False | False |
| False | True | False |
| False | False | False |

Оператор or мягче: ему хватает хотя бы одной истинной стороны:

| Левая часть | Правая часть | Результат |
| --- | --- | --- |
| True | True | True |
| True | False | True |
| False | True | True |
| False | False | False |

Оператор not переворачивает значение на противоположное: not True даёт False, а not False даёт True.

Примеры вживую:

age = 16
has_ticket = True
if age >= 12 and has_ticket:
    print("Вход на сеанс открыт")

day = "воскресенье"
if day == "суббота" or day == "воскресенье":
    print("Выходной")

is_raining = False
if not is_raining:
    print("Зонт можно оставить дома")

Две проверки легко соединяются в один фильтр:

number = int(input("Введите число от 1 до 100: "))
if number >= 1 and number <= 100:
    print("Число попадает в диапазон")
else:
    print("Число вне диапазона")

Число здесь обязано пройти обе границы сразу, и только тогда сработает первая ветка. Тот же смысл несёт запись 1 <= number <= 100, так что выбирайте форму, которая читается легче.

У операторов есть порядок силы: not срабатывает раньше and, а and раньше or. Когда остаются сомнения, скобки расставляют приоритеты явно, и читать такое условие заметно легче. Ещё одна приятная мелочь: границы значения проверяются математической записью вида 0 <= score <= 100, которая в Python работает без дополнительных логических операторов и при 55 возвращает True, а при минус трёх даёт False.

У Python есть скрытая привычка, о которой полезно узнать сразу. В условии он трактует число ноль, пустую строку и пустой список как ложь, а любое ненулевое число и непустую строку как истину. Поэтому запись if name: сработает, когда пользователь ввёл хотя бы один символ, и проследует мимо блока при пустом вводе. Механизм удобный, но на первых порах надёжнее писать полное сравнение name != "": мысль остаётся прозрачной даже через месяц без практики.

Вложенные условия и когда их лучше избегать

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

age = int(input("Возраст: "))
if age >= 18:
    ticket = input("Билет есть? Введи да или нет: ")
    if ticket == "да":
        print("Проходите в зал")
    else:
        print("Сначала купите билет")
else:
    print("Вход только с восемнадцати лет")

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

if age >= 18 and ticket == "да":
    print("Проходите в зал")

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

Сравнение строк и ошибка со знаком равно

Строки сравниваются теми же операторами, что и числа. Равенство проверяет посимвольное совпадение, и регистр здесь критичен: строки "Python" и "python" различаются, потому что заглавная и строчная буквы имеют разные коды в таблице символов. При проверке порядка Python опирается на те же коды, где заглавные буквы стоят раньше строчных, поэтому выражение "Z" < "a" возвращает True.

Один нюанс бьёт новичков регулярно. Функция input() всегда возвращает строку, поэтому введённая с клавиатуры пятёрка равна строке "5", а не числу 5. Сравнение "5" == 5 вернёт False, ведь слева строка, а справа число. Отсюда привычка из прошлых уроков: перед числовыми сравнениями ввод пропускают через int(). Для строковых проверок преобразование не нужно, например проверка имени работает прямо:

name = input("Как тебя зовут? ")
if name == "Аня":
    print("Привет, Аня!")
else:
    print("Рад знакомству,", name)

Оператор неравенства не менее полезен, он отбирает всё, что не совпало с образцом:

answer = input("Продолжить? да или нет: ")
if answer != "да":
    print("Работа программы заканчивается")

Проблему регистра снимает метод lower(), переводящий строку в нижний регистр. Запись name.lower() == "аня" сработает и для Ани, и для АНЯ, потому что сравниваются уже приведённые значения. Сравнивать можно не только сырые значения, но и результаты методов, и этот приём часто спасает формы проверки паролей и кодовых слов.

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

age = 18
if age = 18:
    print("Ровно восемнадцать")

Запуск оборачивается сообщением SyntaxError: invalid syntax. Maybe you meant '==' or ':=' instead of '='? И это приятное сообщение: интерпретатор сам догадался о намерении и прямо намекнул на исправление. Внутри тела блока одиночный знак = остаётся законным присваиванием, ошибка возникает именно в заголовке условия, где интерпретатор ждёт сравнение, а не сохранение значения.

Тернарный оператор и краткая форма if

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

age = 20
status = "взрослый" if age >= 18 else "ребёнок"
print(status)

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

a = int(input("Первое число: "))
b = int(input("Второе число: "))
biggest = a if a > b else b
print("Больше", biggest)

Тернарный оператор не обязан сохранять результат в переменную: его можно положить прямо внутрь print() и получить готовый текст на экране.

age = 15
print("Билет детский" if age < 18 else "Билет взрослый")

Тернарная форма хороша в коротких решениях, где хочется вставить слово в зависимости от условия. Вкладывать тернарные операторы друг в друга не советуют: одна строка с тремя вложенными проверками читается хуже полного if с отступами.

На этом арсенал принятия решений собран полностью. if, elif и else выбирают путь, операторы сравнения формулируют проверку, and, or и not объединяют несколько условий в одно, тернарный оператор сжимает простые развилки. Впереди цикл while, который будет повторять блок кода, пока его условие остаётся истинным, и теперь написать заголовок такого цикла сможет каждый, кто дочитал этот урок до конца.