Условные конструкции if, elif и else в Python
Обновлено:
Условные конструкции позволяют разделять логику программы в зависимости от результата проверки.
Мы уже знаем операторы:
==
!=
>
>=
<
<=
in
not in
not
and
or
Теперь их результаты можно использовать для выбора того, какой код должен выполняться.
1. Конструкция if
Самая простая условная конструкция состоит только из if:
balance = 1500
if balance > 0:
print('На счёте есть деньги')
Результат:
На счёте есть деньги
После if записывается выражение, которое Python проверяет на истинность:
balance > 0
Если результат истинный, выполняется тело if.
Если результат ложный, тело пропускается.
Общий вид:
if условие:
действие
После условия обязательно ставится двоеточие, а тело записывается с отступом в четыре пробела.
2. В теле if может находиться несколько действий
Условный блок не ограничен одной строкой:
balance = 2500
if balance > 0:
print('Баланс положительный')
print(f'Доступно: {balance} руб.')
print('Можно продолжить работу')
Все строки с одинаковым отступом относятся к одному блоку if.
3. В условии можно использовать разные операторы
Например, торговая операция разрешена только для определённых торговых пар и при положительном балансе:
balance = 1500
symbol = 'BTCUSDT'
allowed_symbols = ('BTCUSDT', 'ETHUSDT')
if balance > 0 and symbol in allowed_symbols:
print('Торговая операция разрешена')
Здесь используются сразу:
>
and
in
В if можно использовать любые уже изученные выражения, результат которых Python способен проверить на истинность.
if и else
4. Блок else
Иногда нужно выполнить один код, если проверка успешна, и другой — во всех остальных случаях.
balance = 0
if balance > 0:
print('На счёте есть деньги')
else:
print('Баланс пуст')
Результат:
Баланс пуст
Если условие if истинно, выполняется первый блок.
Если оно ложно, выполняется else.
5. В else нет условия
После else не записывается логическое выражение:
else:
Неправильно:
else balance == 0:
else означает:
Выполнить этот блок, если предыдущие связанные проверки не сработали.
6. else является необязательным
Если альтернативного действия нет, else писать не нужно:
user_name = 'Alex'
if user_name:
print(f'Пользователь: {user_name}')
Конструкция:
if
может существовать самостоятельно.
elif
7. Дополнительные проверки
Если возможных вариантов больше двух, используется:
elif
Пример:
temperature = 18
if temperature > 25:
print('Жарко')
elif temperature >= 10:
print('Тепло')
else:
print('Холодно')
Результат:
Тепло
elif содержит собственное условие:
elif temperature >= 10:
В отличие от else, который условия не имеет.
8. elif и else тоже необязательны
Можно написать:
if
Можно:
if
else
Можно:
if
elif
Можно:
if
elif
elif
else
Количество elif может быть большим.
9. Пример с днями недели
day = 3
if day == 1:
print('monday')
elif day == 2:
print('tuesday')
elif day == 3:
print('wednesday')
elif day == 4:
print('thursday')
elif day == 5:
print('friday')
elif day == 6:
print('saturday')
elif day == 7:
print('sunday')
else:
print('error')
Результат:
wednesday
Python проверяет условия сверху вниз.
Как только одна проверка становится истинной, соответствующий блок выполняется, а оставшиеся elif и else пропускаются.
Связанные и независимые проверки
10. Несколько if — это несколько отдельных проверок
Рассмотрим неправильный вариант программы определения дня:
day = 1
if day == 1:
print('monday')
if day == 2:
print('tuesday')
if day == 3:
print('wednesday')
if day == 4:
print('thursday')
if day == 5:
print('friday')
if day == 6:
print('saturday')
if day == 7:
print('sunday')
else:
print('error')
Результат:
monday
error
Почему?
Каждый if здесь является самостоятельной конструкцией.
Последний else относится только к:
if day == 7:
При day == 1:
if day == 1:
выводит monday.
Но затем Python доходит до:
if day == 7:
Получает False и выполняет связанный с ним else.
Это логическая ошибка программы.
11. Когда нужен if / elif / else
Если проверки описывают один выбор из нескольких вариантов, их нужно объединять:
if day == 1:
...
elif day == 2:
...
elif day == 3:
...
else:
...
В такой цепочке будет выбран только один подходящий блок.
12. Когда несколько отдельных if правильны
Иногда программе действительно нужно выполнить несколько независимых проверок.
Например, интернет-магазин анализирует заказ:
order_price = 7000
product = 'Laptop'
user_name = 'Alex'
blacklist = ('spam_user', 'blocked_user')
warranty_products = ('Laptop', 'Monitor')
if order_price >= 5000:
print('Доступна бесплатная доставка')
if product in warranty_products:
print('Доступна расширенная гарантия')
if user_name not in blacklist:
print('Пользователь может оставить отзыв')
Результат:
Доступна бесплатная доставка
Доступна расширенная гарантия
Пользователь может оставить отзыв
Здесь проверки друг другу не мешают.
В одном заказе одновременно могут:
- предоставить бесплатную доставку;
- предложить гарантию;
- разрешить пользователю оставить отзыв.
Поэтому три независимых if здесь являются правильным решением.
Порядок проверок
13. Python проверяет if / elif сверху вниз
Это значит, что порядок условий может влиять на результат.
Рассмотрим неправильную программу:
grade = 95
if grade >= 60:
print(2)
elif grade >= 70:
print(3)
elif grade >= 80:
print(4)
elif grade >= 90:
print(5)
else:
print(1)
Результат:
2
Хотя оценка 95 должна дать 5.
14. Почему программа ошиблась
Первая же проверка:
grade >= 60
для числа 95 возвращает:
True
После этого Python выполняет первый блок и больше не проверяет остальные elif.
Программа синтаксически правильная и не вызывает исключений.
Ошибка находится в логике.
15. Правильный порядок
Нужно начинать с наиболее строгого условия:
grade = 95
if grade >= 90:
print(5)
elif grade >= 80:
print(4)
elif grade >= 70:
print(3)
elif grade >= 60:
print(2)
else:
print(1)
Результат:
5
При построении цепочки if / elif / else важно не только правильно написать сами условия, но и расположить их в правильном порядке.
Вложенные условия
16. if внутри if
Внутри условного блока можно создать ещё одну условную конструкцию:
user_is_active = True
balance = 1500
if user_is_active:
if balance > 0:
print('Операция разрешена')
else:
print('Недостаточно средств')
else:
print('Учётная запись отключена')
Такой if называется вложенным.
Вложенность может продолжаться и дальше, но большое количество уровней обычно ухудшает читаемость.
Вложенность и elif
17. Один алгоритм можно написать слишком вложенно
Например, перевод стобалльной оценки в пятибалльную:
grade = 79
if grade >= 90:
print(5)
else:
if grade >= 80:
print(4)
else:
if grade >= 70:
print(3)
else:
if grade >= 60:
print(2)
else:
print(1)
Программа работает, но структура становится тяжёлой.
18. Более простой вариант
Тот же алгоритм лучше записать через elif:
grade = 79
if grade >= 90:
print(5)
elif grade >= 80:
print(4)
elif grade >= 70:
print(3)
elif grade >= 60:
print(2)
else:
print(1)
Такой код:
- короче;
- проще читать;
- проще изменять;
- легче проверять.
В PEP 20 — «Дзене Python» — есть принцип:
Flat is better than nested.
То есть:
Плоское лучше вложенного.
Вложенность нужна, когда она действительно отражает структуру алгоритма, но создавать её без необходимости не стоит.
Объединение условий
19. Одинаковую бизнес-логику не нужно дублировать
Предположим, мы сравниваем цены от трёх поставщиков и хотим определить:
- все три цены одинаковые;
- одинаковые хотя бы две цены;
- все цены разные.
Слишком вложенный вариант
first_price = 1500
second_price = 1500
third_price = 1700
if first_price == second_price:
if second_price == third_price:
print('Все цены одинаковые')
else:
print('Совпадают две цены')
else:
if first_price == third_price:
print('Совпадают две цены')
else:
if second_price == third_price:
print('Совпадают две цены')
else:
print('Все цены разные')
Код работает, но содержит лишнюю вложенность.
20. Лишнее дублирование через elif
Можно написать проще:
if first_price == second_price == third_price:
print('Все цены одинаковые')
elif first_price == second_price:
print('Совпадают две цены')
elif first_price == third_price:
print('Совпадают две цены')
elif second_price == third_price:
print('Совпадают две цены')
else:
print('Все цены разные')
Уже лучше, но одна и та же бизнес-логика:
print('Совпадают две цены')
повторяется три раза.
21. Более удачный вариант
Если несколько разных проверок должны приводить к одному результату, их можно объединить через or:
if first_price == second_price == third_price:
print('Все цены одинаковые')
elif (
first_price == second_price
or first_price == third_price
or second_price == third_price
):
print('Совпадают две цены')
else:
print('Все цены разные')
Теперь структура программы напрямую отражает бизнес-логику.
Область видимости
22. if, elif и else не создают новую область видимости
Функция создаёт локальную область видимости:
def example():
local_value = 10
А блоки:
if
elif
else
новую область видимости не создают.
23. if в глобальной области
balance = 1500
if balance > 0:
status = 'active'
bonus = 100
print(status)
print(bonus)
Результат:
active
100
Переменные:
status
bonus
созданы в глобальной области видимости, потому что сам if находится в глобальной области.
Их можно увидеть и через:
dir()
24. if внутри функции
Если условная конструкция находится внутри функции:
def create_account_status(balance):
if balance > 0:
status = 'active'
else:
status = 'empty'
return status
переменная:
status
относится к локальной области функции.
Сам if отдельную область не создаёт.
Общее правило:
if,elifиelseработают в той области видимости, в которой находятся.
Проверка объектов на истинность
25. Не нужно писать лишний код
Мы уже знаем, как класс bool определяет истинность объектов.
Поэтому для проверки непустого списка достаточно:
numbers = [1, 2, 3]
if numbers:
print('Список не пустой')
Это наиболее простой и естественный вариант.
26. Избыточные варианты
Тот же смысл можно получить так:
if len(numbers):
print('Список не пустой')
или:
if bool(numbers):
print('Список не пустой')
или:
if len(numbers) > 0:
print('Список не пустой')
Но для обычной проверки заполненности это лишний код.
Предпочтительно:
if numbers:
print('Список не пустой')
Это относится и к другим уже изученным объектам, для которых определена проверка истинности:
str
list
tuple
27. Проверка пустого объекта
Для противоположной проверки используется not:
numbers = []
if not numbers:
print('Список пустой')
Вместо более громоздких вариантов:
if len(numbers) == 0:
if not bool(numbers):
предпочтительно:
if not numbers:
Код короче и сразу передаёт смысл проверки.
Проверка логической переменной
28. Не сравниваем с True без необходимости
greeting_is_enabled = True
Предпочтительно:
if greeting_is_enabled:
print('Приветствие включено')
Для обычной проверки истинности не нужно писать:
if greeting_is_enabled == True:
или:
if greeting_is_enabled is True:
или:
if bool(greeting_is_enabled):
Первый вариант:
if greeting_is_enabled:
проще и соответствует обычному стилю Python.
PEP 8 отдельно рекомендует не сравнивать логические значения с True и False через ==.
Условия внутри функций
29. return непосредственно в разных ветках
Функция может завершаться прямо внутри нужной ветки:
def check_number(number):
if number > 0:
return 'Положительное число'
elif number < 0:
return 'Отрицательное число'
else:
return 'Ноль'
print(check_number(-1))
Результат:
Отрицательное число
Как только выполняется return, функция завершается.
30. Пример с оператором in
def get_season(month):
if month in (3, 4, 5):
return 'Весна'
elif month in (6, 7, 8):
return 'Лето'
elif month in (9, 10, 11):
return 'Осень'
elif month in (12, 1, 2):
return 'Зима'
else:
return 'Некорректный месяц'
print(get_season(5))
Результат:
Весна
Здесь условные конструкции используются для разделения бизнес-логики функции.
Один return в конце функции
31. В ветках можно подготовить результат
Необязательно писать return внутри каждого блока.
Можно сначала выбрать нужное значение, а вернуть его один раз в конце:
def get_temperature_status(temperature):
if temperature > 25:
status = 'Жарко'
elif temperature >= 10:
status = 'Тепло'
else:
status = 'Холодно'
return status
print(get_temperature_status(18))
Результат:
Тепло
Здесь условная конструкция определяет значение переменной:
status
а выход из функции находится в одном месте:
return status
Оба подхода допустимы.
Выбор зависит от конкретной функции и читаемости кода.
Обязателен ли else после return
32. Вариант с else
def check_even_odd(number):
if number % 2 == 0:
return 'Чётное число'
else:
return 'Нечётное число'
Такой код корректен и хорошо показывает две противоположные ветки.
33. Вариант без else
После выполнения return функция сразу завершается.
Поэтому можно написать:
def check_even_odd(number):
if number % 2 == 0:
return 'Чётное число'
return 'Нечётное число'
Если число чётное, первый return завершит функцию.
Если проверка ложная, программа продолжит выполнение и дойдёт до второго return.
Оба варианта правильные.
Здесь нет универсального правила «всегда удалять else» или «всегда оставлять else».
Нужно выбирать вариант, который лучше передаёт структуру конкретной функции.
34. Проверка чётности через истинность числа
Так как:
number % 2
для чётного числа возвращает:
0
а 0 является ложным значением, проверку можно записать:
def check_even_odd(number):
if not number % 2:
return 'Чётное число'
return 'Нечётное число'
Такой вариант работает.
Однако запись:
number % 2 == 0
часто читается понятнее, потому что непосредственно говорит:
Остаток от деления равен нулю.
Краткость не должна ухудшать читаемость.
Основные правила
35. Что нужно запомнить
if выполняет код только при истинной проверке:
if condition:
...
else выполняется во всех остальных случаях:
if condition:
...
else:
...
elif позволяет добавить дополнительные связанные проверки:
if condition_1:
...
elif condition_2:
...
else:
...
elif и else являются необязательными.
У else нет собственного условия.
В цепочке:
if / elif / else
проверки выполняются сверху вниз, и после первого подходящего блока остальные пропускаются.
Несколько отдельных if используются, когда проверки независимы и программа потенциально должна выполнить несколько блоков.
Порядок условий имеет значение и может стать причиной логической ошибки.
Вложенные if допустимы, но лишнюю вложенность лучше убирать.
Если несколько условий приводят к одной бизнес-логике, их часто можно объединить с помощью:
and
or
in
not in
if, elif и else не создают отдельную область видимости.
Для проверки непустого объекта предпочтительно:
if value:
Для проверки пустого:
if not value:
Для обычной проверки логической переменной:
if flag:
а не:
if flag == True:
Условные конструкции особенно важны потому, что именно с их помощью программа начинает принимать решения и разделять бизнес-логику на разные сценарии.