Что значит true и false

Boolean — Базовые типы данных в Python: Булев, или логический тип

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

Булев тип данный в Python 3

Булев концепт присутствует в каждом языке программирования. Булев тип данных реализует идею истины (true) или лжи (false). Во время составления программы часто всплывают моменты, когда в зависимости от ситуации требуется выполнить различные участки кода. Для этого нужен булев тип.

Есть вопросы по Python?

На нашем форуме вы можете задать любой вопрос и получить ответ от всего нашего сообщества!

4.9 – Логические (булевы) значения

В реальной жизни часто задаются вопросы, на которые можно ответить «да» или «нет». «Яблоко – это фрукт?». Да. «Тебе нравится спаржа?». Нет.

Теперь рассмотрим аналогичное утверждение, на которое можно ответить «верно/истина» (true) или «неверно/ложь» (false): «Яблоки – это фрукты». Совершенно очевидно, что это истина. Или как насчет «Я люблю спаржу». Абсолютно неверно (фу!).

Такие предложения, которые имеют только два возможных результата: да/истина или нет/ложь, настолько распространены, что многие языки программирования включают в себя специальный тип данных для работы с ними. Этот тип называется логическим (булевым, Boolean) типом (примечание: Boolean на английском правильно пишется с заглавной буквы, потому что этот тип назван в честь своего изобретателя Джорджа Буля).

Логические переменные

Логические переменные – это переменные, которые могут иметь только два возможных значения: true (истина) и false (ложь).

Чтобы объявить логическую переменную, мы используем ключевое слово bool .

Чтобы инициализировать или присвоить логической переменной значение истина или ложь, мы используем ключевые слова true и false .

Так же, как унарный оператор минус ( — ) может использоваться для превращения положительного числа в отрицательное, логический оператор НЕ ( ! ) Может использоваться для переключения логического значения с true на false или с false на true :

Логические значения на самом деле не хранятся в логических переменных в виде слов «true» или «false». Вместо этого они хранятся как целые числа: true становится целым числом 1, а false становится целым числом 0. Аналогично, когда вычисляются логические значения, они на самом деле не оцениваются как «true» или «false». Они оценивают целые числа 0 ( false ) или 1 ( true ). Поскольку логические значения фактически хранят целые числа, они считаются целочисленным типом.

Печать логических переменных

Когда с помощью std::cout мы печатаем логические значения, std::cout печатает 0 для false и 1 для true :

Вывод этой программы:

Если вы хотите, чтобы std::cout выводил « true » или « false » вместо 0 или 1, вы можете использовать std::boolalpha . Например:

Эта программа напечатает:

Чтобы отключить этот способ вывода, вы можете использовать std::noboolalpha .

Преобразование целочисленных значений в логические

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

(примечание: некоторые версии g++ не обеспечивают генерирование этой ошибки)

Однако в любом контексте, где целочисленное значение может быть преобразовано в логическое значение, целое число 0 преобразуется в false , а любое другое целое число преобразуется в true .

Эта программа напечатает:

Ввод логических значений

Ввод логических значений с помощью std::cin начинающих программистов иногда сбивает с толку.

Рассмотрим следующую программу:

Оказывается, std::cin принимает для логических переменных только два входных значения: 0 и 1 (а не true или false). Любые другие входные данные вызовут молчаливый сбой std::cin . В этом случае, поскольку мы ввели true , std::cin молча завершился ошибкой. Неудачный ввод также обнулит переменную, поэтому b также получит значение false . Следовательно, когда std::cout печатает значение b , он печатает 0.

Чтобы заставить std::cin принимать в качестве входных данных «false» и «true», необходимо включить параметр std::boolalpha .

Однако, когда включен std::boolalpha , «0» и «1» больше не будут обрабатываться как логические значения.

Логические возвращаемые значения

Логические значения часто используются в качестве возвращаемых значений для функций, которые проверяют, является ли что-то истинным или нет. Такие функции обычно называются, начиная со слова is (т.е. «является», например, isEqual ) или has (т.е. «имеет», например, hasCommonDivisor ).

Рассмотрим следующий пример, очень похожий на приведенный выше:

