Следование в питоне как записать

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

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

Допустим мы хотим по данному числу 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.

Читайте также: