Булева логика в Python, как и в других языках программирования нужна нам для того, чтобы наш код мог сравнивать данные.
Например сравнивать пароль, который вводит пользователь, с паролем, который храниться в базе данных. Или сравнивать ранг игроков в видеоигре, чтобы подбирать соперников по уровню.
Таких примеров сравнений много, и здесь булева логика – крайне полезная штука.
Давайте узнаем из чего она состоит и какие примеры с ней можно создавать.
Когда мы сравниваем числа друг с другом, мы обычно используем такие символы, как > (больше), < (меньше), = (равно) и так далее. Они работают и на Python. И вот как они выглядят там:
Больше >
Меньше <
Равно ==
Не равно !=
Больше или равно > =
Меньше или равно <=
Как Вы заметили, в Python вместо знака равенства = нам необходимо использовать двойной знак равенства ==.
Нам нужен двойной знак равенства для того, чтобы Python не подумал, что мы пытаемся создать переменную.
В Python эти символы называются операторами сравнения. И они нужны нам для того, чтобы наша программа могла сравнивать различные типы данных, например: числа, строки, переменные и так далее.
У Булевой логики есть логические значения: True и False:
True – когда условие истинно. И False – когда условие ложно.
Давайте теперь сыграем.
Я буду сравнивать числа, а Вы будете отвечать в уме – True, если это истина, или False, если это ложь.
Начнем?
2 > 4
10 < 20
3 == 3
5 != 7
А теперь давайте сделаем то же самое в Python. Для этого мы создадим переменную – результат, и присвоим ей значение 2 > 4
Затем выведем результат на экран с помощью функции print. Вот, как это будет выглядеть:
результат = 2 > 4
print(результат)
Впишите этот код в компилятор и запустите его.
Если значение переменной является истиной, программа вернет результат True. Если же значение окажется ложью, программа вернет False.
Ну как? Что возвращает программа?
А теперь подставьте остальные значения из списка, одно за другим, запускайте код и наблюдайте за результатом, который возвращает программа.
Вот так и работает булева логика в Python.
Но что, если мы попробуем сравнить строки? Попробуйте сравнить яблоки с апельсинами, используя следующее значение в переменной:
результат = "яблоки" == "апельсины"
print(результат)
Запишите этот код в компилятор и запустите его.
А теперь сравните яблоки с яблоками:
результат = "яблоки" == "яблоки"
print(результат)
Видите результат?
Теперь Вы знаете, что в программировании булева логика работает не только с числовыми, но и с другими форматами данных.
Как Вы уже заметили, мы можем хранить результаты сравнений, которые возвращают True или False в переменных.
Давайте рассмотрим эту тему подробнее вот с таким примером:
результат = "яблоки" == "бананы"
print(результат)
Давайте впишем этот код в компилятор и запустим его.
В этом коде мы создали переменную с именем “результат”, и присвоили ей логическое значение от сравнения двух строк «яблоки» и «бананы».
Затем мы спустились на одну строку вниз, и вывели значение переменной “результат” на экран, передав имя переменной в скобки функции print. Которую мы перед этим создали.
Правда, не сложно?
А теперь измените код, указав, что яблоки и бананы не равны. Вы уже знаете как это делать :)
Что теперь возвращает программа?
Мы можем сравнивать не только числа и строки, но и целые переменные!
Посмотрите, как это можно сделать:
игра = "Dota"
результат = игра == "FIFA"
print(результат)
Но, прежде чем записать это пример в компилятор и запустить его, подумайте и скажите, какой результат он вернет? True или False?
Решили? А теперь давайте посмотрим правильно Вы решили, или нет:
Как видите, сначала мы создали переменную под названием игра и присвоили ей значение сроки “Dota”.
Затем мы спустились на одну строку ниже, и создали вторую переменную по имени результат.
После этого мы присвоили переменной результат логическое значение от сравнения нашей первой переменной – игра, со строковым значением FIFA.
Затем мы спустились еще на одну строку ниже, и вывели значение переменной результат на экран, с помощью функции print.
А так как значение нашей переменной игра равно строке Dota, а не строке FIFA, то программа вернула False.
Ну как? Совпало Ваше решение с ответом программы?
Давайте теперь закрепим пройденный пример. Возьмите наш код, и напишите на его основе свою версию программы для создания и сравнения двух переменных.
Меняйте что угодно по вашему желанию: имена переменных, их значения. И конечно операторы сравнения.
Ну и в завершение пройденной главы, давайте отработаем очень упрощенный пример из реальной жизни: Программа, которая проверяет правильность введенного пароля:
пароль = "рыба-меч"
приветствие = пароль == "рыба-меч"
print(приветствие)
Введите этот код в компилятор и запустите его.
Давайте рассмотрим все по порядку.
В первой строчке мы создали переменную – пароль, и присвоили ей значение – рыба-меч.
Затем на второй строчке мы создали новую переменную по имени приветствие. И присвоили ей логическое значение, которое сравнивает значение переменной пароль и строку “рыба-меч”.
И, наконец, в третьей строчке мы вывели на экран результат логического сравнения из второй строчки.
Поскольку в качестве оператора сравнения мы использовали == (Равно), а значение переменной пароль действительно равно строке “рыба-меч”, то, переменная приветствие вернула True.
Таким образом, можно представить, что:
“рыба-меч” из первой строчки – это пароль, который хранится в базе паролей.
“рыба-меч” из второй строчки – это пароль, который вводит пользователь, чтобы войти в личный кабинет.
приветствие = пароль == из второй строчки – это код, который сверяет пароль от пользователя с паролем из базы.
А print(приветствие) из третьей строчки – это всего лишь функция, которая выводит результат сверки на экран. True, если пароли совпадают, или False, если пароли не совпадают.
Теперь измените “рыба-меч” из первой или второй строчки на любое другое слово или словосочетание, и перезапустите программу. Программа должна вернуть False, так как пароли больше не совпадают.
Этот пример является упрощенным представлением того, как программисты используют булеву логику и операторы сравнения в Python для задач, связанных с авторизацией пользователей в приложениях.
В пятой главе Вы сделали следующее:
1. Узнали, что такое булева логика в Python;
2. Научились применять операторы сравнения;
3. Познакомились с логическими значениями True и False;
4. Научились использовать логические значения в переменных;
5. Узнали, как программисты используют булеву логику для авторизации пользователей.
Поздравляю! У Вас отличный прогресс! А теперь давайте применим булеву логику в более сложных примерах.
Это мы сделаем в следующей главе – Условные заявления в Python.
Вопрос 1: Этот код хранит результаты сравнения двух строк, «яблоки» и «апельсины», в переменной по имени результат, а затем выводит значение переменной на экран. Но код перепутался. Расположите фрагменты кода в правильном порядке.
1. Результат
2. "апельсины"
3. (результат)
4. =
5. "яблоки"
6. print
7. !=
Вопрос 2: Этот код сравнивает две переменные. Какой результат вернет код, когда мы запустим программу?
машина = "Tesla"
результат = машина == "Toyota"
print (результат)
Вопрос 3: У булевой логики есть логические значения. Их всего два. Подставьте правильные определения для каждого из двух значений.
Когда условие оказывается правдой
Когда условие оказывается неправдой
True
False