Логические выражения и операторы

Логические выражения и логический тип данных

Часто в реальной жизни мы соглашаемся с каким-либо утверждением или отрицаем его. Например, если вам скажут, что сумма чисел 3 и 5 больше 7, вы согласитесь, скажете: «Да, это правда». Если же кто-то будет утверждать, что сумма трех и пяти меньше семи, то вы расцените такое утверждение как ложное.

Подобные фразы предполагают только два возможных ответа – либо "да", когда выражение оценивается как правда, истина, либо "нет", когда утверждение оценивается как ошибочное, ложное. В программировании и математике если результатом вычисления выражения может быть лишь истина или ложь, то такое выражение называется логическим.

Например, выражение 4 > 5 является логическим, так как его результатом является либо правда, либо ложь. Выражение 4 + 5 не является логическим, так как результатом его выполнения является число.

На прошлом уроке мы познакомились с тремя типами данных – целыми и вещественными числами, а также строками. Сегодня введем четвертый – логический тип данных (тип bool). Его также называют булевым. У этого типа всего два возможных значения: True (правда) и False (ложь).

>>> a = True
>>> type(a)
<class 'bool'>
>>> b = False
>>> type(b)
<class 'bool'>

Здесь переменной a было присвоено значение True, после чего с помощью встроенной в Python функции type() проверен ее тип. Интерпретатор сообщил, что это переменная класса bool. Понятия "класс" и "тип данных" в данном случае одно и то же. Переменная b также связана с булевым значением.

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

>>> int(True)
1
>>> int(False)
0

Возможно и обратное. Можно преобразовать какое-либо значение к булевому типу:

>>> bool(3.4)
True
>>> bool(-150)
True
>>> bool(0)
False
>>> bool(' ')
True
>>> bool('')
False

И здесь работает правило: всё, что не 0 и не пустота, является правдой.

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

Говоря на естественном языке (например, русском) мы обозначаем сравнения словами "равно", "больше", "меньше". В языках программирования используются специальные знаки, подобные тем, которые используются в математике: > (больше), < (меньше), >= (больше или равно), <= (меньше или равно), == (равно), != (не равно).

Не путайте операцию присваивания значения переменной, обозначаемую в языке Python одиночным знаком "равно", и операцию сравнения (два знака "равно"). Присваивание и сравнение – разные операции.

>>> a = 10
>>> b = 5
>>> a + b > 14
True
>>> a < 14 - b
False
>>> a <= b + 5
True
>>> a != b
True
>>> a == b
False
>>> c = a == b
>>> a, b, c
(10, 5, False)

В данном примере выражение c = a== b состоит из двух подвыражений. Сначала происходит сравнение (==) переменных a и b. После этого результат логической операции присваивается переменной c. Выражение a, b, c просто выводит значения переменных на экран.

Сложные логические выражения

Логические выражения типа kByte >= 1023 являются простыми, так как в них выполняется только одна логическая операция. Однако, на практике нередко возникает необходимость в более сложных выражениях. Может понадобиться получить ответа "Да" или "Нет" в зависимости от результата выполнения двух простых выражений. Например, "на улице идет снег или дождь", "переменная news больше 12 и меньше 20".

В таких случаях используются специальные операторы, объединяющие два и более простых логических выражения. Широко используются два оператора – так называемые логические И (and) и ИЛИ (or).

Чтобы получить True при использовании оператора and, необходимо, чтобы результаты обоих простых выражений, которые связывает данный оператор, были истинными. Если хотя бы в одном случае результатом будет False, то и все сложное выражение будет ложным.

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

Допустим, переменной x было присвоено значение 8 (x = 8), переменной y присвоили 13 (y = 13). Логическое выражение y < 15 and x > 8 будет выполняться следующим образом. Сначала выполнится выражение y < 15. Его результатом будет True. Затем выполнится выражение x > 8. Его результатом будет False. Далее выражение сведется к True and False, что вернет False.

>>> x = 8
>>> y = 13
>>> y < 15 and x > 8
False

Если бы мы записали выражение так: x > 8 and y < 15, то оно также вернуло бы False. Однако сравнение y < 15 не выполнялось бы интерпретатором, так как его незачем выполнять. Ведь первое простое логическое выражение (x > 8) уже вернуло ложь, которая, в случае оператора and, превращает все выражение в ложь.

В случае с оператором or второе простое выражение проверяется, если первое вернуло ложь, и не проверяется, если уже первое вернуло истину. Так как для истинности всего выражения достаточно единственного True, неважно по какую сторону от or оно стоит.

>>> y < 15 or x > 8
True

В языке Python есть еще унарный логический оператор not, т. е. отрицание. Он превращает правду в ложь, а ложь в правду. Унарный он потому, что применяется к одному выражению, стоящему после него, а не справа и слева от него как в случае бинарных and и or.

>>> not y < 15
False

Здесь у < 15 возвращает True. Отрицая это, мы получаем False.

>>> a = 5
>>> b = 0
>>> not a
False
>>> not b
True

Число 5 трактуется как истина, отрицание истины дает ложь. Ноль приравнивается к False. Отрицание False дает True.

Практическая работа

  1. Присвойте двум переменным любые числовые значения.

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

  3. Аналогично выполните п. 2, но уже используя оператор or.

  4. Попробуйте использовать в логических выражениях переменные строкового типа. Объясните результат.

Создано

Обновлено

Комментарии

У меня в версии 2.7.x следующие результаты:

>>> x = 1
>>> x1 = 'aa'
>>> x < x1
True
>>> x > x1
False
>>> x = -999999
>>> x < x1
True
>>> x > x1
False
>>> x = 9999999
>>> x < x1
True
>>> x > x1
False

Может кто-нибудь подсказать, какой принцип применяется для сравнения?

Ответ на от Гость

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

>>> int() < str()
True

Однако Python 3 уже на попытку сравнения данных разного типа выдает ошибку:

>>> int() < str()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unorderable types: int() < str()
>>> "aa" < 89
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unorderable types: str() < int()

Если оператор and применяется к числам, то результатом является значение последнего операнда, если же применяется оператор or, то результатом выполнения является значение первого операнда. Вопрос: какой алгоритм используется Python в данной ситуации?

>>> 2 and 4
4
>>> 2 and 4 and -5
-5
>>> 2 or -4 or 5
2

Ответ на от Гость

Если первый операнд ложь, то в случае and он будет результатом, если истина, то второй операнд не зависимо от его значения. Например:

>>> 0 and 5
0

При использовании or наоборот - даст первый операнд, если он истина и даст второй в любом другом случае. Пример:

>>> 1 or 0
1
>>> 0 or 'one'
'one'
>>>

Ответ на от Гость

Да, отличаются. Причем & и | в разных языках программирования могут обозначать разное. Например, в Python знак & может обозначать пересечение множеств, а | - их объединение, а также по отношению к целым числам побитовые операции ИЛИ и И.

Побитовые (&, |) и логические (and, or) операторы - разные вещи.

Ответ на от Гость

>>> x = True
>>> x
True
 
>>> x == 1
True
>>> x == 2
False
>>> x + 2
3

То есть переменную можно инициализировать как True, но в зависимости от контекста операций она может проявлять себя как тип int. Не забываем, что Python язык с динамической типизацией...

Ответ на от Гость

он выдает второй операнд, потому что первый "ложь", причем НЕ ЗАВИСИМО от того, что есть второй операнд. Кста - 5 - это True Ложь - это 0, пустая строка и спецобъект None.