if-elif-else. Урок 9 курса «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 (он же самый внешний). Если здесь было получено if выполняется, а в ветку else мы даже не заходим, так как она срабатывает только тогда, когда в условии if возникает ложь.
Если внешний if вернул False, поток выполнения программы заходит в соответствующий ему внешний else. В его теле находится другой if со своим else.
Если введенное число попадает в диапазон от 6 до 12, то выполнится тело вложенного if, после чего программа завершается. Если же число не попадает в диапазон от 6 до 12, то произойдет переход к ветке else. В ее теле находится свой условный оператор, имеющий уже третий уровень вложенности.
Таким образом до последней проверки (16 <= old) интерпретатор доходит только тогда, когда все предыдущие возвращают False. Если же по ходу выполнения программы возникает True, то все последующие проверки опускаются, что экономит ресурсы процессора. Кроме того, такая логика выполнения программы более правильная.
Теперь зададимся следующим вопросом. Можно ли как-то оптимизировать код множественного ветвления и не строить лестницу из вложенных друг в друга условных операторов? Во многих языках программирования, где отступы используются только для удобства чтения программистом, но не имеют никакого синтаксического значения, часто используется подобный стиль:
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 пропускаются.
Спишите последний вариант кода программы из урока. Дополните ее веткой
else, обрабатывающие случаи, когда пользователь вводит числа не входящие в заданные четыре диапазона. Подумайте, почему в первой версии программы (когда использовались не связанные друг с другом условные операторы) нельзя было использоватьelse, а для обработки таких, не входящих в диапазоны, случаев пришлось бы писать еще одинif?Усовершенствуйте предыдущую программу, обработав исключение
, возникающее, когда вводится не целое число.ValueErrorНапишите программу, которая запрашивает на ввод число. Если оно положительное, то на экран выводится цифра 1. Если число отрицательное, выводится -1. Если введенное число – это 0, то на экран выводится 0. Используйте в коде условный оператор множественного ветвления.
Примеры решения и дополнительные уроки в pdf-версии и android-приложении курса
Язык программирования «Python».
Условный оператор ifОператор if
Условный оператор if позволяет выполнить определенный набор инструкций в зависимости от некоторого условия. Использовать этот оператор можно в нескольких вариантах. В этом видео разберем только 2 варианта.
1 Конструкция if
В простейшем варианте использование оператора if выглядит так:
if условие:
блок команд 1
блок команд 2
После оператора if обязательно записывается условие. После условия необходимо поставить знак двоеточия “:”
Рассмотрим пример
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
Пример программы на 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("Хороший результат.
") -
2 В этом коде две ошибки. Найдите и исправьте их:
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("Приятно слышать!")
")Поток управления в Python — GeeksforGeeks
В реальной жизни случаются ситуации, когда нам нужно принять какие-то решения и на основе этих решений мы решаем, что нам делать дальше. Подобные ситуации возникают и в программировании, когда нам нужно принять какие-то решения, и на основе этих решений мы выполним следующий блок кода.
Операторы принятия решений в языках программирования определяют направление потока выполнения программы.
В Python оператор if-else elif используется для принятия решения.
оператор ifоператор if является самым простым оператором принятия решений. Он используется, чтобы решить, будет ли выполняться определенный оператор или блок операторов, т. е. если определенное условие истинно, то блок операторов выполняется, в противном случае нет.
Синтаксис :
если условие : # Операторы для выполнения, если # условие истинно
Здесь условие после оценки будет либо истинным, либо ложным. если оператор принимает логические значения — если значение истинно, то он выполнит блок операторов под ним, иначе нет. Мы можем использовать условие также со скобкой ‘(‘’)’.
Как мы знаем, Python использует отступ для идентификации блока. Таким образом, блок под оператором if будет идентифицирован, как показано в следующем примере:
, если условие: заявление1 заявление2 # Здесь, если условие истинно, если блок # будет считать, что внутри находится только оператор 1 # его блок.Блок-схема оператора Python if
Пример: Оператор Python if
Python3
|
Вывод:
Я не в if
Поскольку условие, присутствующее в выражении if, ложно. Итак, блок под оператором if выполняется.
Одно только выражение if говорит нам, что если условие истинно, то будет выполнен блок операторов, а если условие ложно, то нет. Но что, если мы хотим сделать что-то еще, если условие ложно. А вот и оператор else . Мы можем использовать оператор else с , если оператор выполняет блок кода, когда условие ложно.
Синтаксис :
если (условие):
# Выполняет этот блок, если
# условие верно
еще:
# Выполняет этот блок, если
# Условие неверно Блок-схема Python IF-ELSE.0043 I = 20 IF (I < 15 ):
Print (4 0049004. . Печать ( "I'm IN Block" ) ELSE :
Печать (4493 "" IIS 15.10043 "" "" "" "Я.0044 )
print ( "i'm in else Block" )
print ( "i'm not in if and not in else Block" )
Вывод:
i больше 15
я в другом блоке
я не в if и не в else Блок
Блок кода, следующий за оператором else, выполняется, поскольку условие, присутствующее в операторе if, становится ложным после вызова оператора, который не находится в блоке (без пробелов).
Example 2: Python if else in list comprehension
Python3
def digitSum(n):
dsum = 0
for ele in str (n):
dsum + = int (ele)
return dsum
List = [ 367 , 111 , 562 , 945 , 6726 , 873 ]
Newlist = [Digitsum (I) = 0043 i in List if i & 1 ]
print (newList)
Output
[16, 3, 18, 18]. Вложенные операторы if означают оператор if внутри другого оператора if. Да, Python позволяет нам вкладывать операторы if в операторы if. т. е. мы можем поместить оператор if внутри другого оператора if. Синтаксис :
если (условие1):
# Выполняется, когда условие 1 истинно
если (условие2):
# Выполняется, когда условие 2 истинно
# если блок здесь заканчивается
# if Block is end here Flowchart of Python Nested if Statement
Example: Python Nested if
Python3
i = 10
if (i = = 10 ):
if (i < 15 ):
print ( "I меньше 15" )
0044 if (i < 12 ): print ( "i is smaller than 12 too" )
else :
Печать ( "I больше 15" )
Выход:
I меньше 15.
я тоже меньше 12
лестница if-elif-else Здесь пользователь может выбрать один из нескольких вариантов. Операторы if выполняются сверху вниз. Как только одно из условий, управляющих if, становится истинным, выполняется оператор, связанный с этим if, и остальная часть лестницы игнорируется. Если ни одно из условий не выполняется, будет выполнен последний оператор else.
Синтаксис :
если (условие):
утверждение
Элиф (состояние):
утверждение
.
.
еще:
заявление FlowChart of Python if else elif statements Example: Python if else elif statements Python3
i = 20
if (I = = 10 ):
Печать ( "I IS 10" ) 444444449 9 44449 4444449 4449 49 9 "I IS 10" ) ( 0003 elif (i = = 15 ):
print ( "i is 15" )
elif (i = = 20 ):
( "I - 20" )
"I - 20" ). 0044 Печать ( "I не присутствует" )
Выход:
I - 20
Короткая рука, если Заряд 8 оператор, который будет выполняться внутри блока if, тогда можно использовать сокращение if. Оператор может быть помещен в ту же строку, что и оператор if.
Вложенные операторы if означают оператор if внутри другого оператора if. Да, Python позволяет нам вкладывать операторы if в операторы if. т. е. мы можем поместить оператор if внутри другого оператора if. 
я тоже меньше 12 
0044 Синтаксис:
если условие: заявлениеExample: Python if shorthand
Python3
|
Вывод:
i меньше 15Короткая рука 9 00else 9
Это можно использовать для записи операторов if-else в одной строке, когда есть только один оператор, который должен быть выполнен как в блоке if, так и в блоке else.
Syntax:
statement_when_True if condition else statement_when_FalseExample: Python if else shorthand
Python3
|
Output:
True
How to Use IF Statements in Python ( if, else, elif и т. д.) – Dataquest
3 марта 2022 г.
Наша жизнь полна условий, даже если мы не замечаем их большую часть времени. Давайте рассмотрим несколько примеров:
- Если завтра не будет дождя, я пойду с друзьями в парк. В противном случае я останусь дома с чашкой горячего чая и буду смотреть телевизор.
- Если завтра не будет жарко, я поеду на море, а если будет, то погуляю в лесу. Однако, если пойдет дождь, я останусь дома.
В противном случае я останусь дома с чашкой горячего чая и буду смотреть телевизор. Вы поняли. Давайте посмотрим, как условия работают в компьютерах. Возможно, вы уже знаете, что программы на Python выполняются построчно. Однако иногда нам нужно пропустить какой-то код и выполнить только его часть только при соблюдении определенных условий. Здесь могут пригодиться управляющие структуры. Условные операторы в Python построены на этих управляющих структурах. Они будут направлять компьютер при выполнении программы.
В этом руководстве вы узнаете, как использовать условные операторы. Это руководство предназначено для новичков в Python, но вам необходимо знать некоторые основы кодирования на Python. Если нет, посмотрите этот бесплатный курс по основам Python.
Базовый
if Заявление В Python , если операторы являются отправной точкой для реализации условия.
Давайте рассмотрим самый простой пример:
, если <условие>:
<выражение> Когда <условие> оценивается Python, оно становится либо True , либо False (логические значения). Таким образом, если условие True (т. е. выполняется), то <выражение> будет выполнено, но если <условие> равно False (т. е. не выполняется), то < выражение> выполняться не будет.
Мы можем свободно решать, какими могут быть условия и выражения, потому что Python очень гибок.
Давайте рассмотрим конкретный пример.
# Базовый оператор if
х = 3
у = 10
если х < у:
print("x меньше y") x меньше y.
Прежде всего, мы определяем две переменные, x и y . Тогда мы говорим, что если переменная x меньше, чем переменная y , выведите x меньше, чем y ). Действительно, если мы выполним этот код, мы выведем этот вывод, потому что 3 меньше 10.
Выход: x меньше y.
Давайте рассмотрим более сложный пример.
# Чуть более сложный пример
х = 3
у = 10
г = Нет
если х < у:
г = 13
print(f"Переменная z теперь {z}.") Переменная z теперь равна 13.
В этом случае, если условие выполнено, то переменной z будет присвоено значение 13. Затем Переменная z теперь равна 13. будет распечатано (обратите внимание, что оператор print может использоваться как снаружи, так и внутри , если оператор ).
Как видите, мы не ограничены в выборе выражения для выполнения. Теперь вы можете больше практиковаться, написав более сложный код.
Давайте посмотрим, что произойдет, если мы выполним следующий код:
# Что здесь происходит?
х = 3
у = 10
если х > у:
print("x больше y") Здесь мы изменили направление символа сравнения (было меньше , а теперь больше ). Можете ли вы угадать выход?
Выхода не будет! Это произошло потому, что условие не было выполнено.
3 не больше 10, поэтому условие оценивается как False , и выражение не выполняется. Как решить эту проблему? С оператором else .
Что делать, если мы хотим выполнить какой-то код, если условие не выполняется? Мы добавляем оператор else под оператором if . Давайте посмотрим на пример.
# еще оператор
х = 3
у = 10
если х > у:
print("x больше y.")
еще:
print("x меньше y") x меньше y.
Вывод: x меньше y.
Здесь Python сначала выполняет условие if и проверяет, является ли оно True . Поскольку 3 не больше 10, условие не выполняется, поэтому мы не печатаем «x больше, чем y». Тогда мы говорим, что во всех остальных случаях мы должны выполнять код под оператором else: x меньше y.
Вернемся к нашему первому примеру условного оператора:
Если завтра не будет дождя, я пойду с друзьями в парк.
В противном случае я останусь дома с чашкой горячего чая и буду смотреть телевизор.
Здесь оператор else — «Иначе».
Что произойдет, если условие будет выполнено?
# Что делать, если условие выполнено?
х = 3
у = 10
если х < у:
print("x меньше y.")
еще:
print("x больше y." x меньше y.
В этом случае Python просто выводит первое предложение, как и раньше.
Вывод: x меньше y.
Что, если x равно y ?
# х равно у
х = 3
у = 3
если х < у:
print("x меньше y.")
еще:
print("x больше y") x больше, чем y.
Вывод явно неверный, потому что 3 равно 3! У нас есть еще одно условие за пределами символов сравнения больше или меньше; таким образом, мы должны использовать Элиф выписка.
Давайте перепишем приведенный выше пример и добавим оператор elif .
# x равно y с оператором elif
х = 3
у = 3
если х < у:
print("x меньше y. ")
Элиф х == у:
print("х равно у."
еще:
print("x больше y") 
")
Элиф х == у:
print("х равно у."
еще:
print("x больше y") х равно у.
Вывод: x равно y .
Python сначала проверяет, выполняется ли условие x < y выполнено. Это не так, поэтому мы переходим ко второму условию, которое в Python мы пишем как elif , что является сокращением от else if . Если первое условие не выполнено, проверьте второе условие, и если оно выполнено, выполните выражение. В противном случае сделайте что-нибудь еще. Вывод: «x равно y».
Теперь вернемся к одному из наших первых примеров условных операторов:
Если завтра не будет жарко, поеду на море, а если будет, то погуляю в лесу. Однако, если пойдет дождь, я останусь дома.
Здесь наше первое условие, чтобы завтра не было слишком жарко ( если оператор). Если это условие не выполняется, то идем гулять в лес ( elif инструкция). Наконец, если ни одно из условий не будет выполнено, мы останемся дома (оператор else ).
Теперь давайте переведем это предложение на Python.
В этом примере мы собираемся использовать строки вместо целых чисел, чтобы продемонстрировать гибкость условия , если в Python.
# состояние элиф
завтра = "тепло"
если завтра == "тепло":
print("Я пойду к морю.")
Элиф завтра == "очень жарко":
print("Я пойду в лес.")
еще:
print("Я останусь дома") Я пойду к морю.
Python сначала проверяет, равна ли переменная завтра «теплой» и если да, то выводит Я пойду на море. и останавливает выполнение. Что произойдет, если первое условие не будет выполнено?
# Завтра очень жарко
завтра = "очень жарко"
если завтра == "тепло":
print("Я пойду к морю.")
Элиф завтра == "очень жарко":
print("Я пойду в лес.")
еще:
print("Я останусь дома.") Я пойду в лес.
В этом случае Python оценивает первое условие как False и переходит ко второму условию.
Это условие True , поэтому выводит Я пойду в лес. и останавливает выполнение.
Если ни одно из двух условий не выполнено, то будет напечатано Я останусь дома.
Конечно, вы можете использовать любое количество операторов elif , какое захотите. Давайте добавим больше условий, а также изменим то, что выводится под иначе оператор для Погода не распознана. (например, если завтра «f», мы не знаем, что это значит).
# Несколько условий elif
завтра = "снежно"
если завтра == "тепло":
print("Я пойду к морю.")
Элиф завтра == "очень жарко":
print("Я пойду в лес.")
Элиф завтра == "снежно":
print("Я слеплю снеговика.")
Элиф завтра == "дождливо":
print("Я останусь дома.")
еще:
print("Погода не распознана") Я слеплю снеговика.
Угадайте, что напечатано?
Множественные условия
Теперь добавим немного сложности.
Что, если мы хотим, чтобы соответствовало нескольким условиям в одном выражении if ?
Допустим, мы хотим предсказать биом (например, пустыню или тропический лес) на основе двух климатических измерений: температуры и влажности. Например, если жарко и сухо, то это жаркая пустыня, а если холодно и сухо, то это арктическая пустыня. Вы можете видеть, что мы не можем классифицировать эти два биома только на основе их влажности (оба они сухие), поэтому мы также должны добавить меру температуры.
В Python мы можем использовать логических операторов (то есть, и, или) для использования нескольких условий в одном и том же операторе if .
Посмотрите на код ниже.
# Предсказание биома с логическим оператором и
влажность = «низкая»
температура = "высокая"
если влажность == "низкая" и температура == "высокая":
print("Горячая пустыня.")
elif влажность == "низкая" и температура == "низкая":
print("Это арктическая пустыня. ")
elif влажность == "высокая" и температура == "высокая":
print("Это тропический лес.")
еще:
print("Я не знаю!") 
")
elif влажность == "высокая" и температура == "высокая":
print("Это тропический лес.")
еще:
print("Я не знаю!") Это жаркая пустыня.
Результат будет Это жаркая пустыня. , потому что только при низкой влажности и высокой температуре комбинированное состояние равно True . Недостаточно, чтобы только одно из условий было True .
Формально Python проверяет, является ли первое условие влажности True (действительно так), затем он проверяет, является ли второе условие температуры True (и так оно и есть) и только в этом случае комбинированное условие равно Верно . Если хотя бы одно из этих условий не выполняется, то комбинированное условие оценивается как False .
Что делать, если мы хотим, чтобы одно из двух (или более) условий было выполнено? В этом случае мы должны использовать логический оператор или .
Давайте рассмотрим пример.
Допустим, у вас есть список чисел от 1 до 14 (включительно), и вы хотите извлечь все числа, которые меньше 3 или больше или равны 10. Вы можете добиться результата, используя или 9Оператор 0044!
# или логический оператор
числа = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
nums_less_3_greater_equal_10 = []
для числа в цифрах:
если число < 3 или число >= 10:
nums_less_3_greater_equal_10.append(число)
печать (nums_less_3_greater_equal_10) [1, 2, 10, 11, 12, 13, 14]
Вывод: [1, 2, 10, 11, 12, 13, 14]
Здесь Python проверяет, меньше ли текущее число в цикле for 3, и если оно равно True , то комбинированный оператор if оценивается как True . То же самое происходит, если текущее число равно или больше 10. Если комбинированный оператор if равен True , то выражение выполняется, и текущее число добавляется в список nums_less_3_greater_equal_10 .
Ради эксперимента заменим или на и .
# Изменить или на и
числа = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
nums_less_3_greater_equal_10 = []
для числа в цифрах:
если число < 3 и число >= 10:
nums_less_3_greater_equal_10.append(число)
печать (nums_less_3_greater_equal_10) []
Вывод: []
В этом случае текущее число должно быть одновременно меньше 3 и больше или равно 10, что явно невозможно, поэтому комбинированный оператор if оценивается как False и выражение не выполняется.
Чтобы еще больше прояснить ситуацию, посмотрите на этот оператор print .
печать (ложь или правда)
Правда
Вывод: Правда
Здесь Python оценивает комбинацию False и True , и, поскольку у нас есть логический оператор или , достаточно, чтобы хотя бы одно из этих логических значений было True , чтобы вычислить комбинированный оператор как True .
Теперь, что произойдет, если мы изменим или до и ?
печать (ложь и правда)
Ложь
Вывод: Ложь
Оба логических значения должны быть True , чтобы оценить комбинированное условие как True . Так как одно из них False , комбинированное условие также False . Вот что происходит в примере с числами.
Вы даже можете комбинировать несколько логических операторов в одном выражении. Давайте воспользуемся тем же списком чисел, но теперь нам нужно найти все числа, равные 9.0007 либо меньше 3, либо больше, либо равно 10 и одновременно являются четными числами.
Мы будем использовать оператор % , чтобы выяснить, является ли число четным. Выражение число % другое_число даст остаток от деления числа на другое_число . Если мы хотим выяснить, является ли число четным, то остаток от деления этого числа на 2 должен быть равен 0,
# Более сложные логические операторы
числа = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
nums_less_3_greater_equal_10_multiple_2 = []
для числа в цифрах:
если (число < 3 или число >= 10) и число % 2 == 0:
nums_less_3_greater_equal_10_multiple_2.append(число)
печать (nums_less_3_greater_equal_10_multiple_2) [2, 10, 12, 14]
Вывод: [2, 10, 12, 14]
Почему первое число вывода 2? Во втором цикле for 2 оценивается в первом условии в скобках. Оно меньше 3, поэтому объединенное условие в скобках равно 9.0043 Верно . 2 также делится на 2 с остатком 0, поэтому второе условие также True . Оба условия равны True , поэтому этот номер добавляется к списку.
Почему мы используем скобки? Это из-за приоритета оператора в Python. А если мы их удалим?
# Более сложные логические операторы без круглых скобок
числа = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
nums_less_3_greater_equal_10_multiple_2 = []
для числа в цифрах:
если число < 3 или число >= 10 и число % 2 == 0:
nums_less_3_greater_equal_10_multiple_2. append(число)
печать (nums_less_3_greater_equal_10_multiple_2) 
append(число)
печать (nums_less_3_greater_equal_10_multiple_2) [1, 2, 10, 12, 14]
Вывод: [1, 2, 10, 12, 14]
У нас есть 1 в списке! В Python все операторы оцениваются в точном порядке. Например, операторы и имеют приоритет над операторами или . Но если мы поместим оператор или в круглые скобки, он будет иметь приоритет над операторами и .
Сначала мы оцениваем условия с обеих сторон оператора и (он имеет приоритет). 1 не больше 10 и не дает 0 при делении на 2, поэтому комбинированное условие равно Ложь . У нас остается условие , если num < 3 или False . 1 меньше 3, поэтому первое условие True . Условие становится True или False . У нас есть оператор или , поэтому комбинированное условие оценивается как True , и к списку добавляется 1. Практикуйтесь, проверяя, что происходит с другими числами.
Наконец, взгляните на эту таблицу истинности , чтобы понять, как работают логические операторы. Здесь мы опишем только и и или логические операторы, но в Python у нас также есть оператор , а не . Мы приглашаем вас узнать больше об этом и попрактиковаться в использовании внутри операторов if .
| Вход А | Вход Б | И | ИЛИ |
|---|---|---|---|
| Ложь | Ложь | Ложь | Ложь |
| Правда | Ложь | Ложь | Правда |
| Ложь | Правда | Ложь | Правда |
| Правда | Правда | Правда | Правда |
У нас есть два входа, A и B, которые могут быть либо True , либо False . Например, во второй строке A — это True , а B — False ; таким образом, A И B оцениваются как False , но A OR B оцениваются как Верно .
Аналогично читается остальная часть таблицы. Потратьте минуту, чтобы понять, что он вам говорит.
Вложенные
операторы if Python — очень гибкий язык программирования, и он позволяет вам использовать операторы if внутри других операторов if, так называемые вложенные операторы if . Давайте посмотрим на пример.
# Вложенные операторы if
отметка = 85
если отметка >= 60 и отметка <= 100:
если отметка >= 90:
print("Ты лучший!")
Элиф Марк >= 80:
print("Молодец!")
Элиф Марк >= 70:
print("Вы можете сделать лучше.")
еще:
распечатать("Пройдено")
Элиф Марк > 100:
print("Эта отметка слишком высока.")
Элиф Марк <0:
print("Эта отметка слишком низкая.")
еще:
печать("Ошибка") Молодец!
Вывод: Молодец!
Здесь, если метка находится между 60 и 100, выполняется выражение под оператором if . Но тогда у нас есть другие условия, которые также оцениваются.
Итак, наша отметка — 85, что находится между 60 и 100. Однако 85 меньше 90, поэтому первое вложенное условие if равно False , а первое вложенное выражение не выполняется. Но 85 выше 80, поэтому выполняется второе выражение и «Молодец!» распечатывается.
Конечно, у нас также есть оператора elif вне выражения ниже первого оператора if . Например, какой , если оценка выше 100? Если первое условие (число от 60 до 100) равно False , то мы переходим непосредственно к оператору elif mark > 100 и распечатываем Эта метка слишком низкая. .
Попробуйте присвоить разные номера переменной mark , чтобы понять логику этого кода.
Сопоставление с образцом в Python 3.10
Сопоставление с образцом было добавлено в Python 3.10, выпущенном в октябре 2021 года. Короче говоря, можно увидеть другой синтаксис для операторов if.. Давайте рассмотрим пример, переписав предыдущий пример с использованием сопоставления с образцом.
.elif
# Предыдущий пример
завтра = "снежно"
если завтра == "тепло":
print("Я пойду к морю.")
Элиф завтра == "очень жарко":
print("Я пойду в лес.")
Элиф завтра == "снежно":
print("Я слеплю снеговика.")
Элиф завтра == "дождливо":
print("Я останусь дома.")
еще:
print("Погода не распознана") Я слеплю снеговика.
# Сопоставление с образцом с синтаксисом match..case
завтра = "снежно"
матч завтра:
чехол "теплый":
print("Я пойду к морю.")
случай "очень горячий":
print("Я пойду в лес.")
чехол "снежный":
print("Я слеплю снеговика.")
случай "дождливый":
print("Я останусь дома.")
дело _:
print("Погода не распознана") Я слеплю снеговика.
Мы можем видеть сходство между использованием if..elif 9Операторы 0044 и синтаксис соответствуют синтаксису case . Во-первых, мы определяем, какую переменную мы хотим, чтобы соответствовало , и когда мы определяем случаи (или значения, которые может принимать эта переменная). Остальной код аналогичен. Если совпадает случай (эквивалент двойного знака равенства), то выполняется выражение print .
Обратите внимание на последний оператор case , это случай _ , который эквивалентен else : если ни один случай не соответствует, то мы печать Погода не распознана .
Когда вы начнете писать более сложный код, вы можете оказаться в ситуации, когда вам придется использовать заполнитель вместо кода, который вы хотите реализовать позже. Этот заполнитель является оператором pass . Давайте рассмотрим пример с оператором pass и без него.
# Без пропуска
число = 3
если число == 3:
print("Я напишу этот код позже. ") 9IndentationError: ожидается блок с отступом 
") 9IndentationError: ожидается блок с отступом Python ожидает некоторый код в операторе `if`, но вы еще не реализовали его! Вы можете написать там `pass` и решить эту проблему.
# С пропуском
число = 3
если число == 3:
проходят
print("Я напишу этот код позже.") Я напишу этот код позже.
Вывод: «Я напишу этот код позже».
Если вместо этого вы поместите `pass` в оператор `if`, Python не выдаст никакой ошибки и перейдет к любому коду, который у вас есть ниже оператора `if`. Это работает, даже если у вас есть другие условия после первого оператора `if`.
# С пропуском
число = 4
если число == 3:
проходят
Элиф число == 4:
print("Переменная num равна 4.")
еще:
print("Переменная num не равна ни 3, ни 4.") Переменная num равна 4.
Вывод: Число переменной равно 4.
Выводы
В Python, , если операторы используются постоянно, и вы обнаружите, что используете их практически в любом проекте или сценарии, который вы создаете, поэтому важно понимать логику, стоящую за ними.