Поиск по сайту:

Понимание булевой логики в Python 3

Введение

Тип данных Boolean может принимать одно из двух значений: True или False. Мы используем булевы значения в программировании для сравнения и определения потока управления в данной программе.

Булевы значения представляют собой значения истинности, связанные с логическим разделом математики, который используется в алгоритмах компьютерных наук. Названное в честь математика Джорджа Буля, слово Boolean всегда начинается с заглавной B. Значения True и False также всегда будут с заглавной T и F соответственно, поскольку они являются специальными значениями в Python.

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

Предпосылки

У вас должен быть установлен Python 3 и настроена среда программирования на вашем компьютере или сервере. Если у вас не настроена среда программирования, вы можете обратиться к руководствам по установке и настройке среды программирования на вашем сервере, подходящей для вашей операционной системы (Ubuntu, CentOS, Debian и т. д.).

Операторы сравнения

В программировании операторы сравнения используются для сравнения значений и оценки до одного логического значения True или False.

Информация: Чтобы следовать примеру кода в этом руководстве, откройте интерактивную оболочку Python в вашей локальной системе, выполнив команду python3. Затем вы можете копировать, вставлять или редактировать примеры, добавляя их после приглашения >>>.

В таблице ниже представлены логические операторы сравнения.

Operator What it means
== Equal to
!= Not equal to
< Less than
> Greater than
<= Less than or equal to
>= Greater than or equal to

Чтобы понять, как работают эти операторы, давайте назначим два целых числа двум переменным в программе Python:

x = 5
y = 8

В этом примере, поскольку x имеет значение 5, оно меньше, чем y со значением 8.

Используя эти две переменные и связанные с ними значения, давайте рассмотрим операторы из таблицы выше. В нашей программе мы попросим Python распечатать, имеет ли каждый оператор сравнения значение True или False. Чтобы помочь нам и другим людям лучше понять этот вывод, Python также выводит строку, чтобы показать нам, что он оценивает.

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 <= y:", x <= y)
print("x >= y:", x >= y)

Когда мы запустим эту программу, мы получим следующий вывод.

Output
x == y: False
x != y: True
x < y: True
x > y: False
x <= y: True
x >= y: False

Следуя математической логике, в каждом из приведенных выше выражений Python оценил:

  • Является ли 5 (x) равным 8 (y)? Неверно
  • Разве 5 не равно 8? Верно
  • 5 меньше 8? Верно
  • Пять больше, чем 8? Неверно
  • 5 меньше или равно 8? Верно
  • Разве 5 не меньше или равно 8? Неверно

Хотя мы использовали здесь целые числа, мы могли бы заменить их значениями с плавающей запятой.

Строки также могут использоваться с логическими операторами. Они чувствительны к регистру, если вы не используете дополнительный строковый метод.

Вот как на практике строки сравниваются с булевыми операторами:

Sammy = "Sammy"
sammy = "sammy"

print("Sammy == sammy: ", Sammy == sammy)

Вывод для приведенной выше программы возвращает следующее.

Output
Sammy == sammy:  False

Строка Сэмми выше не равна строке Сэмми, потому что они не идентичны; один начинается с S в верхнем регистре, а другой — с s в нижнем регистре. Но если мы добавим еще одну переменную, которой присвоено значение Sammy, тогда они будут оценены как равные:

Sammy = "Sammy"
sammy = "sammy"
also_Sammy = "Sammy"

print("Sammy == sammy: ", Sammy == sammy)
print("Sammy == also_Sammy", Sammy == also_Sammy)

После запуска программы выше мы получим следующий вывод. Это указывает на то, что пока строки абсолютно идентичны (включая регистр), они будут оцениваться как равные с точки зрения логической логики.

Output
Sammy == sammy:  False
Sammy == also_Sammy:  True

Вы также можете использовать другие операторы сравнения, включая > и <, для сравнения двух строк. Python будет сравнивать эти строки лексикографически, используя значения символов ASCII.

Мы также можем оценивать логические значения с помощью операторов сравнения:

t = True
f = False

print("t != f: ", t != f)

Программа выше вернет следующее.

Output
t != f:  True

Как указано в выводе выше, написанный нами код оценил, что True не равно False.

Обратите внимание на разницу между двумя операторами = и ==.

x = y	# Sets x equal to y
x == y	# Evaluates whether x is equal to y

Первый, = — это оператор присваивания, который устанавливает одно значение равным другому. Второй, == — это оператор сравнения, который оценивает, равны ли два значения.

Логические операторы

Есть три логических оператора, которые используются для сравнения значений. Они оценивают выражения до логических значений, возвращая либо True, либо False. Этими операторами являются и, или и не, и они определены в таблице ниже.

Operator What it means Example
and True if both are true x and y
or True if at least one is true x or y
not True only if false not x

Логические операторы обычно используются для оценки того, являются ли два или более выражений истинными или ложными. Например, их можно использовать, чтобы определить, является ли оценка удовлетворительной и, зарегистрирован ли учащийся на курсе. Если оба эти случая верны, то студенту будет присвоена оценка в системе. Другим примером может быть определение того, является ли пользователь действительным активным покупателем интернет-магазина на основе того, есть ли у него кредит в магазине или совершены ли покупки за последние 6 месяцев.

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

print((9 > 7) and (2 < 4))	# Both original expressions are True
print((8 == 8) or (6 != 6))	# One original expression is True
print(not(3 <= 1))			# The original expression is False

Output
True
True
True

В первом случае print((9 > 7) и (2 < 4)), оба 9 > 7 и 2 < 4 оценивают значение True, поскольку использовался оператор and.

Во втором случае print((8 == 8) или (6 != 6)), поскольку 8 == 8 оценивается как True, он не создает Разница в том, что 6 != 6 оценивается как False, поскольку использовался оператор или. Если бы мы использовали оператор and, это было бы равно False.

В третьем случае, print(not(3 <= 1)), оператор not отменяет значение False, которое возвращает 3 <=1. .

Давайте заменим числа с плавающей запятой на целые числа и будем стремиться к ложным оценкам:

print((-0.2 > 1.4) and (0.8 < 3.1))	# One original expression is False
print((7.5 == 8.9) or (9.2 != 9.2))	# Both original expressions are False		
print(not(-5.7 <= 0.3))				# The original expression is True

В приведенном выше примере

  • и должны иметь по крайней мере одно выражение False, оцениваемое как False,
  • или оба выражения должны оцениваться как False,
    • Внутреннее выражение
  • not должно иметь значение True, чтобы новое выражение оценивалось как False.

Если приведенные выше результаты кажутся вам неясными, мы пройдемся по некоторым таблицам истинности ниже, чтобы вы были в курсе.

Вы также можете писать составные операторы, используя and, or и not:

not((-0.2 > 1.4) and ((0.8 < 3.1) or (0.1 == 0.1)))

Давайте сначала посмотрим на самое внутреннее выражение: (0,8 < 3,1) или (0,1 == 0,1). Это выражение оценивается как True, поскольку оба математических утверждения верны.

Теперь мы можем взять возвращаемое значение True и объединить его со следующим внутренним выражением: (-0.2 > 1.4) и (True). В этом примере возвращается False, поскольку математическое выражение -0.2 > 1.4 равно False, а (False) и (True) возвращает False.

Наконец, у нас есть внешнее выражение: not(False), которое оценивается как True, поэтому окончательное возвращаемое значение, если мы распечатаем этот оператор:

Output
True

Логические операторы и, или и не оценивают выражения и возвращают логические значения.

Таблицы истинности

В логическом разделе математики можно многое узнать, но мы можем выборочно изучить некоторые из них, чтобы улучшить наше алгоритмическое мышление при программировании.

Ниже приведены таблицы истинности для оператора сравнения == и каждого из логических операторов и, или и не. Хотя вы можете их обосновать, также может быть полезно поработать над их запоминанием, так как это может ускорить процесс принятия решений в программировании.

== Таблица истинности

x == y Returns
True == True True
True == False False
False == True False
False == False True

И Таблица истинности

x and y Returns
True and True True
True and False False
False and True False
False and False False

ИЛИ Таблица истинности

x or y Returns
True or True True
True or False True
False or True True
False or False False

НЕ Таблица истинности

not x Returns
not True False
not False True

Таблицы истинности — это общие математические таблицы, используемые в логике, и их полезно запомнить или иметь в виду при построении алгоритмов (инструкций) в компьютерном программировании.

Использование логических операторов для управления потоком

Чтобы управлять потоком и результатами программы в форме операторов управления потоком, мы можем использовать условие, за которым следует предложение.

Условие оценивается до логического значения True или False, представляя точку, в которой в программе принимается решение. То есть условие сообщает нам, оценивается ли что-то как True или False.

Предложение — это блок кода, который следует за условием и диктует результат программы. То есть это do this часть конструкции «Если x равно True, то сделайте это».

Блок кода ниже показывает пример операторов сравнения, работающих в тандеме с условными операторами для управления потоком программы Python:

if grade >= 65:					# Condition
    print("Passing grade")		# Clause

else:
    print("Failing grade")

Эта программа будет оценивать, является ли оценка каждого учащегося удовлетворительной или неудовлетворительной. В случае учащегося с оценкой 83 первое утверждение будет оцениваться как True, и будет запущено утверждение печати Passup. В случае учащегося с оценкой 59 первое утверждение будет оцениваться как False, поэтому программа перейдет к выполнению оператора печати, связанного с выражением else. : Неудовлетворительная оценка.

Поскольку каждый отдельный объект в Python может оцениваться как True или False, руководство по стилю PEP 8 рекомендует не сравнивать значение с True или False, потому что это менее читабельно и часто вернуть неожиданное логическое значение. То есть вам следует избегать использования if sammy == True: в своих программах. Вместо этого сравните sammy с другим небулевым значением, которое вернет логическое значение.

Логические операторы представляют условия, которые можно использовать для определения конечного результата программы с помощью операторов управления потоком.

Заключение

В этом руководстве обсуждались операции сравнения и логические операторы, принадлежащие к типу Boolean, а также таблицы истинности и использование логических операторов для управления потоком программы.

Вы можете узнать больше о других типах данных в нашем учебнике «Как писать условные операторы».

У нас также есть бесплатная электронная книга по Python Как программировать на Python, которая может помочь как новичкам, так и тем, кому нужен краткий справочник.