Вдвойне дает тот, кто дает быстро (Сенека Старший).
Язык программирования Python удобен для чтения и эффективен при написании операций. В этой статье обсуждаются встроенные условные операторы if-else. В Python нет тернарного оператора, поэтому мы используем if-else в одной строке, что имеет тот же эффект, что и тернарный оператор. Это условие оценивает условия в состоянии истинности или ложности.
Как встроенные операторы if-else — это логические операторы, которые предлагают одну строку, которая сохраняет качество кода, заменяя несколько строк кода if-else. Встроенные операторы if-else следует использовать с выражениями и их выполнением на основе условий оценки.
Синтаксис встроенного if-else в Python
Чтобы написать встроенный оператор if-else, мы должны следовать этому синтаксису.
<expression1> if <condition> else <expression2>
В этом синтаксисе <expression1> будет возвращено или выполнено, если условие истинно, иначе будет возвращено или выполнено <expression2>, и эти условия всегда выполняются слева направо.
IndentationError во встроенном if-else
Python использует отступы, чтобы различать, какие строки кода соответствуют другим. Потому что файл Python может содержать несколько определений функций. Функция должна иметь одну строку кода, чтобы быть допустимой. Это также означает, что даже если условие истинно, должна быть выполнена хотя бы одна строка кода; в противном случае возникает исключение IndentationError с сообщением «ожидается намеренный блок».
Пример 1:
Давайте начнем с простого примера того, как работает это встроенное if-else. Помните, что условия оцениваются слева направо. Здесь мы определяем переменную «a» равной «5», а a_output имеет условие if-else, которое мы передаем функции print() для отображения вывода. Встроенное условие if-else здесь вернуло «20», если переменная «a» равна «20», иначе вернуло «10».
a = 5 a_output = "20" if a==20 else "10" print(a_output)
Итак, у нас есть «а» равно «5», поэтому условие ложно, и мы получаем 10 после выполнения этого кода.
Пример 2:
В этом примере у нас есть две переменные во встроенном операторе as. В коде мы определяем переменную как «x» и присваиваем значение «20». Кроме того, у нас есть еще одна переменная, поскольку «y» равно «10». Таким образом, условие «y» равно «10», если «x» меньше «20», иначе будет напечатан «0». Что ж, передайте «x» через условие, поэтому слева направо, если «x» меньше «20», ответ будет «нет», поэтому мы ожидаем, что «y» будет «0». Давайте запустим пример и посмотрим на значение ‘y’.
x=20 y=10 if x<20 else '0' print(y)
Здесь «у» равен «0», потому что условие ложно, так как «х» не меньше «20», он равен «20».
Из приведенного выше кода мы получили значение «y» как «0». Теперь, что, если «x» меньше «20», взяв значение «x» как «19». Мы ожидали, что «y» будет «10». Мы можем увидеть значение «y», напечатав значение.
x=19 y=10 if x<20 else '0' print(y)
Поскольку у нас есть выходное значение «y» равное 10, условие истинно, поскольку «x» меньше «20».
Пример 3:
В этом конкретном примере у нас есть код строки. Присвоив значение «красный» переменной «цветок» и применив встроенное условие if-else, которое печатает «Цветок белый», если переменная «цветок» равна «белому», иначе будет напечатано выражение «цветок не белый». .
flower='red'
print("Цветок белый" if flower == 'white' else "Цветок не белый")
Значение цветка красное; в результате условие не выполняется, и реализуется оператор в другой части. Вы можете увидеть вывод ниже, который печатает «Цветок не белый».
Пример 4:
Все примеры представляют собой просто встроенные условия if-else, но сейчас мы обсудим вложенные условия if-else. Мы берем пример одобрения автомобильных прав для людей, имеющих возраст, равный 18 или старше 18 лет.
У нас есть переменная «age», которая принимает данные от пользователя. В условном встроенном заявлении будет напечатано «вы не имеете права подавать заявку», если возраст младше 16 лет. Если возраст составляет от 16 до 18, будет напечатано «нужно подождать, пока вам исполнится 18+»; в противном случае будет показано «вы имеете право подать заявку».
age = int(input("Введите ваш возраст = "))
message= 'Вы не имеете права подавать заявку' if age<16 else 'вам нужно подождать, чтобы вам исполнилось 18+' if 16<age<=18 else 'вы имеете право подать заявку'
print(message)
Вывод этого кода показывает сообщение «Вы не имеете права подавать заявку», поскольку пользователь вводит возраст 15 лет, что меньше 16 лет.
Теперь, когда пользователи вводят возраст 17 лет, мы печатаем «вам нужно подождать, чтобы вам исполнилось 18+», поскольку возраст составляет от 16 до 18.
На экране консоли было напечатано «вы имеете право подать заявку», поскольку возраст старше 18 лет.
Пример 5:
Это пример чрезвычайно очевидного случая в реальном времени, когда мы должны оценить несколько условий. Здесь мы должны выделить оценку из набранных баллов; мы определяем переменную «AndreyEx» и инициализируем ее значением «80».
Условие хранится в переменной с именем «Результат», которая будет печатать оценки от «А» до «Неудачно» при выполнении. На этот раз оценки выше 90, поэтому ожидается, что на выходе будет A+. Давайте запустим этот код, чтобы увидеть, каков результат этого кода.
AndreyEx = 95 Result = 'Grade = A+' if AndreyEx > 90 else 'Grade = A' if AndreyEx > 80 else 'Grade = B' if AndreyEx >70 else 'Grade = C' if AndreyEx >60 else 'Grade = D' if AndreyEx > 40 else 'Fail' print(Result)
Оценка A+ выводится на экран консоли.
Заключение
Мы подробно рассмотрели встроенные if-else в python с несколькими допустимыми примерами с помощью терминала Spyder. Встроенный if-else имеет гораздо более короткий и аккуратный код, который понятен и прост в использовании. Надеюсь, это поможет вам понять фундаментальную концепцию встроенных операторов if-else.
Если вы нашли ошибку, пожалуйста, выделите фрагмент текста и нажмите Ctrl+Enter.
Загрузка…
Перевод статьи «Python Not Equal Operator».
В Python для проверки верности неравенства используется != или is not. Когда значения любых двух переменных Python или операндов, предоставленных по обе стороны от оператора неравенства, не равны, он должен возвращать True, в противном случае — False.
Выполняя сравнение, следует иметь в виду тип переменных. Многие языки структурированных запросов «ругаются» по поводу сопоставления различных типов. А вот Python гибок, хотя и жестко типизирован. Если значения двух переменных совпадают, но принадлежат к разным типам, оператор неравенства должен возвращать True.
Ниже мы приведем несколько примеров, чтобы показать, как работают операторы неравенства Python.
Сравнение при помощи оператора != переменных одного и двух типов
Наш первый пример будет содержать различные способы сравнения двух или более значений переменных разных типов с помощью оператора неравенства.
Мы инициализируем две целочисленные переменные, x и y. После этого используем знак != для сравнения их значений. Результат в виде булева значения будет сохранен в новой переменной c. После этого мы выводим значение этой переменной.
x = 5 y = 5 c = x != y print(c) # False
При выполнении этого кода мы получим результат False, потому что значения переменных x и y были равны и имели одинаковый тип данных.
Теперь давайте обновим наш код. Мы объявим три разные переменные, причем только две из них будут иметь одинаковое значение.
После этого мы воспользуемся оператором неравенства !=, чтобы получить результат сравнения переменных a и b. В этом случае мы используем оператор неравенства прямо в предложении print.
Затем мы сравним переменные a и c вне предложения print и запишем результат в переменную f. После этого используем значение этой переменной в print.
Наконец, мы объявим переменную строкового типа q и сравним ее с целочисленной переменной a в предложении print.
a = 3
b = 3
c = 2
print(f'a is not equal to b = {a!= b}')
# a is not equal to b = False
f = a != c
print(f"a is not equal to c = {f}")
# a is not equal to c = True
q = '3'
print(f'a is not equal to q = {a!= q}')
# a is not equal to q = True
В выводе мы видим одно ложное и два истинных значения. Первые два результата мы получили, сравнивая переменные целочисленного типа. Однако последнее сравнение было между переменными целочисленного и строкового типов. И хотя обе переменные были равны 3, одна из них была строковой, а вторая – целочисленной. Поэтому мы получили True, значения не равны.
Использование оператора неравенства в if-блоках
Давайте посмотрим, как оператор неравенства используется в условии if.
У нас есть две переменные: переменная x – целочисленного типа, а y – строкового. Мы инициализируем предложение if и используем в нем оператор != , чтобы проверить наши переменные на неравенство. Если условие будет выполняться, то в выводе мы увидим фразу о том, что переменные не равны.
x = 5
y = '5'
if (x != y):
print('x is not equal to y')
# x is not equal to y
После выполнения кода в выводе мы получили желаемую строку.
Рассмотрим другой пример. На этот раз мы используем обе переменные строкового типа и сравним их в операторе if. Также мы используем print(), чтобы вывести значения обеих переменных.
x = 'Aqsa'
y = 'Yasin'
if x != y:
print(x, 'and', y, 'are different')
# Aqsa and Yasin are different
При запуске кода мы не получаем никаких ошибок (т.е. наши переменные действительно не равны).
А теперь давайте рассмотрим пример посложнее.
Используем целочисленную переменную z, имеющую значение 21. Сначала мы вычислим остаток от деления z на 2. После этого, при помощи if, зададим условие с !=, чтобы сравнить вычисленное значение с 0. Таким образом мы проверим, является ли значение z четным. Если полученное значение не равно 0 (т.е. остаток от деления на 2 равен единице), в выводе мы получим значение переменной z и сообщение о том, что оно не является четным.
z = 21
if z % 2 != 0:
print(z, 'is not even!')
# 21 is not even!
В результате выполнения кода переменная z была выведена на экран вместе со строкой is not even!.
Использование оператора != в блоках if-else
В приведенных выше примерах мы использовали оператор if. На этот раз давайте воспользуемся оператором if-else.
Напишем следующий код. Прежде всего, инициализируем переменную целочисленного типа a, значение которой равно 10. После этого мы запускаем условие if-else.
Условие if использует оператор неравенства is not для сравнения переменной a со значением 20. Если условие удовлетворяется, мы получим результат «Values are not Equal». В противном случае программа перейдет к else и выведет «Values are Equal».
a = 10
if a is not 20:
print('Values are not Equal')
else:
print('Values are Equal')
Запустим наш код. Вы можете видеть, что условие в операторе if выполнено и в выводе мы получаем сообщение о том, что значения не равны – «Values are not Equal».
Давайте взглянем на другой пример. Объявим строку str, имеющую значение Aqsa. Если наша str равна Aqsa, то нам выведется на экран Hy Aqsa. Если же условие оператора if не выполняется, программа переходит на следующую строчку кода – оператор elif. В таком случае мы получим сообщение Bye.
str = 'Aqsa'
if str == 'Aqsa':
print('Hy Aqsa')
elif str != 'Aqsa':
print('Bye')
Поскольку условие в операторе if выполняется, на выходе мы получим результат первого print(), и к условию elif программа не перейдет .
Давайте изменим значение переменной str на Yasin. На этот раз условие в операторе if не соблюдается, и программа переходит к условию elif. Следовательно, на экран будет выведен результат второго print().
str = 'Yasin'
if str == 'Aqsa':
print('Hy Aqsa')
elif str != 'Aqsa':
print('Bye')
Запустив код теперь, мы получим результат работы print() в блоке elif – Bye.
Наконец, протестируем оператор сравнения != на сложном примере.
Мы инициализировали класс с именем Test. Внутри этого класса мы инициализировали переменную i, имеющую значение 0. Другая переменная — data — была инициализирована со значением None.
После этого мы инициализировали конструктор нашего класса, чтобы получить значения этих переменных для каждого экземпляра класса.
Затем мы инициализировали встроенный метод, использующий оператор неравенства, и применили в нем конструкцию if-else.
Далее были созданы три объекта для отправки значений конструктору.
После этого мы сравнили объекты друг с другом и вывели на экран результат сравнения. Сохраним код и запустим его.
class Test:
i = 0
data = ''
def __init__(self, i, s):
self.i = i
self.data = s
def __ne__(self, other):
if type(other) != type(self):
return True
if self.data != other.data:
return True
else:
return False
t1 = Test(1, 'Aqsa')
t2 = Test(2, 'Aqsa')
t3 = Test(3, 'Yasin')
print(t1 != t2)
print(t2 != t3)
На выходе получим значение False как возврат первого оператора print(), поскольку значения, проанализированные для обоих объектов, были одинаковыми. Напротив, второй print() возвращает True, потому что t2 и t3 имеют разные значения и, следовательно, они не равны.
Вывод
Сегодня мы поговорили об операторе неравенства в Python. С помощью различных примеров и сценариев мы узнали, как работает оператор != и как его применять для проверки неидентичности двух переменных.
На этом занятии
поговорим об условном операторе. Что это такое? Представьте, что вам нужно
вычислить модуль числа, хранящегося в переменной x. Как это
сделать? Очевидно, нужно реализовать такой алгоритм.
И в этом
алгоритме есть вот такое ветвление программы: при x<0 меняется
знак на противоположный, а при других x это не делается. В результате
получаем модуль числа в переменной x.
Так вот, чтобы
реализовать проверку таких условий в Python имеется один
условный оператор if, который в самом простом случае имеет такой синтаксис:
if(<условное выражение>) : оператор
или так:
if <условное выражение> : оператор
Если условное выражение
истинно, то выполняется оператор, записанный в if. Иначе этот
оператор не выполняется. Используя оператор ветвления, запишем программу для
вычисления модуля числа:
x = -5 if(x < 0) : x = -x print(x)
Здесь операция
изменения знака переменной x будет выполняться только для
отрицательных величин, а положительные просто выводятся в консоль, минуя эту
операцию.
Какие операторы
сравнения существуют в Python и как они работают? Многие из
них нам известны из школьного курса математики, это:
|
a > b |
Истинно, если a |
|
a < b |
Истинно, если a |
|
a >= |
Истинно, если a |
|
a <= |
Истинно, если a |
|
a == b |
Истинно, если a |
|
a != |
Истинно, если a |
Все эти
операторы при сравнении возвращают булевое значение: True – истина или False – ложь.
Например:
print(2 > 1) print(2 == 1) print(2 != 1)
Результат
сравнения можно присвоить переменной, как и любое значение:
result = 7 > 5 print(result)
Сравнение строк
Как вы видите,
сравнение двух числовых значений выполняется вполне очевидным образом. Но можно
ли, например, сравнивать строки между собой? Оказывается да, можно. Чтобы
определить, что одна строка больше другой, Python использует
«алфавитный» или «лексикографический» порядок. Другими словами, строки сравниваются
посимвольно. Например:
print('Я' > 'А' ) print( 'Кот' > 'Код' ) print( 'Сонный' > 'Сон' )
Алгоритм
сравнения двух строк довольно прост:
- Сначала
сравниваются первые символы строк. - Если первый
символ первой строки больше (меньше), чем первый символ второй, то первая
строка больше (меньше) второй. - Если первые
символы равны, то таким же образом сравниваются уже вторые символы строк.
Сравнение
продолжается, пока не закончится одна из строк. Если обе строки заканчиваются
одновременно, и все их соответствующие символы равны между собой, то строки считаются
равными. Иначе, большей считается более длинная строка.
В примерах выше
сравнение ‘Я’ > ‘А’ завершится на первом шаге, тогда как строки
«Кот» и «Код» будут сравниваться посимвольно:
- К равна К.
- о равна о.
- т больше чем д.
На этом сравнение заканчивается. Первая строка больше.
Конструкция if – elif – else
Теперь, когда мы
знаем как сравниваются между собой величины, вернемся к нашему условному
оператору if. И предположим,
что хотим определить знак числа в переменной x. Конечно,
проверку можно записать вот так:
x = -5 if x < 0 : print("x отрицательное число") if x >= 0 : print("x неотрицательное число")
Но можно сделать
лучше. Смотрите, мы здесь имеем дело со взаимоисключающими условиями, то есть,
они не могут произойти одновременно: либо первое, либо второе. Для таких
ситуаций можно использовать ключевое слово else – иначе, чтобы
ускорить процесс проверки:
x = 5 if x < 0: print("x отрицательное число") else: print("x неотрицательное число")
Теперь, у нас
здесь всего одно условие. Если оно истинно, то выполнится первый print, а иначе –
второй. Такая программа будет работать быстрее. И обратите внимание на
синтаксис записи функции print: перед ней необходимо записать хотя бы
один пробел (обычно ставится 4 пробела или символ табуляции). Эти пробелы в Python означают блок
кода, который выполняется по некоторому условию. В данном случае блок кода
состоит всего из одного оператора print. То же самое и
для else.
В общем случае,
синтаксис оператора if else следующий:
if(<выражение>):
оператор 1
else: оператор 2
или
if(<выражение>):
оператор 1
else:
оператор 2
Если же мы хотим
по такому принципу выполнить три проверки: x > 0; x < 0; x == 0, то предыдущую
программу можно записать так:
if x < 0: print("x отрицательное число") elif x > 0: print("x положительное число") else: print("x равен 0")
И вообще таких
конструкций
if – elif – elif –…– elif – else
может быть
много. Далее, обратим внимание на такой факт: во всех наших примерах по условию
шел один оператор – print. Но что если нужно выполнить несколько
операторов по некоторому условию? Для этого их нужно записывать по такому
синтаксису:
if <условие>:
оператор 1
оператор 1
…
оператор N
Например:
x = -10; sgn = 0 if x < 0: sgn = -1 print("x отрицательное число", sgn) elif x > 0: sgn = 1 print("x положительное число", sgn) else: print("x равен 0", sgn)
Здесь по первым
двум условиям выполняется два оператора: присвоение значения переменной sgn и вывод
результата в консоль.
В ряде случаев
конструкцию if-else удобнее
записывать через тернарный условный оператор, который имеет такой синтаксис:
result = значение1 if <условие>
else значение2
При истинности
условия возвращается значение1, в противном случае – значение2. Например:
age = 18 accessAllowed = True if age >= 18 else False print(accessAllowed)
Получим True, если возраст (age) больше или равен 18, иначе – False. Кстати, проверку из данного примера можно сделать короче, просто прописав
accessAllowed = age >= 18
здесь оператор >=
вернет True при возрасте
больше или равен 18 и False – в противном
случае.
Теперь, когда мы
разобрались с базовыми моментами проверки условий, сделаем следующий шаг и
попробуем реализовать проверку попадания переменной x в диапазон [2;
7], то есть, условие должно быть истинным, когда x принимает
значения в этом диапазоне чисел. Очевидно, что здесь должно быть две проверки:
первая – мы проверяем, что x >= 2 и вторая – проверяем, что x <= 7. Если
оба этих условия выполняются одновременно, то x попадает в наш
диапазон. Реализовать такую проверку на Python можно так:
x = 4 if x >= 2 and x <= 7 : print("x попадает в [2; 7]") else: print("x не попадает в [2; 7]")
Смотрите, здесь
записано два условия, объединенных по И (and – это И). В
результате, общее составное условие будет считаться истинным, если истинно и
первое и второе условие. Если хотя бы одно из этих условий ложно, то ложно и
все составное условие. В результате мы корректно реализуем проверку на
вхождение значения переменной в диапазон [2; 7].
А теперь давайте
реализуем противоположное условие, что x не принадлежит
диапазону [2; 7]. Условие будет таким:
x = 40 if(x < 2 or x > 7): print("x не попадает в [2; 7]") else: print("x попадает в [2; 7]")
Здесь в
составном условии используется связка по ИЛИ (or – это ИЛИ) и
оно будет истинно, если истинно или первое, или второе условие. То есть, в
нашем случае, если x < 2 или x > 7, то
делается вывод о невхождении переменной x в указанный
диапазон.
Итак, запомните следующие правила:
-
условие
x >= 2 and x <= 7 истинно,
если истинно каждое из подусловий (x>=2 и x <= 7) и
ложно, если ложно хотя бы одно из них; -
условие
x < 2 or x > 7 истинно,
если истинно хотя бы одно из подусловий (x < 2 или x > 7) и
ложно, когда оба ложны.
Вот так можно
записывать более сложные условия в условном операторе if. Причем они
могут комбинироваться в любом сочетании, например:
x = 4; y = -2 if x >= 2 and x <= 7 and (y < 0 or y > 5): print("x попадает в [2; 7], y не попадает в [0; 5]")
Здесь
реализована проверка, что x должно
принадлежать [2; 7], а y не принадлежать [0; 5]. И обратите
внимание вот на эти круглые скобки. Дело в том, что приоритет у операции and выше, чем у or, поэтому без
скобок у нас бы получилась вот такая проверка:
if (x
>= 2 and x <= 7 and y < 0) or (y > 5)
то есть, мы
проверяли бы, что x принадлежит [2; 7] и y меньше нуля ИЛИ y больше 5. Как вы
понимаете – это уже совсем другая проверка. Поэтому учитывайте приоритет этих
операций при формировании составного условия. Если нужно изменить приоритет – используйте
круглые скобки.
Одиночные проверки
Внутри условия
можно прописывать и такие одиночные выражения:
x = 4; y = True; z = False if(x): print("x = ", x, " дает true") if(not 0): print("0 дает false") if("0"): print("строка 0 дает true") if(not ""): print("пустая строка дает false") if(y): print("y = true дает true") if(not z): print("z = false дает false")
Вот этот оператор
not – это отрицание
– НЕ, то есть, чтобы проверить, что 0 – это false мы
преобразовываем его в противоположное состояние с помощью оператора отрицания
НЕ в true и условие
срабатывает. Аналогично и с переменной z, которая равна false.
Из этих примеров
можно сделать такие выводы:
- Любое число,
отличное от нуля, дает True. Число 0 преобразуется в False. - Пустая строка –
это False, любая другая
строка с символами – это True. - С помощью
оператора not можно менять
условие на противоположное (в частности, False превращать в True).
Итак, в условиях
мы можем использовать три оператора: and, or и not. Самый высокий
приоритет у операции not, следующий приоритет имеет операция and и самый
маленький приоритет у операции or. Вот так работает оператор if в Python.
Видео по теме
Что такое if…else в Python?
Условия, сделать что то, при выполнении определенного условия. Не буду много писать, и побыстрее перейдем к практике.
n = 10 # Переменная со значением 10
if n > 5: #Задаем условие, если n больше 5 то:
print(f"верно {n} больше 5") # Распечатай нам сообщение
else: # Иначе, то есть если вышеописанное условие неверное
print(f"{n} меньше 5") #Распечатай нам сообщение
Я надеюсь в приведенном выше примере, все довольно ясно описано. В вышеописанном примере, мы использовали только одно условие, мы так же можем проверять несколько условий.
Синтаксис if…elif…else
И так, с тем как формируются условия для проверки одного выражения, мы с вами разобрались, теперь попробуем разобраться с тем, как формируются условия, для проверки нескольких вариантов.
Начнем с того что оператор elif, это сокращение от else…if, то есть «Иначе если«, именно благодаря этому оператору мы можем проверять несколько вариантов выражений. Все довольно просто, если условие для нашего if возвращает нам False, то Python проверяет состояние уже следующего за ним условия elif, если и тут условие возвращает нам False, то идем проверять следующее, либо переходим к блоку else, в зависимости от вашего условия. В конструкциях if…else, может быть только один блок else, но могут быть несколько блоков elif. Рассмотрим небольшой пример.
number = 20 #переменная со значением 20
if number > 0: # Если number больше 0
print("Положительное число") # распечатай
elif number == 0: #Иначе, если number равен нулю
print("Равна нулю") # Распечатай
else: # Иначе
print("Отрицательное число") #Распечатай
Что бы было более понятно, я постарался отделить блоки условий друг от друга, а вам небольшое задание, сейчас написанный нами сценарий статичный, нет взаимодействия с пользователем, попробуйте добавить взаимодействие таким образом, что бы пользователь вводил число, и скрипт проводил вышеописанные сравнения. Обязательным условием в решении этого задания, является то, что бы пользователь мог вводить только числа. Попробуйте так же воспользоваться сервисом repl.it, иногда для меня лично удобнее быстро набросать на соседней вкладке браузера, если мой Pycharm не открыт.
Вы смотрели фильм начало? Если нет я для вас оставлю ссылку на трейлер.
В общем то, логика работы вложенных условий чем то напоминают сюжет этого фильма, условия внутри условий! Итак попробуем более подробное разобраться с этой штукой! И так, представьте себе что внутри конструкций if…elif…else мы можем использовать дополнительные условия -конструкции, это и называется вложенными условиями, это как сон во сне, в фильме начало. В самом начале ничего не понятно, но стоит немного углубиться, и все становится на свои места. Пример работы:
number = int(input("Введите число: ")) # Просим пользователя ввести число
if number >= 0: # если число равно больше нуля
if number == 0: # Вложенное условие, если число равно ну
print("Ноль") # Распечатай
else: Иначе ( если число больше нуля)
print("Положительное число") # Распечатай
else: #Иначе (если все вышеописанные условия не верны)
print("Отрицательное число") # Распечатай
Цикл For в Python
В Python существует логический тип данных bool, который может возвращать только два значения:
- True (истину) // первая буква заглавная
- False (ложь) // первая буква заглавная
Мы можем увидеть одно из этих значений, когда что-нибудь сравниваем между собой.
10 > 6
True // истина
5 > 8
False // ложь
4 <= 3
False
3 >= 2
True
6 == 7
False
4 != 9
True
Операторы сравнения в Python
Всего существует 6 операторов сравнения:
- > больше
- < меньше
- >= больше или равно
- <= меньше или равно
- == равно
- != неравно
Ещё операторы сравнения называют — логическими и условными операторами. Логическая конструкция if else держится на этих условных операторах.
Оператор if в Python
Объявим две переменные со значениями 10 и 20 и проверим верно ли условие, что a меньше b. Если (if) условие верно, то оно возвращает истину и на экране распечатается строка «Светит ярко солнце».
a = 10
b = 20
if a < b:
print ('Светит ярко солнце')
Теперь поменяем значения переменных и напишем, тоже самое условие. Условие неверно, ведь c не меньше d, следовательно возвращает False. На экране ничего не распечатается.
c = 20
d = 10
if c < d:
print ('Светит ярко солнце')
Почему выполняемая команда print, пишется с отступом в 4 пробела от левого края? Так мы обозначаем, что исполняемый код относится к блоку с условием if. Все последующие строчки кода с отступами так же будут относится к блоку if. Попытка поставить другое количество пробелов, приведет к ошибке. Интерпретатор Python не сможет определить к чему относится данный код.
Во многих других языках программирования, исполняемый код написали бы в фигурных скобках. Строгое соблюдение отступов в Python — это плата за минималистичный синтаксис. Проблема может возникнуть, если вам попадется чужой неформатированный код, где отступы будут нарушены. Понятно, что такая программа не будет работать.
Конструкция if-else в Python
Если условие if является ложью (False), то программа не выполняет ничего. Однако на практике, такой вариант не имеет особого смысла. Оператор else служит для выполнения альтернативного кода.
a = 20
b = 10
if a < b:
print ('Отличная погода')
else:
print ('Переменная облачность')
Если утверждение, что a меньше b — ложь, то выполняется код в блоке else (иначе). Тогда на экране выведется строка «Переменная облачность».
Конструкция if-elif-else в Python
Оператор ветвления if-elif-else позволяет сделать проверку нескольких условий, прежде чем выполнится альтернативный код. Благодаря ветвлению, можно задать для пользователя больше вариантов ответов.
Python проходится по веткам сверху вниз. Если первая ветка if возвращает False, то интерпретатор переходит ко второй ветке elif. Поскольку условие ветки elif возвращает True, то выполняется код в в блоке elif — распечатывает «Идет дождь». Если оба условия окажутся ложью, то выполнится код в блоке else.
a = 15
b = 10
if a < b:
print ('Отличная погода')
elif a != b:
print ('Идет дождь')
else:
print ('Переменная облачность')
Заключение
Хотите узнать, почему стоит выбрать для изучения Python, как первый язык программирования для новичка. Посмотрите, как просто устанавливается Python на ваш компьютер. Познакомьтесь поближе с переменными и с таким типом данных, как список. Все эти статьи носят ознакомительный характер и не полностью раскрывают все возможности Python. Для изучения языка на профессиональном уровне, перейдите на страницу заказа полного курса по Python.
-
Создано 18.10.2019 10:56:38
-
Михаил Русаков
Копирование материалов разрешается только с указанием автора (Михаил Русаков) и индексируемой прямой ссылкой на сайт (http://myrusakov.ru)!
Добавляйтесь ко мне в друзья ВКонтакте: http://vk.com/myrusakov.
Если Вы хотите дать оценку мне и моей работе, то напишите её в моей группе: http://vk.com/rusakovmy.
Если Вы не хотите пропустить новые материалы на сайте,
то Вы можете подписаться на обновления: Подписаться на обновления
Если у Вас остались какие-либо вопросы, либо у Вас есть желание высказаться по поводу этой статьи, то Вы можете оставить свой комментарий внизу страницы.
Если Вам понравился сайт, то разместите ссылку на него (у себя на сайте, на форуме, в контакте):
-
Кнопка:
Она выглядит вот так:
-
Текстовая ссылка:
Она выглядит вот так: Как создать свой сайт
- BB-код ссылки для форумов (например, можете поставить её в подписи):
Условный оператор — это оператор, который позволяет выполнять определенный участок кода, если указанное условие истинно (т.е. равно True).
if (условное выражение):
код
код
Очень важно, чтобы код, который должен быть выполнен, при истинном условии, был отделен 4 пробелами, от основного кода.
Как работает условный оператор
Разберем работу if на примере:
a = 1
if a > 0:
print('Условие верно!')
#Условие верно!
Мы присвоили переменной a единицу, далее создали условие:
Если a больше нуля, то выполняем инструкции, т.е. печатаем Условие верно!.
Т.к. 1 больше 0, значим условие истинно и равно True, то мы увидели выполнение функции print.
Если же условие не будет выполняться и вернется False, то все инструкции внутри этого блока пропускаются:
Конструкция if – else
Иногда нужно иметь альтернативный вариант выполнения программы, если условие верно выполняем один кусок программы, в противном случае выполняется другая часть.
Для этого случая и используется необязательный оператор else:
a = 1
if a < 0:
print('Отрицательное число')
else:
print('Положительное число')
#Положительное число
Работает эта конструкция так:
Если выражение истинно, выполняем инструкции, иначе — выполняем другие инструкции.
Конструкция if – elif – else
Но бывают и такие моменты, когда нужно проверить не одно, а сразу несколько условий.
В этом случае удобно использовать оператор elif.
a = 1
if a < 0:
print('Отрицательное число')
elif a > 0:
print('Положительное число')
else:
print('Ноль')
#Положительное число
Операторов elif может быть сколько угодно, все они будут проверяться по очереди, пока условие не станет истинным или не дойдет черед до оператора else.
Но перебарщивать с этим тоже не стоит, если в вашем коде более 5 elif, то возможно стоит пересмотреть алгоритм выполнения программы.
Конструкция if — else в одну строку
Python позволяет записывать условия и в одну строку, в таком формате:
<инструкции если True> if <условие> else <инструкции если False>
Возьмем код, записанный стандартным способом:
a = 1
if a < 0:
print('Отрицательное число')
else:
print('Положительное число')
#Положительное число
И запишем его в одну строку:
a = 1
print('Отрицательное число') if a < 0 else print('Положительное число')
#Положительное число
Все работает правильно. Однако, на мой взгляд читаемость условия в одну строку сильно уступает стандартному способу. Особенно, если условий будет больше.
Вложенные условия
Можно без проблем размещать одни условия внутри других. Ограничений по этому поводу нет.
Для примера напишем код, который будет переводить 100 бальную оценку в 5 бальную:
points = 75
if points >= 90:
print(5)
else:
if points >= 80:
print(4)
else:
if points >= 70:
print(3)
else:
if points >= 60:
print(2)
else:
print(1)
#3
Как видно, не очень удобно читать, гораздо проще так:
points = 75
if points >= 90:
print(5)
elif points >= 80:
print(4)
elif points >= 70:
print(3)
elif points >= 60:
print(2)
else:
print(1)
#3
Операторы сравнения
В Python есть 6 основных операторов сравнения.
| Выражение | Описание |
| if x > 5 | если x больше 5 |
| if x < 5 | если x меньше 5 |
| if x >= 5 | если x больше либо равен 5 |
| if x <= 5 | если x меньше либо равен 5 |
| if x == 5 | если x равен 5 |
| if x != 5 | если x не равен 5 |
x = 5
y = 5
if x < y:
print(f'{x} меньше чем {y}')
if x > y:
print(f'{x} больше чем {y}')
if x == y:
print(f'{x} равно {y}')
if x != y:
print(f'{x} не равно {y}')
#5 равно 5
Цепочки сравнений
Также Python предоставляет возможность сравнивать не только 2 переменных между собой, но и строить цепочки сравнений:
- 1 <= x <= 10 (х больше или равно 1 и меньше или равно 10, т.е. находится в промежутке от 1 до 10)
- a == b == c (все три переменные равны друг другу)
x = 5
if 1 <= x <= 10:
print('Верно')
#Верно
a = 5
b = 5
c = 5
if a == b == c:
print('числа равны')
#числа равны
Применение логических операторов
Логические операторы используются, когда в условном операторе несколько условий.
- and — логическое ‘И’;
- or — логическое ‘ИЛИ’;
- not — логическое ‘НЕ’.
Рассмотрим, как работает каждый логический оператор на примерах.
Оператор and
Служит для объединения условий, означает, что инструкции будут выполняться, только если все части условий будут истинны.
Таблица истинности для оператора and:
| a | b | a and b |
| False | False | False |
| False | True | False |
| True | False | False |
| True | True | True |
Для примера, напишем код, который проверяет, является ли число четным и что оно больше 10:
Для того чтобы определить четное число используем остаток от деления a % 2, если остаток от деления равен 0, то число четное.
Второе условие a > 10 будет просто проверять, что наше число больше 10.
И объединим эти два условия с помощью оператора and.
Теперь, мы получим ответ ‘YES’, если оба условия будут True, если хоть одно из двух условий будет False, то мы получим ответ ‘NO’:
a = 12
if a % 2 == 0 and a > 10:
print('YES')
else:
print('NO')
#YES
a = 8
if a % 2 == 0 and a > 10:
print('YES')
else:
print('NO')
#NO
a = 223
if a % 2 == 0 and a > 10:
print('YES')
else:
print('NO')
#NO
Стоит заметить, что количество операторов and может быть любым.
Оператор or
Служит для объединения условий, означает, что инструкции будут выполняться, если хотя бы одно из условий будет истинно.
Таблица истинности для оператора or:
| a | b | a or b |
| False | False | False |
| False | True | True |
| True | False | True |
| True | True | True |
Напишем код, который проверят переменную и если она равна 10 или 20, то выводит соответствующее сообщение.
a = 20
if a == 10 or a == 20:
print('YES')
else:
print('NO')
#YES
a = 10
if a == 10 or a == 20:
print('YES')
else:
print('NO')
#YES
a = 1
if a == 10 or a == 20:
print('YES')
else:
print('NO')
#NO
Оператор not
Оператор not позволяет заменить на противоположный результат логического выражения.
Таблица истинности для оператора not:
| a | not a |
| False | True |
| True | False |
Для примера напишем код, который проверяет длину пароля и если длина больше 10 символов, то выводит соответствующее сообщение.
passw = 'jtu4i5ud3f4wg43w'
if not (len(passw) < 10):
print('YES')
else:
print('NO')
#YES
Условие в этом случае можно прочитать так: если длина пароля не меньше 10.
Этот код будет делать то же самое:
passw = 'jtu4i5ud3f4wg43w'
if len(passw) > 10:
print('YES')
else:
print('NO')
#YES
Здесь условие читается так: если длина пароля больше 10.
Приоритеты логических операторов
Как и у арифметических операций, у логических тоже есть свой приоритет выполнения:
- в первую очередь выполняется логическое ‘НЕ’ — not;
- далее выполняется логическое ‘И’ — and;
- далее выполняется логическое ‘ИЛИ’ — or.
Если нужно изменить очередность, то нужно использовать скобки, так же, как и с арифметическими операциями.
В Python существует три команды выбора, которые исполняют код в зависимости от установленных условий, значений которых может быть истинным (True) либо ложным (False).
- Команда if выполняет действие, если условие истинно (True), и не делает ничего если ложно (False)
- Команда if-else выполняет действие, если условие истинно (True), или выполняет другое действие, если условие ложно (False)
- Команда if-elif-else выполняет одно из нескольких возможных действий в зависимости от истинности или ложности нескольких условий.
| Содержание страницы: |
|---|
| 1.1. Проверка условий |
| 1.2. Проверка нескольких условий |
| 2. Функция input() |
| 3.1. Команда if |
| 3.2. Команда if-else |
| 3.3. Команда if-elif-else |
| 4. Команда if со списками |
1. Проверка условий в Python.
-
Проверка равенств.
Регулярно в программах переменные сравниваются с другими переменными или значениями. Самое простое условия, это проверить равно ли значение переменной конкретному значению.
>>> car = ‘audi’
>>> car == ‘audi’
True
Присвоим переменной car значение ‘audi’. Во второй строке проверим равно ли значение переменной car. Двойной знак равно (==) используется для проверки равенства. В итоге Python возвращает значение True, означающий что значения равны. В случае неравенства значений, возвращается False.
>>> car = ‘audi’
>>> car == ‘bmw’
False
В Python проверка равенства выполняется с учетом регистра. В случае написания значений с разным регистром, значения получаются не равными.
>>> car = ‘audi’
>>> car == ‘Audi’
False
-
Проверка неравенства.
Проверка неравенства происходит с помощью восклицательного знака и знака равно ( != ). Восклицательный знак представляет отрицание, как и во многих языках программирования.
>>> car = ‘audi’
>>> car != ‘bmw’
True
1.2. Проверка нескольких условий.
-
Использование and для проверки нескольких условий.
Для проверки нескольких условий одновременно, используйте ключевое слово and. Чтобы выражение было истинно (True) оба условия должны быть истинны. В примере проверим возраст людей, чтобы был младше или в возрасте 30 лет.
>>> age_1 = 29
>>> age_2 = 20
>>> age_1 <= 30 and age_2 <= 30
True
Если оба условия выполнены, то возвращается True.
-
Использование or для проверки нескольких условий.
При использовании ключевого слова or, проверка будет истинна если выполнено хотя бы одно условие в выражение. Проверим теперь чтобы хотя бы один из людей был младше 25 лет.
>>> age_1 = 29
>>> age_2 = 20
>>> age_1 < 25 or age_2 < 25
True
2. Функция input().
- Функция input() запрашивает данные у пользователя и получает их. Получив данные, сохраняет их в переменной и в последующем вы можете работать с этой переменной.
>>> name = input(‘Как вас зовут? ‘)
Как вас зовут? Ян # вводит пользователь
>>> print(name)
Ян
- Функция input() всегда возвращает строку. Если мы захотим сложить два числа, то получим не верный ответ. Пример:
>>> a = input(‘Введите число: ‘)
Введите число: 5
>>> b = input(‘Введите число: ‘)
Введите число: 10
>>> a + b
‘510’
Вместо того чтобы сложить 5 и 10 и в итоге получить 15, Python складывает строковое значения ‘5’ и ‘10′, и в итоге получает строку ‘510’. Это операция называется конкатенация строк. В результате создается новая строка из левого операнда, за которым следует правый.
- Если вам требуется получить целое число, то преобразуйте строку в число с помощью функции int():
>>> a = int( input(‘Введите число: ‘))
Введите число: 5
>>> b = int( input(‘Введите число: ‘))
Введите число: 10
>>> a + b
15
- Если вам требуется получить число с плавающей точкой, то используйте функцию float()
>>> a = float(input(‘Введите число: ‘))
Введите число: 12.5
>>> b = float(input(‘Введите число: ‘))
Введите число: 7.3
>>> a + b
19.8
3.1. Команда if.
Самая простая команда if состоит из одного условия и одного действия.
if условие:
дествие # отступ в 4 пробела
Приведем пример программы, которая определяет платный ли вход в кинотеатр:
>>> age = 25
>>> if age >= 18:
… print(‘Вход в кинотеатр для вас платный’)
… print(‘Приобретите билет в кассе’)
…
Вход в кинотеатр для вас платный
Приобретите билет в кассе
В первой строке команды if мы размещаем условия, а во второй строке кода с отступом — практически любое действие. В случае выполнения условия выполняется действие, если условие не выполнено, ничего не происходит.
:
3.2. Команда if-else.
В случае если необходимо выполнить другое действие если условие ложно, можно воспользоваться командой if-else. Блок if записывается так же, как и раньше, а после него записывается блок else с набором действий в случае невыполнения команды if.
>>> age = 17
>>> if age >= 18:
… print(‘Вход в кинотеатр для вас платный’)
… print(‘Приобретите билет в кассе’)
… else:
… print(‘Для вас вход бесплатный’)
…
Для вас вход бесплатный
Блок else записывается на уровне блока If, без 4 пробелов.
3.3. Команда if-elif-else.
Команда if-elif-else позволяет проверить сразу несколько условий. Предположим, стоимость билетов кинотеатр изменяется в зависимости от возврата посетителя.
>>> age = 35
>>> if age <= 7:
… print(‘Для вас вход бесплатный’)
… elif age < 18:
… print(‘Стоимость билета 500 руб’)
… elif age <= 60:
… print(‘Стоимость билета 1000 руб’)
… else:
… print(‘Для вас вход бесплатный’)
…
Стоимость билета 1000 руб
Код выполняется последовательно, программа вначале проверяет соответствие возраста меньше или равно 7 лет, затем < 18 и т.д. Как только условия выполняются, Python выводит результат и действие программы прекращается. Важно ставить правильную последовательность условий. К примеру, если мы поставим условие младше или равно 60 в начало, то возраст меньше 7 и 18 не будет работать и программа сразу выдаст результат максимальной стоимости билета.
Наличие секции else в команде if-elif-else необязательно. Ее присутствие позволяет обработать результат, не удовлетворяющий никаким условиям.
4. Команда if со списками.
С помощью команды if, например при переборе списка, возможно использовать каждый элемент на свое усмотрение.
>>> cars = [ ‘ford’, ‘opel’, ‘audi’, ‘land rover’, ‘bmw’ ]
>>> for brand in cars:
… if brand == ‘audi’:
… print(f»Гарантия на автомобиль {brand.title()} 2 года»)
… elif brand == ‘bmw’:
… print(f»Гарантия на автомобиль {brand.title()} 3 года»)
… else:
… print(f»Гарантия на автомобиль {brand.title()} 5 лет»)
…
Гарантия на автомобиль Ford 5 лет
Гарантия на автомобиль Opel 5 лет
Гарантия на автомобиль Audi 2 года
Гарантия на автомобиль Land Rover 5 лет
Гарантия на автомобиль Bmw 3 года
В данном примере с помощью команды for мы перебираем весь список автомобилей. Если марка автомобиля соответствует условия if-elif, то выводится для этих марок свое сообщение по условиям гарантии. В случае не совпадения условий, выдается общее сообщение для всех остальных марок.
Далее: Словари в Python
Назад: Цикл for и функция range в Python