Ниже показан результат двух запусков этой программы:

Как это работает? Сначала мы читаем целочисленные значения для x и y . Затем вычисляется выражение isEqual(x, y) . При первом запуске это приводит к вызову функции isEqual(5, 5) . Внутри этой функции вычисляется 5 == 5 , возвращая значение true . Значение true возвращается вызывающей функции для печати с помощью std::cout . При втором запуске вызов isEqual(6, 4) возвращает значение false .

К логическим значениям нужно немного привыкнуть, но как только вы начнете думать о них, они сразу же покажут свою простоту! Логические значения также являются огромной частью языка – вы в конечном итоге будете использовать их чаще, чем все другие базовые типы вместе взятые!

[ Сборник задач ]
Тема 3. Логический тип
данных

В логическом (булевом) типе данных имеется 2 значения: True («правда») и False («ложь»). Детальное описание этого типа дано в стандарте PEP-285 .

Класс bool – это подкласс типа int (т.е. целых чисел). True и False – синглтон-объекты, которые по ходу выполнения программы никогда не меняют место расположения в памяти.

К логическим объектам можно применять математические операции. Есть 3 типа логических операторов: not («не»), or («или»), and («и»).

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

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

1. В чем разница между выражениями: True == 1 и True is 1? Какие результаты получим при их вычислении?

Когда мы пишем True == 1, то сравниваем значения. Так как класс bool является подклассом целых чисел, то True в данном случае будет той же самой единицей.
Когда задается выражение True is 1, то сравниваются адреса в памяти. Так как логические данные являются синглтон-объектами, то у них имеется собственный адрес в памяти, который не меняется по ходу работы скрипта. Поэтому число 1 и True – занимают разные области в памяти.

Решение – Интерактивный режим
>>> True == 1
True
>>> True is 1 # Сравниваются ячейки памяти
False
>>> id(True), id(1)
(2078150976, 2078275504) # Как видим – разные адреса в памяти

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

A and (B or C) == (A and B) or (A and C)
A or (B and C) == (A or B) and (A or C)

Примеры – Интерактивный режим
>>> True and (False or True) == (True and False) or (True and True)
True
>>> True or (False and True) == (True or False) and (True or True)
True

3. Если сравнивать 2 логических объекта оператором or, то какие значения могут быть получены в итоге? Проиллюстрируйте ответ.

При сравнении двух булевых значений оператором or можно получить 4 варианта ответов. Только в одном случае будет False.

Примеры – Интерактивный режим
>>> True or True
True
>>> False or True
True
>>> False or False
False
>>> True or False
True

4. Какие объекты в Python всегда возвращают булево значение False?

Если применить функцию bool() к большинству объектов в Python, то получим True. Все возможные исключения представлены ниже:

Пример – Интерактивный режим
>>> bool(False)
False

2. None

Пример – Интерактивный режим
>>> bool(None)
False

3. 0
Пример – Интерактивный режим
>>> bool(0)
False

4. Пустые последовательности (строки, списки, кортежи и т.д.)

Примеры – Интерактивный режим
>>> bool(»)
False
>>> bool([])
False
>>> bool(<>)
False

Также, можно принудительно внедрить метод __bool__() с возвращаемым значением False в любой класс.

5. Почему следует избегать выражений типа «a and not b or not c and d or e»? Как его модифицировать для удобочитаемости?

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

((a and not b) or (not c and d)) or e.

Приведем пример, доказывающий идентичность выражений.

Пример – Интерактивный режим
>>> 1 and not 2 or not 3 and 0 or 4
4
>>> ((1 and not 2) or (not 3 and 0)) or 4
4

6*. Поясните различие между выражениями: «a and b» и «bool(a) and bool(b)».

Выражение bool(a) and bool(b) всегда вернет булево значение (т.е. True или False).
Выражение a and b возвращает последнее истинное значение или первое ложное (остальные выражения даже не будут вычисляться в этом случае).

Примеры – Интерактивный режим
>>> bool(7) and bool(‘Программирование’)
True
>>> bool(7) and bool(»)
False
>>> 7 and []
[]
>>> 7 and 44
44
>>> 1 and []
[]
>>> None and 11
None

Булевы операции выполняются слева направо в таком приоритете:
– в первую очередь рассчитываются выражения с оператором not;
– далее вычисляют все конструкции, имеющие оператор and;
– в последнюю очередь работаем с or.

Приведем пример вычисления выражения a or b and not c:
2 or 3 and not 1.
Вначале узнаем результат операции not 1: False.
Далее сравниваем 3 и False: 3 and False = False.
Последний шаг: 2 or False = 2.

Пример – Интерактивный режим
>>> 2 or 3 and not 1
2

Изучающий язык Python студент постоянно путается в свойствах логических операций (ассоциативность, дистрибутивность, коммутативность, правило де Моргана). Он решил написать функцию-подсказку help_bool(letter), которая принимает одну из 4 букв: к, а, д, м (соответствующую каждому свойству).

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

Дано 2 скрипта. В первом – возникает ошибка, во втором – ошибки нет. Поясните почему.

Скрипт 1.
a = None
if len(a) > 0 and a is not None:
____print(‘OK’)

Скрипт 2.
a = None
if a is not None and len(a) > 0:
____print(‘OK’)

После изучения темы «Логический тип в Python» перед учеником стала задача написать функцию divider(a, b), принимающую любые 2 числовых параметра. Задача функции: разделить a на b. Если в знаменателе введут ноль, то результат будет следующим: «Нули в знаменателе не приветствуются». В противном случае выводится итог деления чисел, возведенный в куб.

Решите задание без использования условия if, применяя свойства логических операторов.

Задача 1. Базовый уровень

Задача 2. Базовый уровень

Охарактеризуем каждое правило:

– Коммутативность (к)
A or B = B or A
A and B = B and A

– Дистрибутивность (д)
A and (B or C) == (A and B) or (A and C)
A or (B and C) == (A or B) and (A or C)

– Ассоциативность (а)
A or (B or C) == (A or B) or C == A or B or C
A and (B and C) == (A and B) and C == A and B and C

– Теорема Де Моргана (м)
not (A or B) == not A and not B
not (A and B) == not A or not B
not (A < B) == A >= B
not (not (A)) = A

Если пользователь забудет нужный аргумент, то дадим ему подсказку:
Возможные аргументы: к – Коммутативность, д – Дистрибутивность, а – Ассоциативность, м – Теорема Де Моргана. Можем даже принудительно задать параметр по умолчанию, который без верного аргумента будет возвращать подсказку.

Логические выражения в 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 <= y:», x <= y)
print(«x >= y:», x >= y)
x == y: False
x != y: True
x < y: True
x > y: False
x <= y: True
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

Также для сравнения строк можно использовать операторы > и <. Python выполнит лексикографическое сравнение строк на основе значений символов ASCII.

Операторы сравнения можно применять к логическим значениям 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 <= 1)) # Выражение ложно (False)
True
True
True

В первом случае оба выражения истинны, потому оператор and возвращает True.

Во втором случае истинно только значение 8 == 8. Поскольку хотя бы одно из предложенных условий истинно, оператор or возвращает True. Оператор and в таком случае выдал бы False.

В третьем случае выражение 3 <= 1 ложно. Оператор not изменяет полученное логическое значение на противоположное: not False = True.

Теперь попробуйте сравнить числа с плавающей точкой.

print((-0.2 > 1.4) and (0.8 < 3.1)) # Одно из выражений ложно (False)
print((7.5 == 8.9) or (9.2 != 9.2)) # Оба выражения ложны (False)
print(not(-5.7 <= 0.3)) # Выражение истинно (True)

• Поскольку в первом примере одно из выражений ложно, and вернёт False. Оператор and оценивает выражение как истинное только тогда, когда оба компонента истинны.
• Поскольку оба выражения ложны, оператор or выдаст False.
• Поскольку выражение истинно, оператор not вернёт False (not True = False).

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

Логические операторы можно объединять в составные выражения:

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

Выражение (0.8 < 3.1) or (0.1 == 0.1) истинно, поскольку оба математических выражения, из которых оно состоит, истинны. Оператор or вернёт True.

Полученное значение 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.