Условные операторы
Программа может выполняться постепенно: строка за строкой, выражение за выражением от начала и до конца, не пропуская ни единой строки кода. Но такое в реальности происходит редко. Зачастую необходимо ввести вариативность, чтобы при выполнении определенного условия, происходило одно, а при его невыполнении – другое. Так применяются условные операторы.
Определение
Условные операторы в 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 python
Все ранее рассматриваемые программы имели линейную структуру: все инструкции выполнялись последовательно одна за одной, каждая записанная инструкция обязательно выполняется.
Допустим мы хотим по данному числу x определить его абсолютную величину (модуль). Программа должна напечатать значение переменной x, если x>0 или же величину -x в противном случае. Линейная структура программы нарушается: в зависимости от справедливости условия x>0 должна быть выведена одна или другая величина. Соответствующий фрагмент программы на Питоне имеет вид:
x = int(input()) if x > 0: print(x) else: print(-x)
В этой программе используется условная инструкция if (если). После слова if указывается проверяемое условие (x > 0) , завершающееся двоеточием. После этого идет блок (последовательность) инструкций, который будет выполнен, если условие истинно, в нашем примере это вывод на экран величины x . Затем идет слово else (иначе), также завершающееся двоеточием, и блок инструкций, который будет выполнен, если проверяемое условие неверно, в данном случае будет выведено значение -x .
Итак, условная инструкция в Питоне имеет следующий синтаксис:
if Условие: Блок инструкций 1 else: Блок инструкций 2
Блок инструкций 1 будет выполнен, если Условие истинно. Если Условие ложно, будет выполнен Блок инструкций 2 .
В условной инструкции может отсутствовать слово else и последующий блок. Такая инструкция называется неполным ветвлением. Например, если дано число x и мы хотим заменить его на абсолютную величину x , то это можно сделать следующим образом:
x = int(input()) if x < 0: x = -x print(x)
В этом примере переменной x будет присвоено значение -x , но только в том случае, когда x
Для выделения блока инструкций, относящихся к инструкции if или else в языке Питон используются отступы. Все инструкции, которые относятся к одному блоку, должны иметь равную величину отступа, то есть одинаковое число пробелов в начале строки. Рекомендуется использовать отступ в 4 пробела и не рекомедуется использовать в качестве отступа символ табуляции.
Это одно из существенных отличий синтаксиса Питона от синтаксиса большинства языков, в которых блоки выделяются специальными словами, например, нц. кц в Кумире, begin. end в Паскале или фигурными скобками в Си.
2. Вложенные условные инструкции
Внутри условных инструкций можно использовать любые инструкции языка Питон, в том числе и условную инструкцию. Получаем вложенное ветвление – после одной развилки в ходе исполнения программы появляется другая развилка. При этом вложенные блоки имеют больший размер отступа (например, 8 пробелов). Покажем это на примере программы, которая по данным ненулевым числам x и y определяет, в какой из четвертей координатной плоскости находится точка (x,y):
x = int(input()) y = int(input()) if x > 0: if y > 0: # x > 0, y > 0 print("Первая четверть") else: # x > 0, y < 0 print("Четвертая четверть") else: if y >0: # x < 0, y >0 print("Вторая четверть") else: # x < 0, y < 0 print("Третья четверть")
В этом примере мы использовали комментарии – текст, который интерпретатор игнорирует. Комментариями в Питоне является символ # и весь текст после этого символа до конца строки.
3. Операторы сравнения
Как правило, в качестве проверяемого условия используется результат вычисления одного из следующих операторов сравнения: < Меньше — условие верно, если первый операнд меньше второго.
> Больше — условие верно, если первый операнд больше второго.
>= Больше или равно.
== Равенство. Условие верно, если два операнда равны.
!= Неравенство. Условие верно, если два операнда неравны.
Операторы сравнения в Питоне можно объединять в цепочки (в отличии от большинства других языков программирования, где для этого нужно использовать логические связки), например, или .
4. Тип данных bool
Операторы сравнения возвращают значения специального логического типа bool . Значения логического типа могут принимать одно из двух значений: True (истина) или False (ложь). Если преобразовать логическое True к типу int , то получится 1, а преобразование False даст 0. При обратном преобразовании число 0 преобразуется в False , а любое ненулевое число в True . При преобразовании str в bool пустая строка преобразовывается в False , а любая непустая строка в True .
4.1. Логические операторы
Иногда нужно проверить одновременно не одно, а несколько условий. Например, проверить, является ли данное число четным можно при помощи условия (n % 2 == 0) (остаток от деления n на 2 равен 0 ), а если необходимо проверить, что два данных целых числа n и m являются четными, необходимо проверить справедливость обоих условий: n % 2 == 0 и m % 2 == 0 , для чего их необходимо объединить при помощи оператора and (логическое И): n % 2 == 0 and m % 2 == 0 .
В Питоне существуют стандартные логические операторы: логическое И, логическое ИЛИ, логическое отрицание.
является бинарным оператором (то есть оператором с двумя операндами: левым и правым) и имеет вид and . Оператор and возвращает True тогда и только тогда, когда оба его операнда имеют значение True .
является бинарным оператором и возвращает True тогда и только тогда, когда хотя бы один операнд равен True . Оператор “логическое ИЛИ” имеет вид or .
(отрицание) является унарным (то есть с одним операндом) оператором и имеет вид not , за которым следует единственный операнд. Логическое НЕ возвращает True , если операнд равен False и наоборот.
Пример. Проверим, что хотя бы одно из чисел a или b оканчивается на 0:
15 40
a = int(input()) b = int(input()) if a % 10 == 0 or b % 10 == 0: print('YES') else: print('NO')
Проверим, что число a — положительное, а b — неотрицательное:
if a > 0 and not (b < 0):
Или можно вместо not (b < 0) записать (b >= 0) .
Множественное ветвление: 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
Программа, код которой вы видите выше, оценивает значение `выражение`, которое может быть равно True или False . Программа выполнит оператор(ы), только если выражение = True . Если выражение = False , этот кусок кода не будет выполняться.
В Python тело конструкции if обозначается отступами. Тело начинается с первой строки с отступом и заканчивается первой строкой без отступа.
Работая с условной конструкцией, важно знать, что Python интерпретирует ненулевые значения как True . None и 0 интерпретируются как False .
Блок-схема конструкции
Пример использования конструкции
# Если число положительно, мы выведем на экран соответствующее сообщение. num = 3 if num > 0: print(num, "— положительное число.") print("Это сообщение напечатается в любом случае.") num = -1 if num > 0: print(num, "— положительное число.") print("Это сообщение тоже напечатается в любом случае.") Вывод:
3 — положительное число.
Это сообщение выведется в любом случае.
Это сообщение тоже выведется в любом случае.
В примере выше num > 0 — выражение, которое проверяется на истинность. Только если это выражение окажется истинным, т.е. True , выполнится тело оператора if .
При num = 3 выражение num > 0 истинно, поэтому Python выполнит оператор, находящийся в теле if. Вот почему на экран выводится сообщение «3 — положительное число».
При num = -1 выражение num > 0 ложно, поэтому Python проигнорирует оператор, находящийся в теле if.
А вот функции вывода на экран print("Это сообщение выведется в любом случае.") и print("Это сообщение тоже выведется в любом случае.") находятся вне блока if, поэтому выполняются при любых значениях num .
Конструкция if. else
Синтаксис конструкции
if выражение:
Тело if
else:
Тело else
Оператор if. else оценивает выражение и выполняет тело if только в том случае, если выражение (условие) истинно, то есть равно True .
Если выражение равно False , выполняется тело else . Для разделения этих блоков используются отступы.
Блок-схема конструкции
Пример использования конструкции
# Программа проверяет, является ли число положительным # или отрицательным и выводит соответствующее сообщение. num = 3 # Также попробуйте следующие два варианта. # num = -5 # num = 0 if num >= 0: print("Число больше либо равно 0") else: print("Отрицательное число") Вывод:
Число больше либо равно 0
В приведенном выше примере при num = 3 выражение истинно, поэтому выполняется тело if , а тело else игнорируется.
При num = -5 выражение ложно, поэтому выполняется тело else . В этом слуае игнорируется тело if .
При num = 0 выражение истинно, поэтому выполняет тело равно if , а тело else игнорируется.
Конструкция if. elif. else
Синтаксис конструкции
if выражение_1:
Тело if
elif выражение_2:
Тело elif
else:
Тело else
elif — это сокращение от else if . Этот оператор позволяет нам проверять сразу несколько выражений.
Если условие для if = False , Python оценивает условие блока elif и так далее. Если все условия = False , выполняется тело else .
Для одного if может быть только один else . Но внутри конструкции if. else может быть сколько угодно блоков elif .
Блок-схема конструкции
Пример использования конструкции
# В этой программе мы проверяем, # является ли число положительным, # отрицательным или нулем и # выводим соответствующее выражение. num = 3.4 # Также попробуйте такие варианты: # num = 0 # num = -4.5 if num > 0: print("Положительное число") elif num == 0: print("Ноль") else: print("Отрицательное число") Если переменная num содержит положительное значение, Python выведет на экран сообщение «Положительное число».
Если num равно 0, напечатается сообщение «Ноль».
Если num содержит отрицательное значение, Python выведет на экран сообщение «Отрицательное число».
Вложенные конструкции
Любое количество блоков if…elif…else можно разместить внутри другого оператора if…elif…else . Отступы — единственный способ отделять разные уровни вложенности. Это делает код сложнее для понимания, поэтому загроможденной вложенности желательно избегать.
# В этой программе мы вводим число, # проверяем, является ли число положительным, # отрицательным или нулем, и выводим # соответствующее сообщение. # На этот раз мы используем вложенную конструкцию. num = float(input("Введите число: ")) if num >= 0: if num == 0: print("Ноль") else: print("Положительное число") else: print("Отрицательное число") Вывод 1:
Введите число: 5
Положительное число
Вывод 2:
Введите число: -1
Отрицательное число
Вывод 3:
Введите число: 0
Ноль