Множественное ветвление с elif

В прошлом уроке вы научились разбивать программу на два пути: если условие истинно — один блок, иначе — другой. Конструкция if/else хорошо работает, пока вариантов ровно два. Но что делать, когда их три, четыре или больше? Именно здесь появляется elif.

От if/else к elif: зачем нужна третья ветвь

Представьте, что нужно классифицировать балл не в два варианта (сдал / не сдал), а в четыре: отлично, хорошо, удовлетворительно, неудовлетворительно. Если пытаться решить это только через if/else, придётся вкладывать один блок else внутрь другого:

score = int(input('Балл: '))
if score >= 90:
    print('Отлично')
else:
    if score >= 75:
        print('Хорошо')
    else:
        if score >= 60:
            print('Удовлетворительно')
        else:
            print('Неудовлетворительно')

Код работает, но с каждым новым вариантом уровень вложенности растёт вправо. Уже на четвёртом уровне читать это неудобно, а на шестом — почти невозможно.

Для таких ситуаций в Python есть ключевое слово elif — сокращение от else if. Оно позволяет добавить новое условие на том же уровне отступа, что и исходный if, без вложенности:

score = int(input('Балл: '))
if score >= 90:
    print('Отлично')
elif score >= 75:
    print('Хорошо')

Синтаксис elif повторяет синтаксис if: ключевое слово, пробел, логическое условие, двоеточие — и тело блока с отступом в четыре пробела. Заголовок elif пишется на том же уровне отступа, что и if, а не внутри него.

Логика выполнения проста: Python сначала проверяет условие if. Если оно ложно — переходит к elif и проверяет его условие. Блок elif выполняется только тогда, когда все предшествующие проверки оказались ложными, а текущее условие — истинно. Количество ветвей elif не ограничено: можно добавить столько, сколько нужно вариантов.

Ключевой момент: elif — это не самостоятельная инструкция. Она всегда привязана к предшествующему if и не может стоять отдельно. Без if перед ней Python выдаст синтаксическую ошибку.

Полная конструкция if / elif / else и порядок проверки

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

Это гарантия эксклюзивности: из всей цепочки if / elif / elif / ... / else выполнится не более одного блока.

Посмотрим на это поведение схематично:

x = 85

if x >= 90:
    print('A')      # x < 90, пропускаем
elif x >= 75:
    print('B')      # x >= 75 — истина, выполняем
elif x >= 60:
    print('C')      # до сюда Python уже не дойдёт
else:
    print('D')      # и сюда тоже

При x = 85 первое условие ложно, второе истинно — Python печатает B и немедленно переходит к коду после всей конструкции. Ветви elif x >= 60 и else даже не проверяются.

Теперь о роли else. Эта ветвь необязательна: если её нет, а ни одно условие не сработало, Python просто ничего не сделает и продолжит выполнение дальше. Если else есть — она становится «ловушкой для всего остального»: срабатывает ровно тогда, когда все if и elif оказались ложными. У else нет своего условия — только двоеточие и тело блока.

Важно понимать, что if / elif / else — это одна цельная конструкция, а не три независимые инструкции. Python видит её как единое дерево решений с чёткими правилами: не более одного победителя, строгий порядок сверху вниз. Именно эта семантика делает конструкцию предсказуемой: можно точно знать, какой блок выполнится при каждом конкретном значении переменной.

Классификатор оценок: построение программы шаг за шагом

Возьмём конкретную задачу: пользователь вводит балл от 0 до 100, программа должна вывести одну из четырёх меток — «Отлично», «Хорошо», «Удовлетворительно» или «Неудовлетворительно». Вот как двигаться от постановки к готовому коду.

Шаг 1. Определить диапазоны и метки.

Прежде чем писать код, нужно зафиксировать границы:

• 90 и выше → «Отлично»
• от 75 до 89 → «Хорошо»
• от 60 до 74 → «Удовлетворительно»
• ниже 60 → «Неудовлетворительно»

Четыре варианта — значит, нам нужны if, два elif и else.

Шаг 2. Написать заголовок if с первым условием.

Начинаем с самого высокого порога — 90. Почему именно с него, станет понятно в следующем разделе.

score = int(input('Балл: '))
if score >= 90:
    print('Отлично')

Шаг 3. Добавить ветви elif для остальных диапазонов.

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

score = int(input('Балл: '))
if score >= 90:
    print('Отлично')
elif score >= 75:
    print('Хорошо')
elif score >= 60:
    print('Удовлетворительно')

Если score = 82, первое условие (>= 90) ложно, второе (>= 75) истинно — Python выполнит print('Хорошо') и выйдет из конструкции. До третьего elif он даже не дойдёт.

Шаг 4. Добавить else для оставшихся случаев.

score = int(input('Балл: '))
if score >= 90:
    print('Отлично')
elif score >= 75:
    print('Хорошо')
elif score >= 60:
    print('Удовлетворительно')
else:
    print('Неудовлетворительно')

else здесь — «ловушка» для всех значений ниже 60. У неё нет условия: она сработает только если все три проверки выше оказались ложными.

Шаг 5. Проверить полноту покрытия.

Пробегитесь по граничным значениям мысленно:

• score = 100 → >= 90 истина → «Отлично» ✓
• score = 90 → >= 90 истина → «Отлично» ✓
• score = 89 → первое ложно, >= 75 истина → «Хорошо» ✓
• score = 60 → первые два ложны, >= 60 истина → «Удовлетворительно» ✓
• score = 59 → все три ложны → else → «Неудовлетворительно» ✓

Если хотя бы одно граничное значение даёт неожиданный результат — цепочка составлена неверно.

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

Типичная ошибка: неверный порядок условий

Есть ловушка, в которую попадают почти все, кто впервые пишет цепочку elif. Выглядит она так:

score = int(input('Балл: '))
if score >= 60:
    print('Удовлетворительно')
elif score >= 75:
    print('Хорошо')
elif score >= 90:
    print('Отлично')
else:
    print('Неудовлетворительно')

Попробуйте мысленно проверить score = 95. Python идёт сверху вниз: первое условие score >= 60 — истина. Python выполняет print('Удовлетворительно') и выходит из конструкции. До elif score >= 90 он просто не доберётся.

Причина: условие >= 60 захватывает все значения от 60 до бесконечности — в том числе 75, 90, 100. Оно слишком широкое и стоит первым, поэтому «съедает» все случаи, которые должны были попасть в более узкие ветви.

Правило простое: располагать условия от самого узкого (самого строгого) к самому широкому. Именно так сделано в правильном классификаторе — сначала >= 90, потом >= 75, потом >= 60. Каждое следующее условие срабатывает только на значениях, которые не прошли проверку выше.

Как это проверить, не запуская программу: пройдитесь по граничным значениям вручную.

• score = 90 → первое условие >= 60 истинно → «Удовлетворительно» — неверно, ожидалось «Отлично».

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

Ещё один способ контролировать себя: убедитесь, что каждое условие в цепочке формулирует только нижнюю границу своего диапазона. Верхняя граница уже обеспечена тем, что предыдущие ветви отсекли всё, что выше. Если вы пишете условие вроде 60 <= score < 75 — это тоже работает, но избыточно: верхняя часть проверки уже гарантирована логикой конструкции.