Условный оператор
Все ранее рассматриваемые программы имели линейную структуру: все инструкции выполнялись последовательно одна за одной, каждая записанная инструкция обязательно выполняется.
Допустим мы хотим по данному числу 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, то это можно сделать следующим образом:
if x < 0:
x = -x
print(x)
В этом примере переменной x будет присвоено значение -x, но только в том случае, когда x
Для выделения блока инструкций, относящихся к инструкции if или else в языке Питон используются отступы. Все инструкции, которые относятся к одному блоку, должны иметь равную величину отступа, то есть одинаковое число пробелов в начале строки. Рекомендуется использовать отступ в 4 пробела и не рекомедуется использовать в качестве отступа символ табуляции.
Это одно из существенных отличий синтаксиса Питона от синтаксиса большинства языков, в которых блоки выделяются специальными словами, например, нц. кц в Кумире, begin. end в Паскале или фигурными скобками в Си.
ОПЕРАТОРЫ ПРИНАДЛЕЖНОСТИ В PYTHON
В Python существует два оператора принадлежности: in и not in.
Эти операторы проверяют, является ли значение частью какой либо последовательности: строки, списка, кортежа, словаря.
Оператор «in»
Возвращает True, если значение присутствует в последовательности, иначе возвращает False.
Пример со строкой:
a = "b" in "abc" print(a) TrueПример со списком:
a = 7 in [3, 4, 5] print(a) FalseОператор «not in»
Возвращает True, если значения нет в последовательности. Если значение присутствует в последовательности, то возвращает False. Пример:
a = 5 not in (2, 3, 4) print(a) Следование в питоне как записать
Ряд операций представляют условные выражения. Все эти операции принимают два операнда и возвращают логическое значение, которое в Python представляет тип bool . Существует только два логических значения — True (выражение истинно) и False (выражение ложно).
Операции сравнения
Простейшие условные выражения представляют операции сравнения, которые сравнивают два значения. Python поддерживает следующие операции сравнения:
- == Возвращает True, если оба операнда равны. Иначе возвращает False.
- != Возвращает True, если оба операнда НЕ равны. Иначе возвращает False.
- > (больше чем) Возвращает True, если первый операнд больше второго.
- < (меньше чем) Возвращает True, если первый операнд меньше второго.
- >= (больше или равно) Возвращает True, если первый операнд больше или равен второму.
Примеры операций сравнения:
a = 5 b = 6 result = 5 == 6 # сохраняем результат операции в переменную print(result) # False - 5 не равно 6 print(a != b) # True print(a > b) # False - 5 меньше 6 print(a < b) # True bool1 = True bool2 = False print(bool1 == bool2) # False - bool1 не равно bool2
Операции сравнения могут сравнивать различные объекты - строки, числа, логические значения, однако оба операнда операции должны представлять один и тот же тип.
Логические операции
Для создания составных условных выражений применяются логические операции. В Python имеются следующие логические операторы:
-
Оператор and (логическое умножение) применяется к двум операндам:
x and y
Сначала оператор and оценивает выражение x, и если оно равно False, то возвращается его значение. Если оно равно True, то оценивается второй операнд - y и возвращается значение y.
age = 22 weight = 58 result = age > 21 and weight == 58 print(result) # True
В данном случае оператор and сравнивает результаты двух выражений: age > 21 weight == 58 . И если оба этих выражений возвращают True, то оператор and также возвращает True (формально возвращается значение последнего операнда). Но операндами оператора and необязательно выступают значения True и False. Это могут быть любые значения. Например:
result = 4 and "w" print(result) # w, так как 4 равно True, поэтому возвращается значение последнего операнда result = 0 and "w" print(result) # 0, так как 0 эквивалентно False
x or y
Сначала оператор or оценивает выражение x, и если оно равно True, то возвращается его значение. Если оно равно False, то оценивается второй операнд - y и возвращается значение y. Например
age = 22 isMarried = False result = age > 21 or isMarried print(result) # True, так как выражение age > 21 равно True
И также оператор or может применяться к любым значениям. Например:
result = 4 or "w" print(result) # 4, так как 4 эквивалентно True, поэтому возвращается значение первого операнда result = 0 or "w" print(result) # w, так как 0 эквивалентно False, поэтому возвращается значение последнего операнда
age = 22 isMarried = False print(not age > 21) # False print(not isMarried) # True print(not 4) # False print(not 0) # True
Оператор in
Оператор in возвращает True если в некотором наборе значений есть определенное значение. Он имеет следующую форму:
значение in набор_значений
Например, строка представляет набор символов. И с помощью оператора in мы можем проверить, есть ли в ней какая-нибудь подстрока:
message = "hello world!" hello = "hello" print(hello in message) # True - подстрока hello есть в строке "hello world!" gold = "gold" print(gold in message) # False - подстроки "gold" нет в строке "hello world!"
Если нам надо наоборот проверить, нет ли в наборе значений какого-либо значения, то мы може использовать модификацию оператора - not in . Она возвращает True , если в наборе значений НЕТ определенного значения:
message = "hello world!" hello = "hello" print(hello not in message) # False gold = "gold" print(gold not in message) # True
Логические выражения в Python 3
Логический тип данных (или Boolean) – это примитивный тип, который принимает одно из двух возможных значений: истину (True) или ложь (False). Этот тип используется во многих языках программирования для построения алгоритмов и управления поведением программ.
Примечание: Название этого типа данных (Boolean) всегда пишется с заглавной буквы, поскольку он назван в честь математика Джорджа Буля, который занимался исследованиями математической логики. Значения True и False тоже пишутся с большой буквы – в Python они являются специальными значениями.
Данное руководство ознакомит вас с основами булевой логики в Python: операторами сравнения, логическими операторами, таблицами истинности и т.п.
Операторы сравнения
В программировании операторы сравнения используются при оценке и сравнении значений для последующего сведения их к одному логическому значению (True или False).
Операторы сравнения Python 3 представлены в этой таблице:
| Оператор | Значение |
| == | Проверяет равенство между компонентами; условие истинно, если компоненты равны. |
| != | Проверяет равенство между компонентами; условие истинно, если компоненты НЕ равны. |
| Оценивает значение левого компонента; условие истинно, если он меньше, чем правый. | |
| > | Оценивает значение левого компонента; условие истинно, если он больше, чем правый. |
| Оценивает значение левого компонента; условие истинно, если он меньше или равен правому компоненту. | |
| >= | Оценивает значение левого компонента; условие истинно, если он больше или равен правому компоненту. |
Попробуйте поработать с этими операторами, чтобы понять, как они действуют. Для начала создайте пару переменных:
Теперь сравните значения переменных с помощью вышеперечисленных операторов.
x = 5
y = 8
print("x == y:", x == y)
print("x != y:", x != y)
print("x < y:", x < y)
print("x > y:", x > y)
print("x print("x >= y:", x >= y)
x == y: False
x != y: True
x < y: True
x > y: False
x x >= y: False
Следуя математической логике, Python оценивает соотношения между значениями переменных так:
- 5 равно 8? Ложь
- 5 не равно 8? Истина
- 5 меньше 8? Истина
- 5 больше 8? Ложь
- 5 меньше или равно 8? Истина
- 5 больше или равно 8? Ложь
Также операторы сравнения можно применять к числам с плавающей точкой и строкам.
Примечание: Строки чувствительны к регистру; чтобы отключить такое поведение, нужно использовать специальный метод.
Попробуйте сравнить две строки:
Hello = "Hello"
hello = "hello"
print("Hello == hello: ", Hello == hello)
Hello == hello: False
Строки Hello и hello содержат одинаковый набор символов, однако они не равны, поскольку одна из них содержит символы верхнего регистра. Попробуйте добавить ещё одну переменную, которая также будет содержать символы верхнего регистра, а затем сравните их.
Hello = "Hello"
hello = "hello"
Hello_there = "Hello"
print("Hello == hello: ", Hello == hello)
print("Hello == Hello_there", Hello == Hello_there)
Hello == hello: False
Hello == Hello_there: True
Операторы сравнения можно применять к логическим значениям True и False:
t = True
f = False
print("t != f: ", t != f)
t != f: True
Обратите внимание на разницу между операторами = и ==.
x = y # Оператор присваивания. Устанавливает равенство между x и y (то есть присваивает x значение y).
x == y # Оператор сравнения. Проверяет равенство между x и y и оценивает выражение как истинное или ложное. Выражение истинно, если x и y равны.
Логические операторы
Для сравнения значений используется три логических оператора, которые сводят результат к логическому значению True или False.
| Оператор | Значение |
| and | Оператор «и»: выражение истинно, если оба его компонента истинны. |
| or | Оператор «или»: выражение истинно, если хотя бы один из его компонентов истинен. |
| not | Оператор «не»: изменяет логическое значение компонента на противоположное. |
Логические операторы обычно используются для оценки двух или больше выражений. Например, их можно использовать в программе, которая проверит:
- сдал ли студент экзамен
- и зарегистрирован ли он.
Если оба значения истинны, студент будет переведён на следующий курс.
Другой пример: программа с логическими операторами может проверять активность пользователя в онлайн-магазине:
- использовал ли он кредит магазина
- или заказывал ли он товары в течение последних 6 месяцев.
Для примера попробуйте сравнить три выражения:
print((9 > 7) and (2 < 4)) # Оба выражения истинны (True)
print((8 == 8) or (6 != 6)) # Одно из выражений истинно (True)
print(not(3 True
True
True
В первом случае оба выражения истинны, потому оператор and возвращает True.
Во втором случае истинно только значение 8 == 8. Поскольку хотя бы одно из предложенных условий истинно, оператор or возвращает True. Оператор and в таком случае выдал бы False.
Теперь попробуйте сравнить числа с плавающей точкой.
- Поскольку в первом примере одно из выражений ложно, and вернёт False. Оператор and оценивает выражение как истинное только тогда, когда оба компонента истинны.
- Поскольку оба выражения ложны, оператор or выдаст False.
- Поскольку выражение истинно, оператор not вернёт False (not True = False).
Примечание: Если вы не понимаете, как это работает, вам помогут разобраться таблицы истинности. Эту тему мы рассмотрим далее в этом руководстве.
Логические операторы можно объединять в составные выражения:
Полученное значение True становится компонентом следующего выражения: (-0.2 > 1.4) and (True). Оператор and выдаст False, потому что выражение -0.2 > 1.4 ложно. (False) and (True) = False.
Далее оператор not заменит полученное значение False на обратное ему логическое значение: not(False) = True. Значит, результат будет таким:
Таблицы истинности
Математическая логика – очень полезная в программировании область знаний. В данном руководстве мы ознакомимся с основными её аспектами.
Ниже представлены таблицы истинности для оператора сравнения == и всех логических операторов. Ими можно пользоваться при написании логических выражений. В таблицах перечислены общие случаи использования оператора, потому их рекомендуется выучить наизусть.
Таблица истинности оператора ==
| x | == | y | Результат |
| True | == | True | True |
| True | == | False | False |
| False | == | True | False |
| False | == | False | True |
Таблица истинности оператора AND
| x | and | y | Результат |
| True | and | True | True |
| True | and | False | False |
| False | and | True | False |
| False | and | False | False |
Таблица истинности оператора OR
| x | or | y | Результат |
| True | or | True | True |
| True | or | False | True |
| False | or | True | True |
| False | or | False | False |
Таблица истинности оператора NOT
| not | x | Результат |
| not | True | False |
| not | False | True |
Таблицы истинности – общие математические таблицы, которые используются в логике. Их полезно выучить наизусть, чтобы затем применять при построении алгоритмов и написании программ.
Использование логических операторов для управления потоком
Для управления результатом и потоками данных программы можно использовать условные операторы (condition) с выражениями (clause).
Условные операторы оценивают значение как истинное или ложное.
Выражение – это блок кода, который идёт после условного оператора и определяет результат программы.
Ниже приведён блок кода, который показывает, как объединить условные операторы для управления потоком программы Python.
if grade >= 65: # условие
print("Passing grade") # выражение
else:
print("Failing grade")
Эта программа оценивает результат каждого студента и определяет, сдал он экзамен или нет. К примеру, если студент набрал 83, первое условие будет иметь значение True, и программа выведет на экран строку:
Если же студент набрал 59 баллов, первое условие будет ложно, потому программа выдаст:
Читайте также: руководство PEP 8
Заключение
Данное руководство охватывает основы работы с логическими данными Python.
Читайте также: