Ветвление

Ветвление – это фундаментальный механизм в программировании, позволяющий выполнять различные действия в зависимости от условия. Это похоже на принятие решений в реальной жизни: «Если я наберу 100 очков, то перейду на следующий уровень. Иначе мне придётся сыграть ещё раз».

Условные операторы

В Python ветвление реализуется с помощью условных операторов if (с англ. – если), elif (от англ. else if – иначе если) и else (с англ. – иначе):

if условие_1:
    блок_кода_1
elif условие_2:
    блок_кода_2
else:
    блок_кода_3

Каждое условие – это логическое выражение, результат которого может быть либо истинным (True), либо ложным (False). Если первое условие в if истинно, то выполняется соответствующий блок кода, иначе – проверяется следующее условие в elif и так далее. Если все условия оказались ложными, то выполняется блок кода else.

Принадлежность кода к блоку if, elif или else определяется обязательным отступом (обычно 4 пробела). Отсутствие или неправильный отступ приведет к ошибке IndentationError.

Оператор if

Самая простая форма ветвления – это просто оператор if. В этом случае определенный блок кода выполняется только при истинности заданного условия:

points = int(input("Введите количество набранных очков: "))
if points < 100:
    print("Вам пока не хватает очков для завершения игры! :(")
# Ввод: Введите количество набранных очков: 5 
# Вывод: Вам пока не хватает очков для завершения игры! :(

Если введённое пользователем число меньше 100, программа выведет сообщение о неудаче. В противном случае ничего не произойдет.

Операторы elif

Оператор elif добавляет альтернат ивные сценария выполнения программы. При этом количество блоков elif не ограничено, но условие в каждом  них проверяется только в том случае, если условие в  if  или в предыдущем   elif  было ло жным:    

points = int(input("Введите количество набранных очков: "))
if points < 100:
    print("Вам пока не хватает очков для завершения игры! :(")
elif points >= 100:
    print("Поздравляем! Вы набрали нужное количество очков! :)")
# Ввод: Введите количество набранных очков: 100
# Вывод: Поздравляем! Вы набрали нужное количество очков! :)

Теперь, если условие points < 100 окажется ложным, программа перейдёт ко второму условию points >= 100. Если оно будет истинным, пользователь увидит сообщение об успехе.

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

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

points = int(input("Введите количество набранных очков: "))
if points < 100:
    print("Вам пока не хватает очков для завершения игры! :(")
elif points >= 100 and points <= 110:
    print("Поздравляем! Вы отлично сыграли! Ваш ранг: A :)")
elif points >= 111 and points <= 150:
    print("Поздравляем! Вы великолепно сыграли! Ваш ранг: S :)")
# Ввод: Введите количество набранных очков: 120
# Вывод: Поздравляем! Вы великолепно сыграли! Ваш ранг: S :)

Математически оба сложных условия можно записать как 100 ≤ points ≤ 110 и 111 ≤ points ≤ 150. Например, выражение points >= 100 and points <= 110 будет истинным, если введённое пользователем число одновременно меньше или равно 110 и больше или равно 100.

Оператор else

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

points = int(input("Введите количество набранных очков: "))
if points < 100:
    print("Вам пока не хватает очков для завершения игры! :(")
elif points >= 100 and points <= 110:
    print("Поздравляем! Вы отлично сыграли! Ваш ранг: A :)")
elif points >= 111 and points <= 150:
    print("Поздравляем! Вы великолепно сыграли! Ваш ранг: S :)")
else:
    print("Слишком большое количество очков! Может быть вы жульничали? D:")
# Ввод: Введите количество набранных очков: 100500
# Вывод: Слишком большое количество очков! Может быть вы жульничали? D: 

Теперь, если введено недопустимое значение (больше 150), программа сообщит об ошибке.

Вложенное ветвление

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

Представим ситуацию, когда необходимо проверить два условия последовательно: сначала убедиться, что игрок набрал достаточное количество очков, а потом проверить, прошел ли он проверку на робота:

points = int(input("Введите количество набранных очков: "))
if points >= 100:
    print("Отлично! Вы набрали достаточное количество очков!")
    is_bot_test_passed = input("Вы прошли проверку на робота? (Да/Нет): ")
    if is_bot_test_passed == 'Да':
        print("Поздравляем! Вы успешно завершили игру! :)")
    else:
        print("К сожалению, проверка на робота не пройдена. Попробуйте еще раз.")
else:
    print("Вам пока не хватает очков для завершения игры! :(")
# Ввод: 120
# Вывод: Отлично! Вы набрали достаточное количество очков!
# Вывод: Вы прошли проверку на робота? (Да/Нет): 
# Ввод: Да
# Вывод: Поздравляем! Вы успешно завершили игру! :)

Как видно из примера, второе условие is_bot_test_passed == "Да" проверяется только после того, как первое условие points >= 100 выполнено. Это помогает структурировать код таким образом, чтобы каждый шаг зависел от предыдущего результата.

Однако чрезмерное вложение делает код сложнее для чтения и понимания. Поэтому рекомендуется избегать большого числа уровней вложенности. Даже в философии Python сказано: «Плоское лучше, чем вложенное», поэтому следует избегать глубоких вложений, особенно если задачу можно решить другим способом.

Тернарный оператор

Для простого условного выбора в одну строку Python предлагает компактную запись с помощью тернарного оператора:

значение1 if условие else значение2

Этот оператор возвращает значение1, если условие истинно, и значение2, если условие ложно.

Тернарный оператор часто используется для присваивания значения переменной в зависимости от условия:

points = int(input("Введите количество очков: "))
result = "Вы проиграли :(" if points < 100 else "Вы выиграли :)"
print(result)
# Ввод: Введите количество очков: 110
# Вывод: Вы выиграли :)

Этот код эквивалентен обычной конструкции if/else:

points = int(input("Введите количество очков: "))
if points < 100:
    result = "Вы выиграли :)"
else:
    result = "Вы проиграли :("
print(result)
# Ввод: Введите количество очков: 25
# Вывод: Вы проиграли :(

Сопоставление с шаблонами

Начиная с Python 3.10, в языке появилась мощная конструкция сопоставления с шаблонами (англ. – match case), которая предоставляет более структурированный и читаемый способ обработки различных значений переменной по сравнению с длинными цепочками if/elif/else:

match выражение:
    case шаблон_1:
        действия_при_совпадении_с_шаблоном_1
    case шаблон_2:
        действия_при_совпадении_с_шаблоном_2
    ...
    case _:
        действия_если_ни_один_шаблон_не_подошёл

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

day = input("Введите день недели: ")
match day:
    case "Понедельник":
        print("Понедельник – день когда, всё будет хорошо!")
    case "Вторник":
        print("Вторник – самое время начать что-нибудь новенькое!")
    case "Среда":
        print("Середина недели – только вперед к новым вершинам!")
    case "Четверг":
        print("Четверг – отличный повод задуматься о том, сколько всего хорошего впереди!")
    case "Пятница":
        print("Пятница – конец рабочей недели! Время расслабиться!")
    case "Суббота" | "Воскресенье":
        print("Выходные – отличная возможность зарядиться энергией для но-вой недели!")
    case _:
        print("Кажется, что-то пошло не так...")
# Ввод: Введите день недели: Среда
# Вывод: Середина недели – только вперед к новым вершинам!

# Ввод: Введите день недели: День недели
# Вывод: Кажется, что-то пошло не так...

Конструкция match/case принимает выражение (в данном случае значение переменной day) и сравнивает его последовательно с каждым case. Если значение совпадает с шаблоном в case, выполняется соответствующий блок кода.

Оператор | внутри case выполняет функцию оператора or и объединяет несколько шаблонов (в данном случае "Суббота" и "Воскресенье").

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

Сопоставление с шаблонами также поддерживает сопоставление не только с конкретными значениями, но и с типами данных, последовательностями и другими объектами, что делает его очень полезным для обработки сложных сценариев ветвления.

Примеры

Пример 1. Система скидок в интернет-магазине

Интернет-магазин предоставляет скидку в зависимости от итоговой суммы заказа:

order_amount = float(input("Введите сумму заказа: "))

# Определение скидки (%)
if order_amount > 10000:
    discount = 20
elif order_amount > 5000:
    discount = 15
elif order_amount > 2500:
    discount = 10
else:
    discount = 0

# Расчёт суммы с учётом скидки
total = order_amount * (1 - discount / 100)
print(f"Ваша скидка: {discount}%")
print(f"Итоговая сумма: {total:.2f} руб.")

Вывод:

Введите сумму заказа: 6500
Ваша скидка: 15%
Итоговая сумма: 5525.00 руб.

Пример 2. Ограничение доступа к сайту по возрасту

