Множественное ветвление: if-elif-else. Оператор match в Python
Ранее мы рассмотрели работу условного оператора if . С помощью его расширенной версии if-else можно реализовать две отдельные ветви выполнения. Однако алгоритм программы может предполагать выбор больше, чем из двух путей, например, из трех, четырех или даже пяти. В данном случае следует говорить о необходимости множественного ветвления.
Рассмотрим конкретный пример. Допустим, в зависимости от возраста пользователя, ему рекомендуется определенный видеоконтент. При этом выделяют группы от 3 до 6 лет, от 6 до 12, от 12 до 16, 16+. Итого 4 диапазона. Как бы мы стали реализовывать задачу, имея в наборе инструментов только конструкцию if-else?
Самый простой ответ – последовательно проверять вхождение введенного числа-возраста в определенный диапазон с помощью следующих друг за другом условных операторов:
old = int(input('Ваш возраст: ')) print('Рекомендовано:', end=' ') if 3 old 6: print('"Заяц в лабиринте"') if 6 old 12: print('"Марсианин"') if 12 old 16: print('"Загадочный остров"') if 16 old: print('"Поток сознания"')
Примечание. Названия фильмов выводятся на экран в двойных кавычках. Поэтому в программе для определения строк используются одинарные.
Предложенный код прекрасно работает, но есть одно существенное «но». Он не эффективен, так как каждый if в нем – это отдельно взятый оператор, никак не связанный с другими if . Процессор тратит время и «нервы» на обработку каждого из них, даже если в этом уже нет необходимости. Например, введено число 10. В первом if логическое выражение возвращает ложь, и поток выполнения переходит ко второму if . Логическое выражение в его заголовке возвращает истину, и его тело выполняется. Всё, на этом программа должна была остановиться.
Однако следующий if никак не связан с предыдущим, поэтому далее будет проверяться вхождение значения переменной old в диапазон от 12 до 16, в чем необходимости нет. И далее будет обрабатываться логическое выражение в последнем if , хотя уже понятно, что и там будет False .
Решить проблему избыточности проверок можно, вкладывая условные операторы друг в друга:
old = int(input('Ваш возраст: ')) print('Рекомендовано:', end=' ') if 3 old 6: print('"Заяц в лабиринте"') else: if 6 old 12: print('"Марсианин"') else: if 12 old 16: print('"Загадочный остров"') else: if 16 old: print('"Поток сознания"')
Рассмотрим поток выполнения этого варианта кода. Сначала проверяется условие в первом if (он же самый внешний). Если здесь было получено True , то тело этого if выполняется, а в ветку else мы даже не заходим, так как она срабатывает только тогда, когда в условии if возникает ложь.
Если внешний if вернул False , поток выполнения программы заходит в соответствующий ему внешний else . В его теле находится другой if со своим else . Если введенное число попадает в диапазон от 6 до 12, то выполнится тело вложенного if , после чего программа завершается. Если же число не попадает в диапазон от 6 до 12, то произойдет переход к ветке else . В ее теле находится свой условный оператор, имеющий уже третий уровень вложенности.
Теперь зададимся следующим вопросом. Можно ли как-то оптимизировать код множественного ветвления и не строить лестницу из вложенных друг в друга условных операторов? Во многих языках программирования, где отступы используются только для удобства чтения программистом, но не имеют никакого синтаксического значения, часто используется подобный стиль:
if логическое_выражение < … ; >else if логическое_выражение < … ; >else if логическое_выражение < … ; >else
Может показаться, что имеется только один уровень вложенности, и появляется новое расширение для if , выглядящее как else if . Но это только кажется. На самом деле if , стоящее сразу после else , является вложенным в это else . Выше приведенная схема – то же самое, что
if логическое_выражение < … ; >else if логическое_выражение < … ; >else if логическое_выражение < … ; >else
Именно так ее «понимает» интерпретатор или компилятор. Однако считается, что человеку проще воспринимать первый вариант.
В Питоне такое поднятие вложенного if к внешнему else невозможно, потому что здесь отступы и переходы на новую строку имеют синтаксическое значение. Поэтому в язык Python встроена возможность настоящего множественного ветвления на одном уровне вложенности, которое реализуется с помощью веток elif.
Слово «elif» образовано от двух первых букв слова «else», к которым присоединено слово «if». Это можно перевести как «иначе если».
В отличие от else , в заголовке elif обязательно должно быть логическое выражение также, как в заголовке if . Перепишем нашу программу, используя конструкцию множественного ветвления:
old = int(input('Ваш возраст: ')) print('Рекомендовано:', end=' ') if 3 old 6: print('"Заяц в лабиринте"') elif 6 old 12: print('"Марсианин"') elif 12 old 16: print('"Загадочный остров"') elif 16 old: print('"Поток сознания"')
Обратите внимание, в конце, после всех elif , может использоваться одна ветка else для обработки случаев, не попавших в условия ветки if и всех elif . Блок-схему полной конструкции if-elif-…-elif-else можно изобразить так:
Как только тело if или какого-нибудь elif выполняется, программа сразу же возвращается в основную ветку (нижний ярко-голубой прямоугольник), а все нижеследующие elif , а также else пропускаются.
Оператор match-case в Python
Начиная с версии 3.10 в Питоне появился оператор match , который можно использовать как аналог оператора switch , который есть в других языках. На самом деле возможности match немного шире.
В match множественное ветвление организуется с помощью веток case :
match имя_переменной: case значение_1: действия case значение_2: действия …
Слова match-case можно перевести как «соответствовать случаю». То есть, если значение переменной или выражения при match соответствует значению при каком-либо case , то выполнятся действия, вложенные в этот case .
В отличие от if-elif здесь нельзя использовать логические выражения. После case должен находится литерал, конкретное значение, выражение, возвращающее однозначный результат.
Рассмотрим программу, в которой реализовать множественное ветвление с помощью match-case удобнее, чем через if-elif-else:
sign = input('Знак операции: ') a = int(input('Число 1: ')) b = int(input('Число 2: ')) match sign: case '+': print(a + b) case '-': print(a - b) case '/': if b != 0: print(round(a / b, 2)) case '*': print(a * b) case _: print('Неверный знак операции')
Здесь значение переменной sign проверяется не на вхождение в какой-либо диапазон, а на точное соответствие заданным строковым литералам. При этом в ветках case уже не надо писать sign == ‘+’ или sign == ‘-‘ , как это пришлось бы делать в программе с if-elif:
if sign == '+': print(a + b) elif sign == '-': print(a - b) elif sign == '/': if b != 0: print(round(a / b, 2)) elif sign == '*': print(a * b) else: print('Неверный знак операции')
Код с match выглядит более ясным.
Оператор match языка Python не имеет ветки else . Вместо нее используется ветка case _ .
При одном case через оператор | можно перечислять несколько значений. Если значение переменной соответствует хотя бы одному из них, тело этого case выполнится.
sign = input('Знак операции: ') match sign: case '+' | '-' | '*': a = int(input('Число 1: ')) b = int(input('Число 2: ')) print(eval(f' ')) case _: print('Неверный знак операции')
В коде выше с помощью функции eval() переданная ей строка выполняется как выражение. Например, если были введены числа 3, 5 и знак *, то получится строка «3 * 5» . Вызов eval(«3 * 5») возвращает число 15.
Практическая работа
- Спишите вариант кода программы «про возраст» c if и тремя ветками elif из урока. Дополните его веткой else , обрабатывающие случаи, когда пользователь вводит числа не входящие в заданные четыре диапазона. Подумайте, почему в первой версии программы (когда использовались не связанные друг с другом условные операторы) нельзя было использовать else , а для обработки не входящих в диапазоны случаев пришлось бы писать еще один if ?
- Усовершенствуйте предыдущую программу, обработав исключение ValueError , возникающее, когда вводится не целое число.
- Напишите программу, которая запрашивает на ввод число. Если оно положительное, то на экран выводится цифра 1. Если число отрицательное, выводится -1. Если введенное число – это 0, то на экран выводится 0. Используйте в коде условный оператор множественного ветвления.
Примеры решения и дополнительные уроки в pdf-версии курса
X Скрыть Наверх
Python. Введение в программирование
if else в Python
Зачастую нам не нужно, чтобы в программе выполнился весь код. Вместо этого мы можем сделать так, чтобы определенный кусочек кода запускался только при выполнении определенного условия, а другая часть кода запускалась, если условие не выполнено. Вот тут и пригодятся условные операторы if и else.
Условные операторы if else в Python позволяют четко и компактно управлять логическим потоком программы. Они представляют собой ответвления – как развилки на дороге – которые изменяют способ выполнения кода и управляют процессом принятия решений.
Сегодня мы рассмотрим основы работы с операторами if , if. else и elif в Python, а также разберем всё на примерах.
Итак, давайте начнем!
Синтаксис базового оператора if
Оператор if в Python, по существу, говорит:
«Если это выражение оценивается как верное ( True ), то нужно запустить один раз код, следующий за выражением if . Если это выражение ложно (т.е. False ), то этот блок кода запускать не нужно».
Общий синтаксис if -блока выглядит следующим образом:
if условие: выполняй вот этот блок
Состав if -блока:
- Ключевое слово if , с которого и начинается блок кода.
- Затем идет условие. Его значение может оцениваться как истинное ( True ) или ложное ( False ). Круглые скобки вокруг условия необязательны, но они помогают улучшить читаемость кода, когда присутствует более одного условия.
- Двоеточие отделяет условие от следующих за ним инструкций.
- Новая строка и отступ из 4 пробелов (размер отступа оговорен в соглашениях по стилю Python).
- Наконец, идет само тело конструкции. Это код, который будет запускаться только в том случае, если наше условие выполняется, т.е. имеет значение True . В теле может быть несколько инструкций. В этом случае нужно быть внимательным: все они должны иметь одинаковый уровень отступа.
Возьмем следующий пример:
a = 1 b = 2 if b > a: print(" b is in fact bigger than a") # Output: b is in fact bigger than a
В приведенном выше примере мы создали две переменные, a и b , и присвоили им значения 1 и 2 соответственно.
Фраза в операторе print() выводится в консоль, потому что условие b > a оценивается как True . Раз условие истинно, следующий за ним код запускается. А если бы a было больше b , ничего бы не случилось. Код бы не запустился и ничего бы не вывелось в консоль.
a = 1 b = 2 if a > b print("a is in fact bigger than b")
Поскольку у нас a меньше b , условие оценивается как False , и в консоль ничего не выводится.
Как работает оператор if else в Python?
Оператор if запускает код только при выполнении условия. Иначе ничего не происходит.
Если же мы хотим, чтобы какая-то часть кода запускалась, когда условие не выполняется, нам нужен еще один оператор – else .
Синтаксис блока if..else выглядит следующим образом:
if условие: выполнить, если условие истинно else: выполнить, если условие ложно
По сути оператор if..else в Python говорит:
«Когда выражение после if оценивается как истинное ( True ), нужно выполнить следующий за ним код. Но если оно оценивается как ложное ( False ), нужно выполнить код, следующий за оператором else ».
Оператор else записывается на новой строке после последней строки кода с отступом и не может быть записан сам по себе. Оператор else является частью оператора if .
Код, следующий за else , также должен иметь отступ в 4 пробела, чтобы показать, что он является частью конструкции else .
Код, следующий за оператором else , выполняется только тогда, когда условие в if имеет значение False . Если условие в блоке if имеет значение True и, следовательно, запущен код после if , то код в блоке else не запустится.
a = 1 b = 2 if a < b: print(" b is in fact bigger than a") else: print("a is in fact bigger than b")
Здесь строка кода, следующая за оператором else , print(" a is in fact bigger than b") никогда не будет запущена. Условие в блоке if имеет значение True , поэтому выполняется только эта часть кода.
Блок else запускается в следующем случае:
a = 1 b = 2 if a > b: print(" a is in fact bigger than b") else: print("b is in fact bigger than a") # Output: b is in fact bigger than a
Имейте в виду, что нельзя написать какой-либо другой код между if и else . Вы получите SyntaxError , если сделаете это:
if 1 > 2: print("1 is bigger than 2") print("hello world") else: print("1 is less than 2") # Output: # File "", line 3 # print("hello world") # ^ # SyntaxError: invalid syntax
От редакции Pythonist. Также рекомендуем почитать «Блок else в циклах».
Как работает elif в Python?
Что, если мы хотим иметь больше, чем два варианта?
Вместо того, чтобы говорить: «Если первое условие истинно, сделай одно, в противном случае сделай другое», мы говорим: «Если это условие не истинно, попробуй другое, но если все условия не выполняются, сделай вот это».
elif означает else + if .
Базовый синтаксис данной конструкции выглядит так:
if первое_условие: выполнить одно elif второе_условие: выполнить другое else: выполнить это, если все предыдущие условия ложны
Мы можем использовать более одного оператора elif . Это дает нам больше условий и больше возможностей.
x = 1 if x > 10: print(" x is greater than 10!") elif x < 10: print("x is less than 10!") elif x < 20 : print("x is less than 20!") else: print("x is equal to 10") # Output: x is less than 10!
В этом примере оператор if проверяет конкретное условие, блоки elif – это две альтернативы, а блок else — последнее решение, если все предыдущие условия не были выполнены.
Важно помнить о порядке, в котором вы пишете свои условия elif .
В предыдущем примере, если бы мы написали:
x = 1 if x > 10: print(" x is greater than 10!") elif x < 20 : print("x is less than 20!") elif x < 10: print("x is less than 10!") else: print("x is equal to 10")
была бы выведена строка x is less than 20! , потому что это условие стояло раньше.
Оператор elif упрощает написание кода. Вы можете использовать его вместо многочисленных операторов if..else , которые быстро «плодятся» по мере роста и усложнения программ.
Если все операторы elif не рассматриваются и имеют значение False , тогда и только тогда будет выполняться код, следующий за оператором else .
Например, вот случай, когда будет выполняться инструкция else :
x = 10 if x > 10: print(" x is greater than 10!") elif x < 10: print("x is less than 10!") elif x >20 : print("x is greater than 20!") else: print("x is equal to 10") # Output: x is equal to 10
Заключение
Это основные принципы if , if..else и elif в Python, которые помогут вам начать работу с условными операторами.
В дальнейшем конструкции могут быть более сложными.
Условные операторы также могут быть вложены в другие условные операторы, в зависимости от проблемы, которую вы пытаетесь решить, и логики вашего решения.
Спасибо за чтение и успехов в написании кода!
Как работает команда if в python
Условный оператор if позволяет выполнить определенный набор инструкций в зависимости от некоторого условия. Использовать этот оператор можно в нескольких вариантах. В этом видео разберем только 2 варианта.
1 Конструкция if
В простейшем варианте использование оператора if выглядит так:
if условие: блок команд 1 блок команд 2 После оператора if обязательно записывается условие. После условия необходимо поставить знак двоеточия “:”. Если данное условие будет истинно, то выполняется блок команд 1. Вне зависимости от условия блок команд 2 будет выполняться в любом случае.
Рассмотрим пример
if a==777: print("Этот принт сработает, если а будет равно 777.") print("И так же этот принт.") print("И этот.") print("А это сообщение выведется в любом случае") Здесь 3 команды, сдвинутые отступами, будут выполняться только в том случае, если переменная а будет равна 777. А последняя команда будет выполняться в любом случае, т.к. по оступам она стоит на том же уровне, что и оператор if, тем самым как бы закрывая собой блок команд внутри условного оператора.
Еще пример
money = 100 ticket = 90 if money > ticket: print("УРАААА. ") print("Я иду в кино!") print("Пора идти домой") Что касается отступов. Внутри блока инструкции должны находиться на одинаковом уровне отступов. В противном случае будет ошибка.
if 5>1: print("Тут оступ в 2 пробела.") print("А здесь в четыре. Будет ошибка.") Пример программы:
Программа получает на вход 2 числа, и нужно перераспределить эти 2 значения таким образом, чтобы в первой переменной оказалось большее значение.
a=int(input()) b=int(input()) if b>a: a,b = b,a print(a,b) 2 Конструкция if-else
В состав оператора if может входить необязательный оператор else. Схема использования выглядит следующим образом:
if условие: блок команд 1 else: блок команд 2 блок команд 3 Инструкции, входящие в блок команд 1, будут выполняться только в случае, если условие будет истинно. В противном случае будет выполняться блок команд 2. А блок команд 3 выполнится после этого в любом случае.
Пример программы на if-else
Вводится одно число и необходимо вывести сообщение "Четное", если число делится на 2 без остатка, или "Нечетное" - в противном случае
a = int(input()) if a%2==0: print('Четное') else: print('Нечетное') Еще пример программы на if-else
Вводится два числа и необходимо вывести самое большое значение среди них.
a = int(input()) b = int(input()) if a>b: print(a) else: print(b) Вопросы для проверки пройденного:
- 1 Исправьте следующий код:
score = int(input("Ваш балл за экзамен") if score > 80: print("Хороший результат.")x == 7 if x % 2 !=0: print("x - нечетное число.") else print("x - четное число.")3 В этом коде четыре ошибки. Скопируйте код в IDLE и найдите ошибки.
day = input("Как называется 5й день недели?") if day = "Friday" or d=="friday": print("Верно!") else print("Неверно!")4 Подумайте почему эта программа неправильно работает.
x=input("Как настроение?") if x=="Хорошо" or "Прекрасно": print("Приятно слышать!")Оператор if else в Python
При изучении программирования в качестве практики часто приходится создавать «идеальные программы», которые в реальном мире работают совсем не так.
Иногда, например, нужно исполнить ряд инструкций только в том случае, если соблюдаются определенные условия. Для обработки таких ситуаций в языках программирования есть операторы управления. В дополнение к управлению потоком выполнения программы эти операторы используются для создания циклов или пропуска инструкций, когда какое-то условие истинно.
Операторы управления бывают следующих типов:
- Оператор-выражение if
- Оператор-выражение if-else
- Оператор-выражение if-elif-else
- Цикл while
- Цикл for
- Оператор-выражение break
- Оператор-выражение continue
В этом уроке речь пойдет о первых трех операторах управления.
Оператор if
Синтаксис оператора if следующий:
if condition: indented statement 1> indented statement 2> non-indented statement> Первая строчка оператора, то есть if condition : — это условие if, а condition — это логическое выражение, которое возвращает True или False . В следующей строке блок инструкций. Блок представляет собой одну или больше инструкций. Если он идет следом за условием if, такой блок называют блоком if.
Стоит обратить внимание, что у каждой инструкции в блоке if одинаковый отступ от слова if. Многие языки, такие как C, C++, Java и PHP, используют фигурные скобки ( <> ), чтобы определять начало и конец блока, но в Python используются отступы.
Каждая инструкция должна содержать одинаковое количество пробелов. В противном случае программа вернет синтаксическую ошибку. В документации Python рекомендуется делать отступ на 4 пробела. Такая рекомендация актуальная для и для этого .
Как это работает:
Когда выполняется инструкция if, проверяется условие. Если условие истинно, тогда все инструкции в блоке if выполняются. Но если условие оказывается неверным, тогда все инструкции внутри этого блока пропускаются.
Инструкции следом за условием if, у которых нет отступов, не относятся к блоку if. Например, — это не часть блока if, поэтому она будет выполнена в любом случае.
number = int(input("Введите число: ")) if number > 10: print("Число больше 10") Введите число: 100 Число больше 10 Введите число: 5 Стоит обратить внимание, что во втором случае, когда условие не истинно, инструкция внутри блока if пропускается. В этом примере блок if состоит из одной инструкции, но их может быть сколько угодно, главное — делать отступы.
Рассмотрим следующий код:
number = int(input("Введите число: ")) if number > 10: print("первая строка") print("вторая строка") print("третья строка") print("Выполняется каждый раз, когда вы запускаете программу") print("Конец") Введите число: 45 первая строка вторая строка третья строка Выполняется каждый раз, когда вы запускаете программу Конец Введите число: 4 Выполняется каждый раз, когда вы запускаете программу Конец Здесь важно обратить внимание, что только выражения на строках 3, 4 и 5 относятся к блоку if. Следовательно, они будут исполнены только в том случае, когда условие if будет истинно. Но инструкции на строках 7 и 8 выполнятся в любом случае.
Консоль Python реагирует иначе при использовании операторов управления прямо в ней. Стоит напомнить, что для разбития выражения на несколько строк используется оператор продолжение ( \ ). Но в этом нет необходимости с операторами управления. Интерпретатор Python автоматически активирует мультистрочный режим, если нажать Enter после условия if. Например:
>>> >>> n = 100 >>> if n > 10: ... После нажатия Enter на строке с условием if командная строка преобразуется с >>> на … . Консоль Python показывает … для многострочных инструкций. Это значит, что начатая инструкция все еще не закончена.
Чтобы закончить инструкцию if, нужно добавить еще одну инструкцию в блок if:
>>> >>> n = 100 >>> if n > 10: ... print("n v 10") ... Python не будет автоматически добавлять отступ. Это нужно сделать самостоятельно. Закончив ввод инструкции, нужно дважды нажать Enter, чтобы исполнить инструкцию. После этого консоль вернется к изначальному состоянию.
>>> >>> n = 100 >>> if n > 10: ... print("n больше чем 10") ... n больше чем 10 >>> Все эти программы заканчиваются внезапно, не показывая ничего, если условие не истинно. Но в большинстве случаев пользователю нужно показать хотя бы что-нибудь. Для этого используется оператор-выражение if-else.
Оператор if-else
Оператор if-else исполняет одну порцию инструкций, если условие истинно и другое — если нет. Таким образом этот оператор предлагает два направления действий. Синтаксис оператора if-else следующий:
if condition: # блок if statement 1 statement 2 and so on else: # блок else statement 3 statement 4 and so on: Как это работает:
Когда оператор if-else исполняется, условие проверяется, и если оно возвращает True , когда инструкции в блоке if исполняются. Но если возвращается False , тогда исполняются инструкции из блока else.
Пример 1: программа для расчета площади и длины окружности круга.
radius = int(input("Введите радиус: ")) if radius >= 0: print("Длина окружности token punctuation">, 2 * 3.14 * radius) print("Площадь token punctuation">, 3.14 * radius ** 2) else: print("Пожалуйста, введите положительное число") Введите радиус: 4 Длина окружности = 25.12 Площадь = 50.24 Введите радиус: -12 Пожалуйста, введите положительное число Теперь программа показывает корректный ответ пользователю, даже если условие if не является истинным. Это и требуется.
В инструкциях if-else нужно следить за тем, чтобы условия if и else находились на одном уровне. В противном случае программа вернет синтаксическую ошибку. Например:
radius = int(input("Введите радиус: ")) if radius >= 0: print("Длина окружности token punctuation">, 2 * 3.14 * radius) print("Площадь token punctuation">, 3.14 * radius ** 2) else: print("Пожалуйста, введите положительное число") Если попробовать запустить эту программу, то появится следующая ошибка:
$ python3 if_and_else_not_aligned.py File "if_and_else_not_aligned.py", line 6 else: ^ SyntaxError: invalid syntax $ Для исправления проблемы нужно вертикально выровнять if и else
Пример 2: программа для проверки пароля, введенного пользователем.
password = input("Введите пароль: ") if password == "sshh": print("Добро пожаловать") else: print("Доступ запрещен") Введите пароль: sshh Добро пожаловать Введите пароль: abc Доступ запрещен Вложенные операторы if и if-else
Использовать операторы if-else можно внутри других инструкций if или if-else. Это лучше объяснить на примерах:
Оператор if внутри другого if-оператора
Пример 1: программа, проверяющая, имеет ли студент право на кредит.
gre_score = int(input("Введите текущий лимит: ")) per_grad = int(input("Введите кредитный рейтинг: ")) if per_grad > 70: # внешний блок if if gre_score > 150: # внутренний блок if print("Поздравляем, вам выдан кредит") else: print("Извините, вы не имеете права на кредит") Здесь оператор if используется внутри другого if-оператора. Внутренним называют вложенный оператором if. В этом случае внутренний оператор if относится к внешнему блоку if, а у внутреннего блока if есть только одна инструкция, которая выводит “Поздравляем, вам выдан кредит”.
Как это работает:
Сначала оценивается внешнее условие if, то есть per_grad > 70 . Если оно возвращает True , тогда управление программой происходит внутри внешнего блока if. Там же проверяется условие gre_score > 150 . Если оно возвращает True , тогда в консоль выводится "Congratulations you are eligible for loan" . Если False , тогда программа выходит из инструкции if-else, чтобы исполнить следующие операции. Ничего при этом не выводится в консоль.
При этом если внешнее условие возвращает False , тогда выполнение инструкций внутри блока if пропускается, и контроль переходит к блоку else (9 строчка).
Введите текущий лимит: 160 Введите кредитный рейтинг: 75 Поздравляем, вам выдан кредит Введите текущий лимит: 160 Введите кредитный рейтинг: 60 Извините, вы не имеете права на кредит У этой программы есть одна маленькая проблема. Запустите ее заново и введите gre_score меньше чем 150 , а per_grade — больше 70 :
Введите текущий лимит: 140 Введите кредитный рейтинг: 80 Программа не выводит ничего. Причина в том, что у вложенного оператора if нет условия else. Добавим его в следующем примере.
Пример 2: инструкция if-else внутри другого оператора if.
gre_score = int(input("Введите текущий лимит: ")) per_grad = int(input("Введите кредитный рейтинг: ")) if per_grad > 70: if gre_score > 150: print("Поздравляем, вам выдан кредит") else: print("У вас низкий кредитный лимит") else: print("Извините, вы не имеете права на кредит") Введите текущий лимит: 140 Введите кредитный рейтинг: 80 У вас низкий кредитный лимит Как это работает:
Эта программа работает та же, как и предыдущая. Единственное отличие — у вложенного оператора if теперь есть инструкция else. Теперь если ввести балл GRE меньше, чем 150, программа выведет: “У вас низкий кредитный лимит”
При создании вложенных операторов if или if-else, всегда важно помнить об отступах. В противном случае выйдет синтаксическая ошибка.
Оператор if-else внутри условия else
Пример 3: программа для определения оценки студента на основе введенных баллов.
score = int(input("Введите вашу оценку: ")) if score >= 90: print("Отлично! Ваша оценка А") else: if score >= 80: print("Здорово! Ваша оценка - B") else: if score >= 70: print("Хорошо! Ваша оценка - C") else: if score >= 60: print("Ваша оценка - D. Стоит повторить материал.") else: print("Вы не сдали экзамен") Введите вашу оценку: 92 Отлично! Ваша оценка А Введите вашу оценку: 72 Хорошо! Ваша оценка - C Введите вашу оценку: 56 Вы не сдали экзамен Как это работает:
Когда управление программой переходит к оператору if-else, проверяется условие на строке 3 ( score >= 90 ). Если оно возвращает True , в консоль выводится “Отлично! Ваша оценка А”. Если значение неверное, управление переходит к условию else на 5 строке. Теперь проверяется условие score >= 80 (6 строка). Если оно верное, тогда в консоли выводится “Здорово! Ваша оценка — B”.
В противном случае управление программой переходит к условию else на 8 строке. И здесь снова имеется вложенный оператор if-else. Проверяется условие ( score >= 70 ). Если оно истинно, тогда в консоль выводится “Хорошо! Ваша оценка — C”. В противном случае управление переходит к блоку else на 11 строке. В конце концов, проверяется условие ( score >= 60 ). Если оно возвращает True , тогда в консоль выводится “Ваша оценка — D. Стоит повторить материал.” Если же False , тогда в консоли будет “Вы не сдали экзамен”. На этом этапе управление переходит к следующим инструкциям, написанным после внешнего if-else.
Хотя вложенные операторы if-else позволяют проверять несколько условий, их довольно сложно читать и писать. Эти же программы можно сделать более читабельными и простыми с помощью if-elif-else.
Оператор if-elif-else
Оператор if-elif-else — это альтернативное представление оператора if-else, которое позволяет проверять несколько условий, вместо того чтобы писать вложенные if-else. Синтаксис этого оператора следующий:
if condition_1: # блок if statement statement more statement elif condition_2: # первый блок elif statement statement more statement elif condition_3: # второй блок elif statement statement more statement ... else statement statement more statement Примечание: … означает, что можно писать сколько угодно условий eilf .
Как это работает:
Когда исполняется инструкция if-elif-else, в первую очередь проверяется condition_1 . Если условие истинно, тогда исполняется блок инструкций if. Следующие условия и инструкции пропускаются, и управление переходит к операторам вне if-elif-else.
Если condition_1 оказывается ложным, тогда управление переходит к следующему условию elif , и проверяется condition_2 . Если оно истинно, тогда исполняются инструкции внутри первого блока elif . Последующие инструкции внутри этого блока пропускаются.
Этот процесс повторяется, пока не находится условие elif , которое оказывается истинным. Если такого нет, тогда исполняется блок else в самом конце.
Перепишем программу с помощью if-elif-else.
score = int(input("Введите вашу оценку: ")) if score >= 90: print("Отлично! Ваша оценка А") elif score >= 80: print("Здорово! Ваша оценка - B") elif score >= 70: print("Хорошо! Ваша оценка - C") elif score >= 60: print("Ваша оценка - D. Стоит повторить материал.") else: print("Вы не сдали экзамен") Введите вашу оценку: 78 Хорошо! Ваша оценка - C Введите вашу оценку: 91 Отлично! Ваша оценка А Введите вашу оценку: 55 Вы не сдали экзамен Такую программу намного легче читать, чем в случае с вложенными if-else.