Что делает условный оператор в python

Ветвление. Условный оператор

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

Однако чаще в программах бывает не так. При выполнении кода, в зависимости от тех или иных условий, некоторые его участки могут быть опущены, в то время как другие – выполнены. Иными словами, в программе может присутствовать ветвление, которое реализуется условным оператором – особой конструкцией языка программирования.

Проведем аналогию с реальностью. Человек живет по расписанию. Можно сказать, расписание – это алгоритм для человека, его программный код, подлежащий выполнению. В расписании на 18.00 стоит поход в бассейн. Однако экземпляр биоробота класса Homo sapiens через свои рецепторы-сенсоры получает информацию, что воду из бассейна слили. Разумно было бы отменить занятие по плаванию, то есть изменить ход выполнения программы-расписания. Одним из условий посещения бассейна должно быть его функционирование, иначе должны выполняться другие действия.

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

if логическое_выражение

Перевести на человеческий язык можно так: если логическое выражение возвращает истину, то выполняются выражения внутри фигурных скобок; если логическое выражение возвращает ложь, то код внутри фигурных скобок не выполняется. С английского «if» переводится как «если».

Конструкция if логическое_выражение называется заголовком условного оператора. Выражения внутри фигурных скобок – телом условного оператора. Тело может содержать как множество выражений, так и всего одно.

Пример использования условного оператора в языке программирования Python:

if n  100: a = a + b

В Питоне вместо фигурных скобок используется двоеточие. Обособление вложенного кода, то есть тела оператора, достигается за счет отступов. В программировании принято делать отступ равным четырем пробелам. Можно использовать клавишу табуляции ( Tab ) на клавиатуре.

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

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

Python считается языком с ясным синтаксисом и легко читаемым кодом. Это достигается сведением к минимуму таких вспомогательных элементов как различные скобки и точка с запятой. Для разделения выражений используется переход на новую строку, а для обозначения вложенных выражений – отступы от начала строки. В других языках данный стиль программирования также используется, но лишь для удобочитаемости кода человеком. В Питоне же такой стиль возведен в ранг синтаксического правила.

Данный пример вырван из контекста и сам по-себе не является рабочим. Полная версия программы могла бы выглядеть так:

a = 50 b = 10 n = 98 if n  100: a = a + b print(a)

Последняя строчка кода print(a) уже не относится к условному оператору, что обозначено отсутствием перед ней отступа. Она не является вложенной в условный оператор, значит, не принадлежит ему.

Поскольку переменная n равна 98, а это меньше 100, то a станет равной 60. Это значение будет выведено на экран. Если переменная n изначально была бы связана, например, со значением 101, то на экран было бы выведено 50. Потому что при n , равной 101, логическое выражение в заголовке условного оператора вернуло бы ложь. Значит, тело не было бы выполнено, и переменная a не изменилась бы.

Структуру программы можно изобразить следующим образом:

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

Для небольших программ иногда чертят так называемые блок-схемы, отражающие алгоритм выполнения. В языке блок-схем различные части кода обозначаются своими фигурами. Так блоку последовательно выполняемых действий соответствует прямоугольник, ветвлению – ромб. Для кода выше блок-схема может выглядеть так:

Условный оператор может включать не одну ветку, а две, реализуя тем самым полноценное ветвление.

В случае возврата логическим выражением False поток выполнения программы не возвращается сразу в основную ветку. На случай False существует другой вложенный код, отличный от случая True . Другими словами, встретившись с расширенной версией условного оператора, поток выполнения программы не вернется в основную ветку, не выполнив хоть какой-нибудь вложенный код.

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

if логическое_выражение < выражение 1; выражение 2; … >else

Если условие при инструкции if оказывается ложным, то выполняется блок кода при инструкции else . Ситуация, при которой бы выполнились обе ветви, невозможна. Либо код, принадлежащий if , либо код, принадлежащий еlse . Никак иначе. В заголовке else никогда не бывает логического выражения.

Пример программы с веткой else на языке Python:

tovar1 = 50 tovar2 = 32 if tovar1 + tovar2 > 99: print("99 рублей недостаточно") else: print("Чек оплачен") 

Следует иметь в виду, что логическое выражение при if может выглядеть нестандартно, то есть не так просто, как a > b и тому подобное. Там может стоять просто одна переменная, число, слово True или False , а также сложное логическое выражение, когда два простых соединяются через логически and или or .

a = ? if a: a = 1

Если вместо знака вопроса будет стоять 0, то с логической точки зрения это False , значит выражение в if не будет выполнено. Если a будет связано с любым другим числом, то оно будет расцениваться как True , и тело условного оператора выполнится. Другой пример:

a = 5 > 0 if a: print(a)

Здесь a уже связана с булевым значением. В данном случае это True . Отметим, что в выражении a = 5 > 0 присваивание выполняется после оператора сравнения, так что подвыражение 5 > 0 выполнится первым, после чего его результат будет присвоен переменной a . На будущее, если вы сомневаетесь в последовательности выполнения операторов, используйте скобки, например так: a = (5 > 0) .

if a > 0 and a  b: print(b - a)

Тут, чтобы вложенный код выполнился, a должно быть больше нуля и одновременно меньше b . Также в Питоне, в отличие от других языков программирования, позволительна такая сокращенная запись сложного логического выражения:

if 0  a  b: print(b - a)

Практическая работа

1. Напишите программу, которая просит пользователя что-нибудь ввести с клавиатуры. Если он вводит какие-нибудь данные, то на экране должно выводиться сообщение «ОК». Если он не вводит данные, а просто нажимает Enter , то программа ничего не выводит на экран.
2. Напишите программу, которая запрашивает у пользователя число. Если оно больше нуля, то в ответ на экран выводится число 1. Если введенное число не является положительным, то на экран должно выводиться -1.

Примеры решения и дополнительные уроки в pdf-версии курса

X Скрыть Наверх

Python. Введение в программирование

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

Условные конструкции предоставляют возможность выполнить проверку условия и в зависимости от результата выполнить определенный участок кода. За урок мы научимся использовать if-else, а также тернарный оператор в языке Python.

Видеоурок

Что такое условные операторы?

Они отвечают за изменение поведения программы в зависимости от входных параметров, определённых в проверке. Проще говоря: если будет число 1, то программа запустит скрипт one, а если число 2 – скрипт two. Внутри условных операторов могут быть другие такие же условия для уточнения полученных данных. В рамках одного оператора можно сразу проверить пару условий. Для того, чтобы проверить несколько условий нужно их разделить элементом and (логическое и).

Пример создания условия:

a = 2 if a != 0 and a != 1: print ("Проверка сработала")

На экране будет показана запись лишь в том случае, когда переменная «a» не будет равна значению 0 и значению 1. То есть обе проверки в операторе должны выдать результат – true.

Есть возможность произвести проверку с помощью or — логическое или. При использовании данного оператора достаточным поводом для запуска сообщения «Заработало» станет соответствие хотя бы одного из условий.

a = 1.1 if a != 1.1 or a > 0: print ("Проверка сработала")

Условный оператор «if-else»

user_data = int(input("Введите число: ")) isHappy = True if isHappy or user_data == 6: print("User is happy") elif user_data == 5: print("Number is 5") elif user_data == 7: print("Number is 7") else: print("User is unhappy") # if user_data != 5: # print("Мы на месте") # if user_data > 6: # print("Number is bigger than 5")

Посмотреть остальной код можно после подписки на проект!

Задание к уроку

Необходимо оформить подписку на проект, чтобы получить доступ ко всем домашним заданиям

Большое задание по курсу

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

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

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

Определение

Условные операторы в Python 3 иногда называют операторами ветвления. Они созданы, чтобы программа могла выбрать, какой инструкции стоит следовать при определенном значении заданной переменной. Условные операторы состоят из заголовка и тела. Заголовок – это сама конструкция и то, что стоит рядом с ним (не в фигурных скобках в других языках программирования или перед двоеточием в Python). Тело – то, что написано после двоеточия. Чтобы программа поняла, что код после него является вложенным, необходимо обязательно сделать отступ в виде четырех пробелов. Обычно они ставятся автоматически, если пользователь работает в специально созданной среде программирования.

Заметим, что пользоваться клавишей Tab для создания отступа крайне нежелательно.

Ситуаций, в которых можно было бы применить условный оператор, великое множество. К ним, например, относится:

• Определение, сдал ли студент экзамен. При количестве верных ответов 10 из 15 – сдал, если меньше – не сдал;
• Выяснение размера скидки. Если купил 10 товаров – скидка 10%, если меньше – скидка не предоставляется.

Оператор if

С английского название этого оператора переводится, как «если». То есть он задает условие. После данного оператора записывается само выражение. Если оно оказывается истинным, то программа переходит к выполнению инструкции, заданной в указанном операторе. Выражение считается истинным, когда оно:

