Ветвление

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

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

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

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

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

Оператор 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("Поздравляем! Вы набрали нужное количество очков! :)")
# Ввод: 110
# Вывод: Поздравляем! Вы набрали нужное количество очков! :)

Теперь, если условие 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. Напишите программу, которая принимает на вход два целых числа и один из основных арифметических операторов (сложение +, вычитание -, умножение * и деление /), и выводит на экран результат арифметической операции между введёнными числами в зависимости от введённого оператора.

Если вводится арифметический оператор не из списка, то на экран выводится строка "Неизвестный оператор".

n_1 = int(input())
n_2 = int(input())
operator = input()

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

2. Напишите программу, которая принимает на вход целое число от 1 до 7, обозначающее номер дня недели, и выводит на экран название этого дня.

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

day = int(input())

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

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

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

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

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

n_1 = int(input())
n_2 = int(input())

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

🔥 5. Напишите программу, которая принимает на вход целое трёхзначное число и выводит на экран "Да" или "Нет" в зависимости от того, совпадает ли его первая и последняя цифра.

Подсказка: вспомните про операторы целочисленного деления // и нахождения остатка от деления %.

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