Перейти к содержанию

Оператор ветвления if, elif, else

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

Мы уже изучали операторы, которые в результате проверок давали логическое значение Trueили False. На самом деле они и есть основной ингредиент более интересной магии, которая позволяет создавать алгоритмы принятия решений. Эта конструкция языка позволяет выполнить код если определенное условие выполняется или не выполняется. То есть программа в заивисимости от условия поток выполнения программы включает или нет опеределенные зоны. По-другому можно сказать, что программа разделяется на разные ветви, поэтому еще конструкцию if-elif-else еще называют оператором ветвления.

Полный синтаксис конструкции выглядит так:

if <условие 1>:
    <блок кода 1>
elif <условие 2>:
    <блок кода 2>
else:
    <блок кода 3>

Для того чтобы привыкнуть к этом оператору и научиться понимать его научитесь читать его: если (if) выполняется <условие 1>, то выполнить <блок кода 1>, иначе если (elif, сокращенно от else if) выполняется <условие 2> то выполнить блок кода 2, иначе (else) выполнить блок кода 3.

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

Условие — это логическое выражение, которое должно вернуть False или True.

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

n = input("Введите число: ")
if n.isnumeric():
    print("Вы ввели число")
# конец

Более сложный пример:

n = input("Введите число: ")
if n.isnumeric():
    n = int(n)
    if n < 0:
        print("Отрицательное число")
    elif 0 <= n <= 10:
        print("Маленькое число")
    else:
        print("Большое число")
else:
    print("Ошибка")

print("Спасибо")
# конец

Давайте разберем подробнее этот пример. Мы просим ввести пользователя число и проверяем строку методом isnumeric(), если эта строка состоит из символов, которые могут быть конвертированы в число, то проверка вернет True, и значит первый оператор if будет истинным. Тогда стартует большой вложенный блок, который конвертирует строку в число и запустит дополнительные проверки. Но если пользователь введет какой-то текст, который невозможно конвертировать в число, то сработает инструкция else и на экран выведется сообщение об ошибке ввода. В случае выполнения условий происходит вывод соответствующего текста:

В этом примере показан пример более глубокого уровня вложенности. Внутри первого блока появляется еще один вложенный блок. И для него используются свои отступы. На самом деле в Python может быть достаточно много уровней вложенности, но обычно если их больше 5-7, то это частый признак того, что код надо оптимизировать. Потому что большое количество отступов может плохо сказаться на читаемости кода.

Комбинирование условий

В предыдущем примере мы уже столкнулись с примером того, что число в переменной n проверяется на вхождение в диапазон от 0 до 10 такой конструкцией 0 <= n <= 10. Поскольку результат выполнения оператора — это логическое значение, то оно может быть комбинировано и с другими логическими операторами, для того чтобы создавать сложные условия:

x = 'abc'

if 'a' in x and 'b' in x or 'c' in x:
    print("Некоторые буквы найдены")

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

x = 'abracadabra'

if (('ab' in x) and ('ba' in x)) or ('ca' in x):
    print("Некоторые буквы найдены")

Сначала идет проверка первого блока, в котором оператор and сравнивает выполнение двух условий на вхождение подстроки ab и ba в переменную x, если эти условия не выполнены, то произойдет проверка второго блока условий после or и проверка на вхождение ca в x. Для того чтобы проверка была успешной достаточно выполнения обоих первых условий (между ними стоит И) или второго условия.

Блок условий — это полноценный код, который выполняется в момент проверки, этот код может содержать вычисления или вызовы функций:

n = 10

if n ** 2 >= 100:
    pass

Согласно приоритету операторов, переменная n возводится в степень 2, а после этого происходит проверка неравенства.

Проверка на истинность

Во время работы с Python кодом вам часто будет встречаться конструкция:

if variable:
    # тело блока

Может показаться, что тут нет явного условия, но согласно правилам языка истинной являются все значения кроме None, 0, 0.0, 0j, '', (), [], {}. Поэтому если ваша переменная имеет хоть какое-то значение кроме перечисленных, то она автоматически становится равна True. Что позволяет писать такой лаконичный код.

Условия одной строкой

Помимо блочного представления оператора if-elif-else у него еще есть краткая однострочная форма:

<выражение1> if <условие> else <выражение2>

Такой формат еще называют тернарным оператором (тот самый который я регулярно проверяю в документации как он работает!). Он позволяет экономить место и делать код более компактным:

>>> age = 18
>>> print("Ребенок" if age < 18 else "Взрослый")
Взрослый

И конечно вы можете их объединять в цепочку:

age = 14
>>> print("Ребенок" if age < 12 else "Подросток" if age < 18 else "Взрослый")
Подросток

Этот же код можно записать в виде блока:

age = 14
if age < 18:
    if age < 12:
        print("Ребенок")
    else:
        print("Подросток")
else:
    print("Взрослый")

По началу такая конструкция выглядит слишком запутанной.

image