[МУЗЫКА] [МУЗЫКА]

Теперь перейдем к использованию логических выражений на практике.

Начнем с проверки числа на четность.

Мы считываем некоторое число и хотим получить истину,

если оно четное, и ложь в противном случае.

И напечатать это сразу.

Назовем переменную isEven, является ли число четным,

и запишем туда результат вычисления логического выражения.

Как проверить число на четность,

да и вообще на делимость на какое-то другое число?

Нужно посчитать остаток от деления этого числа на то,

что мы хотим разделить — в нашем случае на 2, и сравнить его с 0.

То есть число — четное, если остаток от деления на 2 равен 0.

И напечатаем нашу логическую переменную.

Посмотрим, как это будет выглядеть.

Запускаем.

Пусть у нас число 10 — четное.

Оно печатает нам true — истина.

То есть если мы пытаемся напечатать результат вычисления логического

выражения, то у нас печатается строка true в случае,

если оно истинно, и false, если оно ложно.

Девять оказалось нечетным числом.

Так мы можем использовать присваивание в логических выражениях.

Теперь посмотрим более сложную задачу.

Пусть у нас есть два отрезка.

Например, это отрезки времени, годы — с какого года по какой,

происходило какое-то событие.

И перед нами стоит задача понять, пересекаются ли эти события, то есть, есть

ли хоть один такой год, во время которого происходило и первое событие, и второе.

Что нам понадобится?

Нам понадобится четыре переменных.

Это время начала и время конца для каждого из двух событий.

[БЕЗ_ЗВУКА] Начало первого события.

Конец первого события.

Пусть у нас они задаются в таком порядке.

Сначала полностью первое событие описывается, а затем полностью второе.

Чтобы не набирать эти слова два раза, я копирую и меняю цифры.

Отлично, данные мы считали.

И что делать дальше?

Нужно каким-то образом научиться проверять, пересекаются ли два отрезка,

расположенные вдоль прямой.

В какой ситуации у нас они пересекаются?

Для этого достаточно, чтобы или начало,

или конец одного из отрезков находились внутри другого.

Причем неважно, какого именно, в каком, потому что ситуаций очень много.

Один отрезок полностью вложен, они пересекаются,

пересекаются в другом порядке или не пересекаются одним или другим образом.

Так что такой критерий — проверить,

находится ли конец или начало одного из отрезков в другом для каждой пары,

то есть первого во втором и второго в первом, и если хотя бы один из

таких концов находится внутри другого — значит, отрезки пересекаются.

Давайте называть переменные осмысленно

и пытаться из всего этого собрать какую-то конструкцию, которая будет понятна.

Например, мы можем сделать такую

штуку: начало первого отрезка isS1,

is — это является ли оно S1 — это

старт первого in 2 — вот такой смысл имеет это страшное

название: начала первого отрезка во втором.

Ну теперь, когда у нас есть такое название,

условие записать достаточно просто.

Что для этого нужно сделать?

Для этого нужно, чтобы начало второго отрезка было меньше, либо равно,

чем начало первого отрезка и, в свою очередь, это начало первого отрезка должно

находиться до конца второго, тогда начало первого отрезка лежит внутри второго.

Вот так выглядит это выражение.

Как уже говорилось, в Python можно использовать несколько сравнений в одном

выражении, они будут все проверяться последовательно.

Теперь давайте распишем то же самое для конца первого отрезка.

Оно очень похоже, отличие небольшое.

Нам нужно, чтобы конец теперь,

вместо начала первого отрезка, находился внутри второго.

Смотрите, я увидел ошибку, а мог не заметить.

Отлично, ошибка исправлена, но

если она осталась бы, то в какой-то момент у нас программа работала бы неправильно.

Нам пришлось бы думать, как ее отловить и исправить.

Хорошо, теперь для первого отрезка мы проверили принадлежность его

концов второму, и нужно сделать обратную операцию — проверить для второго отрезка.

Может быть, какой-то из его концов лежит внутри первого?