• не равно нулю;
• не является пустым;
• является логическим

Для ясности рассмотрим пример использования if — условия в Python 3:

if 3: print("Привет 3")

На экране перед пользователем появится запись: Привет 3.

a = 6 if a == 6: print("Привет 2")

На дисплее компьютера отобразится: Привет 2.

Также можно задать условие формулой или условным выражением:

a = 5 if a > 2: print("Привет 3")

Переменная равна 5, условие, чтобы она была больше 2. Оно истинное, поэтому перед нами появится: Привет 3.

Еще более сложный вариант с несколькими переменными:

a = 0 b = 34 c = 10 if c < 100: a = b + c print(a)

Поскольку с действительно меньше 100, а станет равным 44, и именно это число появится на дисплее при выполнении данного кода. Если бы с изначально было большее 100, например, 110, то на экране бы отобразился 0, переменная а просто не изменилась бы вообще.

Оператор else

Иногда программе нужно указать, что делать, если условие оказывается ложным. Для этого задается новый набор инструкций и используется конструкция if – else. Кстати, стоит запомнить, что в else не может быть никакого логического выражения. Также невозможна и ситуация, при которой выполнятся обе ветви (и if, и else).

a = 7 if a > 5: print("Да") else: print("Нет")

При выполнении данного кода на компьютере появится: Да. Это происходит, потому что 7 действительно больше заданной в условии цифры 5.

Посмотрим, что же случится, если условие станет ложным. Возьмем тот же код, но изменим переменную а.

a = 3 if a > 5: print("Да") else: print("Нет")

Очевидно, что перед пользователем появится слово «Нет», поскольку 3 не больше 5, а меньше.

product1 = 30 product2 = 23 if product1+ product2 > 70 : print("70 рублей не хватит") else: print("Денег хватает, все оплачено")

В данном случае программист увидит запись: Денег хватает, все оплачено, поскольку 30 + 23 = 53, а это меньше чем 70.

Оператор elif и конструкция if – elif – else

Вообще elif примерно расшифровывается, как else + if. Чтобы можно было реализовать программу, которая выбирала бы из нескольких альтернативных вариантов, используется указанная конструкция.

Рассмотрим код, в котором имеется несколько условий:

if balance < 0: print("Баланс ниже нуля, положите деньги на счет, чтобы Вам не выписали штраф") elif balance == 0: print("Баланс равен нулю, скорее внесите деньги на счет") else: print("Ваш баланс выше нуля, все хорошо")

Так, программа может рассмотреть варианты с тремя условиями. И если переменная balance будет равна 150, то перед пользователем появится надпись: Ваш баланс выше нуля, все хорошо.

Оператор elif позволяет упростить код. Сделать его легче читаемым. Позволяет избежать написание несколько условий if в Python.

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

Иногда для сокращения записи используется так называемый тернарный оператор, благодаря ему код набирается в одну строку. Посмотрим на пример того, как можно записать условие Python в одну строку:

is_happy = True state = "happy" if is_happy else "not happy"

Чтобы не расписывать в несколько строк оператор if, просто используем сжатый вариант.

Конструкция switch – case

Данная инструкция в Python не используется. Вместо этого можно применять конструкции с несколькими elif. Например, программист хочет написать код, чтобы программа ставила оценку за пройденный студентами тест. При этом оценок может быть несколько. Тогда можно оформить так:

if grade >= 50: print("Оценка 5 с плюсом") elif grade >= 45: print("Оценка 5") elif grade >= 35: print("Оценка 4") elif grade >= 25: print("Оценка 3") else: print("Тест провален")

В этом случае значение переменной grade будет сравниваться со всеми условиями подряд. Однако когда условие станет истинным, выполнение кода остановится и на экране появится сообщение об оценке. Например, если grade равен 30, то на дисплей будет выведена надпись: Оценка 3; если же переменная будет ниже 25, то пользователь увидит: Тест провален.

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

Оператор if else в Python

При изучении программирования в качестве практики часто приходится создавать «идеальные программы», которые в реальном мире работают совсем не так.

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

Операторы управления бывают следующих типов:

1. Оператор-выражение if
2. Оператор-выражение if-else
3. Оператор-выражение if-elif-else
4. Цикл while
5. Цикл for
6. Оператор-выражение break
7. Оператор-выражение 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.