Введение в булеву логику в Python

Булева логика является важной частью математики, инженерии и программирования. В большинстве языков существует специальный булев тип данных. Когда вы новичок в Python, булевы значения могут сбить вас с толку из-за особенностей их работы в этом языке. Мы исследуем все тонкости булевой логики в Python.

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

Булевая логика является основой принятия решений в программировании. В своей сути, всё сводится к простому вопросу. Является ли что-то истинным или ложным?

Концепция возникает от математика Джорджа Буля, который в 19 веке разработал алгебраическую систему логики, использующую всего два значения: истина и ложь. В информатике этот бинарный способ мышления идеально подходит для цифрового мира. Это связано с тем, что компьютеры в конечном итоге работают с двумя состояниями: включено (1) и выключено (0).

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

В программировании логика Буля является тем, что позволяет компьютерам «принимать решения». Каждый раз, когда программе нужно что-то проверить, будь то проверка пароля, управление игровыми механиками или определение, прошла ли онлайн-платеж, она полагается на логическое мышление. Без него компьютеры просто обрабатывали бы данные вслепую. С ним они могут реагировать, ветвиться и адаптироваться к различным ситуациям.

Булевы значения в Python

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

True False 

Обратите внимание на заглавные буквы в обоих словах. Это важно, потому что написание true или false строчными буквами вызовет ошибку в Python, так как Python рассматривает их как неопределённые переменные. Оба True и False принадлежат к встроенному в Python типу данных bool:

print(type(True)) print(type(False)) 

Интересный факт в том, что bool является подтипом int. Это означает, что булевы значения ведут себя как числа 1 и 0 в определенных ситуациях:

print(True == 1) print(False == 0) print(True + True) print(False + 5) 

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

Python предоставляет функцию bool(), которая преобразует любое значение в логическое. Здесь приходит в игру концепция "истинных" и "ложных" значений. Ложные значения обрабатываются как False. К ним относятся

• 0
• 0.0
• (пустая строка)
• [] (пустой список)
• {} (пустой словарь)
• Ничего

Все остальное считается истинным (и оценивается как True.)

print(bool(0)) print(bool("")) print(bool([])) print(bool(42)) print(bool("hi")) print(bool([1, 2])) 

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

До сих пор мы видели, что в Python есть два логических значения: True и False. Но как мы на самом деле используем их на практике? Вот тут на помощь приходят логические операторы. Эти типы операторов позволяют нам сравнивать значения, проверять отношения и задавать вопросы с ответом «да» или «нет».

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

Операторы сравнения используются для сравнения двух значений. Результат сравнения всегда является логическим значением (True или False.) Вот полный список операторов сравнения в Python:

Давайте посмотрим на несколько примеров того, что они делают.

print(10 > 3) print(10 < 3) print(5 == 5) print(5 != 5) print(8 >= 8) print(2 <= 1) 

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

print("apple" == "apple") print("apple" != "banana") print("cat" < "dog") 

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

В то время как операторы сравнения проверяют, равны ли два значения, операторы идентичности проверяют, ссылаются ли две переменные на один и тот же объект в памяти. Python предоставляет два оператора идентичности:

is

is not

Быстрый пример:

a = [1, 2, 3] b = a c = [1, 2, 3] print(a == b) print(a is b) print(a is c) 

Здесь a и b не просто равны. Они буквально один и тот же список в памяти. С другой стороны, a и c могут иметь одинаковое содержимое, но это два отдельных объекта. Вот почему результат — False.

Операторы членства

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

in

not in

Давайте рассмотрим несколько примеров строковых типов.

print("a" in "apple") print("app" in "apple") print("z" not in "apple")

Здесь in проверяет как подстроки, так и отдельные символы. Что касается последовательностей:

numbers = [1, 2, 3, 4, 5] print(3 in numbers) print(10 in numbers) print(10 not in numbers)

Мы проверяем, существует ли определенный элемент в последовательности, в данном случае в списке Python.

Булева логика в условных операторах и циклах

Булевы значения — это не просто абстрактные значения. Во многих программах они контролируют поток кода и принятие решений. Каждый раз, когда вашей программе нужно выбрать путь или повторить действие, она полагается на булеву логику. Есть два основных места, где вы увидите это в действии:

1. Условные конструкции (если/иначе если/иначе)
2. Циклы (while и for)

Давайте исследовать каждый.

Условия

Условные операторы позволяют вашей программе реагировать по-разному в зависимости от того, истинно ли условие True или ложно False. Вот простой пример условной проверки:

age = 20 if age >= 18:    print("You are allowed to vote.")     

Python оценивает age >= 18. Если результат True, выполняется вложенный блок. Если это False, блок пропускается. Здесь, поскольку 20 >= 18 является True, сообщение выводится. Вот еще один пример, где мы выполняем другую кодовую инструкцию в случае False.

password = "password123" if password == "password123":     print("Access granted.") else:     print("Access denied.")     

Если условие True, выполняется первый блок. Если нет, выполняется блок else. Если есть более одного условия, то мы используем инструкции elif.

score = 85 if score >= 90:    print("Grade: A") elif score >= 80:    print("Grade: B") elif score >= 70:    print("Grade: C") else:    print("Grade: F")     

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

Циклы

Циклы используют булеву логику, чтобы определить, должны ли они продолжать выполнение. Это особенно полезно в циклах while.

count = 0 while count < 3:     print("Counting:", count)     count += 1     

Python проверяет count < 3. Если это True, тело цикла выполняется. После выполнения Python снова проверяет условие. Когда оно становится False, цикл останавливается. Вы также можете использовать логическое значение True, чтобы инициировать бесконечный цикл.

while True:    command = input("Type 'exit' to quit: ")    if command == "exit":        break     

Здесь условие True заставляет цикл выполняться бесконечно, но логика булевого выражения внутри цикла (command == "exit") позволяет нам выйти из него, когда это необходимо. Логика булевых выражений также играет свою роль в циклах for. Это может не быть очевидным, но она присутствует.

numbers = [1, 2, 3, 4, 5] for num in numbers:    if num % 2 == 0:        print(num, "is even")    else:        print(num, "is odd")     

В каждой итерации Python в сущности спрашивает, есть ли еще элемент в списке. Если да, присваивайте его переменной num и выполняйте тело цикла. Если нет, то остановите цикл. Этот скрытый вопрос «да/нет» – это действие булевой логики.

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

Общие ошибки, которых следует избегать

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

Смешение is с ==

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

Предполагая, что преобразование bool() интуитивно понятное

Функция bool() преобразует значения в True или False в зависимости от того, являются ли они истинными или ложными. Новички часто предполагают, что написание bool("False") вернет False. В Python любая непустая строка является истинной, независимо от того, что она говорит. Только "" (пустая строка) оценивается как False.

Забывая порядок операций

Булевы операторы не всегда оцениваются слева направо. Например:

a = 5 print(not a == 5)

На первый взгляд, это выглядит так, будто это означает not (a == 5) (что является False), но на самом деле это означает (not a) == 5. Поскольку not a становится False, вы сравниваете False == 5. Вот почему всегда следует использовать скобки при смешивании логических операторов и сравнений.

print(not (a == 5))

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