Вот у нас уже четыре страшных строки сейчас.

Мы приведем их в порядок.

Все переменные будем поддерживать в состоянии, что имена их осмысленны.

И это нам поможет в итоге что-то написать работающее.

Итак, когда у нас отрезки пересекаются,

когда хотя бы один из концов лежит внутри другого, то есть хотя бы

одна из этих четырех переменных является истиной.

Проверяем.

Может быть, начало первого лежит во втором,

или конец первого лежит во втором?

Или начало второго лежит в первом,

или конец второго лежит в первом?

Вот такое страшное выражение получилось.

Давайте его и напечатаем.

Посмотрим.

Конечно, случаев очень много,

и если мы сейчас будем всё проверять, то это затянется надолго.

Тем не менее, вам нужно это делать, когда вы сдаете задачи, проверять,

или хотя бы если вы поленились проверить и получили неправильный ответ

при попытке отправить решение, то искать тесты,

перебирать разные варианты и проверять, правильно ли работает ваша программа.

Давайте возьмем какой-нибудь простой вариант.

Опять я ввел неправильно данные.

Но мы уже знаем, что с этим делать — вводить правильно.

Итак, отрезки с 1 по 3 и с 2 по 4 — они должны пересекаться.

Да. Теперь какие-нибудь отрезки,

которые не пересекаются.

Например, с 1 по 10 и с 20 по 30 не пересекаются.

Ну и проверим один какой-нибудь случай, например,

один отрезок лежит внутри другого — первый внутри второго.

Числа могут быть и отрицательные.

Ничего страшного.

Значит, сейчас у нас первый отрезок полностью находится внутри

второго отрезка, и ответ должен быть true.

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

конечно, старались называть переменные осмысленно, все равно читать это тяжело.

И многие задачи становятся намного проще, если немного подумать.

И в этой задаче, на самом деле, достаточно проверить гораздо более простое условие,

а именно, начало первого отрезка должно быть меньше либо равно,

чем конец второго, и одновременно с этим,

начало второго должно быть меньше либо равно, чем конец первого.

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

Если эти условия оба одновременно выполнены,

то у нас отрезки будут пересекаться.

Давайте всё, что было написано, удалим.

Жалко, конечно, пять строк такого сложного кода.

Но на самом деле всё намного проще.

Начало первого отрезка меньше либо равно, чем конец второго.

И одновременно с этим начало второго отрезка меньше

либо равно, чем конец первого.

Здесь мы используем End — логическую связку i.

Ну и давайте те же примерно случаи, как у нас были, проверим.

Итак, 1, 3, 2, 4.

Действительно, пересеклись.

Теперь не пересекающиеся отрезки — не пересеклись.

И, наконец, случаи вложенности одного отрезка в другой.

Опять наша программа работает правильно.

Таким образом, иногда, чтобы упростить решение задачи,

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

какое-нибудь условие, которое будет достаточно коротким и простым.

Тем не менее, не обязательно это делать и иногда имеет смысл аккуратно,

очень аккуратно всё расписать, и тогда код будет намного надежнее.

Может быть, вы где-то допустили какую-то ошибку в своих рассуждениях,

но если вы всё напишете вот ровно, как просят, и не будете ничего придумывать,

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

описок и так далее.

Поэтому здесь нужно смотреть по обстоятельствам.

Если вы имеете большой опыт и уже сдаете задачи успешно,

можете придумать какие-то простые красивые условия,

то, конечно, можно экономить свое время и не писать громоздкий код.

Если же ваш опыт пока не очень большой,

то гораздо правильней описать все случаи аккуратно, и этот код будет надежней.

Ну и соответственно, если вы будете, например, запускать спутник к Луне, то,

конечно, нужно писать надежный код.

Сейчас мы посмотрим некоторые новые конструкции, которые здорово

облегчат нам жизнь и которых вам наверняка не хватало в прошлых занятиях.

[МУЗЫКА]

Примеры использования логических выражений

Основы программирования на Python

Meet the Instructors