Доступ к сайту запрещён для лиц младше 18 лет:

age = int(input("Введите ваш возраст: "))
access = "Доступ разрешён" if age >= 18 else "Доступ запрещён"
print(access)

Вывод:

Введите ваш возраст: 21
Доступ разрешён

Пример 3. Обработка заказа в интернет-магазине

Система определяет действие по заказу в зависимости от его статуса:

order_status = input("Введите статус заказа: ")
 
match order_status:
    case "Новый":
        action = "Назначить менеджера"
    case "В обработке":
        action = "Проверить наличие товара"
    case "Доставлен":
        action = "Отправить опрос клиенту"
    case "Отменён":
        action = "Уточнить причину отмены"
    case _:
        action = "Статус не распознан"
 
print(f"Действие: {action}")

Вывод:

Введите статус заказа (Новый/В обработке/Доставлен/Отменён): Доставлен
Действие: Отправить опрос клиенту

Итоги

• Ветвление (if/elif/else) – это механизм, позволяющий выполнять разные блоки кода в зависимости от истинности или ложности определенных условий. Если первое условие в if истинно, то выполняется соответствующий блок кода, иначе – проверяется следующее условие в elif и так далее. Если ни одной из условий не выполняется, то выполняется блок кода else.
• Сложные условия создаются объединением простых условий с помощью логических операторов and, or, not.
• Тернарный оператор (значение1 if условие else значение2) – это компактная запись для простого условного выбора в одну строку. Он возвращает значение1, если условие истинно, иначе – значение2.
• Сопоставление с шаблонами (match/case) – это механизм, позволяющий обрабатывать различные значения переменной при множестве условий. Если значение переменной в match совпадает с шаблоном в case, выполняется соответствующий блок кода.
• Оператор | объединяет несколько шаблонов в одном case.
• Символ _ используется для определения шаблона по умолчанию.

Задания для самопроверки

1. Запросите у пользователя целое число от 1 до 7, обозначающее номер дня недели, и выведите на экран название этого дня. 
Если введённое число выходит за пределы диапазона целых чисел от 1 до 7, то выведите строку "Такого дня недели не существует".

day = int(input())

match day:
    case 1:
        print("Понедельник")
    case 2:
        print("Вторник")
    case 3:
        print("Среда")
    case 4:
        print("Четверг")
    case 5:
        print("Пятница")
    case 6:
        print("Суббота")
    case 7:
        print("Воскресенье")
    case _:
        print("Такого дня недели не существует")

2. Запросите у пользователя два целых числа и один из основных арифметических операторов (+, -, * и /). Выведите на экран результат арифметической операции между введёнными числами в зависимости от введённого оператора.
Если вводится арифметический оператор не из списка, то выведите строку "Неизвестный оператор".

n1 = int(input())
n2 = int(input())
operator = input()

if operator == "+":
    print(f"{n1} + {n2} = {n1 + n2}")
elif operator == "-":
    print(f"{n1} - {n2} = {n1 - n2}")
elif operator == "*":
    print(f"{n1} * {n2} = {n1 * n2}")
elif operator == "/":
    print(f"{n1} / {n2} = {n1 / n2}")
else:
    print("Неизвестный оператор")

3. Запросите у пользователя два целых числа, и если они оба положительные, то выведите на экран наибольшее из них, а если оба отрицательные – наименьшее.
Если знаки чисел не совпадают или одно или оба равны нулю, то выведите оба числа через запятую.

n1 = int(input())
n2 = int(input())

if n1 > 0 and n2 > 0:
    if n1 > n2:
        print(n1)
    else:
        print(n2)
elif n1 < 0 and n2 < 0:
    if n1 < n2:
        print(n1)
    else:
        print(n2)
else:
    print(f"{n1}, {n2}")

4. Запросите у пользователя два целых числа, и если они являются решением уравнения 61 + x = 98 - y, то выведите на экран строку "Да", иначе – "Нет".

x = int(input())
y = int(input())

if 61 + x == 98 - y:
    print("Да")
else:
    print("Нет")

5. Запросите у пользователя целое трёхзначное число, и если его первая и последняя цифра совпадают, то выведите на экран строку "Да", иначе – "Нет".
Подсказка: вспомните про операторы целочисленного деления (//) и нахождения остатка от деления (%).

n = int(input())
digit_1 = n // 100
digit_3 = n % 10
if digit_1 == digit_3:
    print("Да")
else:
    print("Нет")