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

Логическими выражениями называют утверждения, которые могут быть оценены как истинные или ложные. Например, выражение «Идёт дождь» в зависимости от погоды будет истинным или ложным. Так и в Python результатом вычисления любого логического выражения всегда будет значение логического типа данных True или False.

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

Логический тип данных также называют булевым типом (англ. – boolean) в честь британского математика и философа Джорджа Буля (англ. – George Boole). Именно он в середине 19 века предложил систему рассуждений, где каждое высказывается либо истинное, либо ложное, что легло в основу булевой алгебры. Благодаря работе Буля современные компьютеры обрабатывают данные, основываясь на простейших двоичных состояниях: 1 и 0, соответствующих логическим понятиям истинности и ложности.

Логические значения объектов

Любой объект в Python обладает определенным логическим значением, которое можно получить с помощью встроенной функции bool() (от англ. boolean – булев (логический) тип данных).

Функция bool() возвращает True, если объект считается истинным, и False, если объект считается ложным.

К истинным значениям относятся любые непустые объекты и ненулевые числа:

print(bool("В саду распустились розы")) 
# Вывод: True
print(bool({"Имя": "Копатыч", "Место жительства": "Долина Смешариков"})) 
# Вывод: True
print(bool(256)) 
# Вывод: True

К ложным значениям относятся любые пустые объекты, число 0 любого типа и объект None:

print(bool("")) 
# Вывод: False
print(bool(0.0)) 
# Вывод: False
print(bool(None))
# Вывод: False

Связь с типом целых чисел

Булевы значения True и False тесно связаны с целочисленным типом данных (int): True соответствует числу 1, а False – числу 0. Мы даже можем явно преобразовать булевы значения в целые числа с помощью функции int():

print(int(True)) 
# Вывод: 1
print(int(False)) 
# Вывод: 0

Данная особенность может применяется в арифметических операциях, хотя это не является распространенной практикой.

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

Для проверки отношения между объектами используются операторы сравнения. Их цель – сравнение содержимого объектов, чтобы определить отношение между двумя величинами. Результатом сравнения всегда является булево значение, указывающее на истинность или ложность выражения.

Сравнение чисел в Python работает точно так же, как и в обычной математике:

print(21 < 42) 
# Вывод: True
print(12 <= 1) 
# Вывод: False
print(14 == 17) 
# Вывод: False

Важно различать оператор сравнения на равенство == и оператор присваивания =. Они выполняют совершенно разные задачи, и неправильное их использование приведёт к ошибкам.

Сравнение строк

Операторы сравнения могут применяться и к строкам. В этом случае строки сравниваются лексикографически (посимвольно) на основе их порядковых номеров в Юникоде. Сначала сравнивается первый символ каждой строки, затем второй и так далее. Строчные буквы считаются меньше прописных, а латинские символы больше кириллических.

Например, если сравнить строки, содержащие строчные английские буквы "a" и "b", то строка с буквой "a" будет меньше:

print("a" < "b") 
# Вывод: True

Это связано с тем, что порядковый номер символа "a" в Юникоде меньше, чем порядковый номер символа "b". Убедимся в этом, получив номера символов с помощью функции ord():

print(ord("a")) 
# Вывод: 97 
print(ord("b"))
# Вывод: 98

Так как 97 < 98, то и "a" < "b".

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

print("Груша" > "груша") 
# Вывод: False
print("большой театр" >= "Большой театр") 
# Вывод: True

Если символы совпадают, то больше будет так строка, у которой больше длина:

print("Гол" < "Голова") 
# Вывод: True
print("Котёнок" > "Кот") 
# Вывод: True

Поэтому строки равны только в том случае, если у них совпадают все символы и длина строки.

Операторы идентичности

В отличие от оператора сравнения на равенство (==), который проверяет равенство значений, операторы идентичности is и is not проверяют указывают ли две переменные на один и тот же объект в памяти компьютера.

На практике операторы is и is not чаще всего применяются при сравнении с None для проверки на отсутствие значения, так как None представляет собой уникальный объект, и любое другое значение гарантированно не совпадает с ним по ссылке:

apples = None
print(apples is None)
# Вывод: True 

melons = 100
print(melons is None)
# Вывод: False

Операторы идентичности следует использовать с осторожностью при сравнении изменяемых объектов (таких как списки и словари), так как они проверяют равенство идентификаторов объектов, а не их содержимого.

Например, создадим две переменные целочисленного типа данных (неизменяемого) с одинаковым значением и увидим, что обе будут ссылаться на один объект в памяти компьютера:

number1 = 10
number2 = 10
print(number1 is number2) 
# Вывод: True

Однако для каждого из списков (изменяемого типа данных), несмотря на одинаковое содержимое, будут созданы новые объекты:

fruits1 = ["Яблоки", "Груши"]
fruits2 =  ["Яблоки", "Груши"]
print(fruits1 is fruits2) 
# Вывод: False

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

fruits1 = ["Яблоки", "Груши"]
fruits2 = fruits_1
print(fruits1 is fruits_2) 
# Вывод: True

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

Логические операторы выполняют логические операции над простыми выражениями, объединяя их в единое сложное выражение. Основываясь на законах алгебры логики, в Python выделяют три основные логические операции: отрицание, конъюнкцию и дизъюнкцию.

Отрицание изменяет значение условия на противоположное, фактически являясь инверсией. В реальной жизни аналогичную роль играет частица «не». Предположим, вы заявляете друзьям в кафе: «Мы закажем пиццу с ананасами», но ваш приятель отрицает ваше высказывание: «Мы не закажем пиццу с ананасами».

Интуитивно понять смысл терминов «конъюнкция» и «дизъюнкция» может быть сложно, так как они заимствованы из латыни. Конъюнкция буквально означает «связывание», отражая требование выполнения всех заданных условий одновременно, поэтому её ассоциируют с союзом «и». Так, если кто-то заявит: «Мы закажем и пиццу с ананасами, и пиццу с грибами», то его высказывание будет истинным только, если будут заказаны обе пиццы.

Что касается дизъюнкции, то её корень восходит к слову «разделять» и сама операция приближена к союзу «или». Она воплощает понятие альтернативы, подразумевая выбор одного или обоих из предлагаемых вариантов. Подобно ситуации, когда кто-то скажет: «Мы закажем или пиццу с грибами, или пиццу с курицей», и он будет прав как в случае заказа одной из перечисленных пицц, так и сразу обеих.

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

В Python рассмотренные логические операции реализуются тремя основными операторами: not (с англ. – не), and (с англ. – и) и or (с англ. – или). Первый реализует отрицание, второй – конъюнкцию, а третий – дизъюнкцию.

Логические операторы работают с логическими значениями (True и False), а их приоритет аналогичен тому, который установлен для арифметических операций:

1. Отрицание.
2. Конъюнкция (логическое умножение).
3. Дизъюнкция (логическое сложение).

Однако с помощью круглых скобок можно изменять приоритет выполнения операторов, например, чтобы сначала выполнился оператор or, и только затем and:

print(18 > 16 and (4 == 5 or 1 > 0))
# Вывод: True

Логическое отрицание

Задача оператора not состоит в изменении исходного значения на противоположное. Так истинное значение становится ложным и наоборот:

print(not(True)) 
# Вывод: False
print(not(10 > 0))
 # Вывод: False

Конъюнкция: логическое умножение

Результат конъюнкции или логического умножения с помощью оператора and будет истинным лишь тогда, когда каждое объединяемое выражение истинно. Поэтому его также называют логическим «И»:

print(20 >= 18 and 20 <= 21) 
# Вывод: True

Процесс вычисления такого выражения происходит поэтапно:

1. Вычисляется значение первого операнда: 20 >= 18 (Результат – True).
2. Вычисляется значение второго операнда: 20 <= 21 (Результат – True).
3. Вычисляется значение полученного выражения: True and True (Результат – True).

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

print(12 >= 18 and 12 <= 21) 
# Вывод: False

Здесь значение выражения 12 <= 21 даже не вычислялось, так выражение 12 >= 18 является ложным.

Дизъюнкция: логическое сложение

В отличии от конъюнкции результат дизъюнкции будет истинным, если истинно хотя бы одно из объединяемых выражений, поэтому её также называют логическим «ИЛИ»:

print(17 >= 18 or 27 <= 35) 
# Вывод: True

Такое выражение тоже вычисляется последовательно, пока не встретится первое истинное значение. После этого выражение возвращает True и дальнейшие вычисления не происходят.

Но если при вычислении значений всех выражений не было получено ни одного значения True, то будет возвращен False:

print(17 >= 18 or 17 <= 12) 
# Вывод: False

Примеры

Пример 1. Доступ к фильмам 16+ в онлайн-кинотеатре

В онлайн-кинотеатре для доступа к фильмам с возрастным рейтингом 16+ пользователь должен соответствовать определённым требованиям: он должен быть зарегистрирован и быть старше 16 лет:

# Данные пользователя
user_age = 20
is_registered = True
# Определяем наличие доступа к фильму
has_access = user_age >= 16 and is_registered
print(f"Имеет ли пользователь доступ к фильму? {has_access}")

Вывод:

Имеет ли пользователь доступ к фильму? True

Пример 2. Оценка состояния товара на складе

Программа складского учёта определяет состояние товара на складе, которое требует принятия мер. Такой товар может находится в недостатке (меньше 10), в избытке (больше 100), или же его вовсе нет в наличии:

# Количество товара на складе
product_stock = 5

# Проверяем, находится ли товар в недостатке
is_low_stock = product_stock < 10
print(f"Товара на складе: {product_stock} шт. Дефицит? {is_low_stock}")

# Проверяем, находится ли товар в избытке
is_overstocked = product_stock > 100
print(f"Избыток товара? {is_overstocked}")
 
# Проверяем, отсутствует ли товар на складе
is_out_of_stock = product_stock == 0
print(f"Товара нет в наличии? {is_out_of_stock}")

# Проверяем необходимость принятия мер
requires_attention = is_low_stock or is_overstocked or is_out_of_stock
print(f"Требует ли товар внимания (дефицит/избыток/отсутствие)? {requires_attention}")

Вывод:

Товара на складе: 5 шт. Дефицит? True
Избыток товара? False
Товара нет в наличии? False
Требует ли товар внимания (дефицит/избыток/отсутствие)? True

Пример 3. Проверка сложности задачи

Система оценивает сложность задачи на основе времени выполнения и задействованных ресурсов. Задача считается сложной, если на её выполнение требуется больше 10 часов или больше 5 единиц ресурсов. При этом задача не будет считаться сложной, если при любом затрачиваемом времени требуется всего 1 единица ресурсов:

# Ввод пользовательских данных
time_required = int(input("Оценочное время выполнения (часы): "))
resources_needed = int(input("Количество задействованных ресурсов (ед.): "))

# Определение сложности задачи
is_complex = (time_required > 10 or resources_needed > 5) and not re-sources_needed == 1
print("Задача сложная?", is_complex)

Вывод:

Оценочное время выполнения (часы): 15
Количество задействованных ресурсов (ед.): 1
Задача сложная? False

Итоги

• Логические выражения – это утверждения, которые могут быть оценены как истинные (True) или ложные (False).
• True и False – это единственные значения логического (булева) типа данных.
• Функция bool() возвращает логическое значение объекта. К истинным значениям относятся непустые объекты и ненулевые числа, а к ложным – пустые объекты, число 0 любого типа и объект None.
• Операторы сравнения (>, >=, <, <=, !=, ==) определяют отношение между двумя величинами. Числа сравниваются арифметически, а строки – лексикографически.
• Операторы идентичности (is и is not) проверяют ссылаются ли две переменные на один и тот же объект в памяти компьютера.
• Логические операторы выполняют логические операции над простыми выражениями, объединяя их в единое сложное выражение.
• Логическое отрицание (оператор not) изменяет логическое значение на противоположное.
• Логическое умножение или конъюнкция (оператор and) возвращает True, если оба объединяемых выражений истинны.
• Логическое сложение или дизъюнкция (оператор or) возвращает True, если хотя бы одно объединяемое выражение истинно.

Задания для самопроверки

1. Какие из следующих объектов являются истинными?

n = 20
reply = ""
message = "Сегодня выпало много снега"
is_admin = False
count = 0

2. Что будет выведено на экран в результате выполнения данного кода?

print(145 < -1)
print(89 != 19)
print("Сегодня солнечно" == "Сегодня солнечно")
print(91 >= -1)
print("Доступ разрешён" != "Доступ запрещён")

False
True
True
True
True

3. В каком порядке выполняются логические операции при отсутствии скобок?

4. Что будет выведено на экран в результате выполнения данного кода?

print(92 > 1 or "Кто ты" != "Кто я")
print(not(84 == 84))
print(23 > 1 and not(90) or 1 < -9)
print(10 != 23 or 1 > 2 and "Яблоко" == "Яблоко")
print(98 <= 100 and 12 != 98 and 78 > -1 and not(1 > 2))

True
False
False
True
True

5. Запросите у пользователя год рождения и выведите на экран True, если введённое значение лежит в пределах от 2000 до 2004 включительно, иначе – False.

age = int(input())
print(age >= 2000 and age <= 2004)