Что такое условная инструкция в питоне

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

• условный оператор if,
• конструкция if-else,
• конструкция if-elif-else,
• примеры программ.

Проще всего это понять на примере. Введите в интерпретаторе Python следующее и нажмите Enter для вывода:

>>> if 5 > 4:
print('Верно, 5 больше, чем 4.')
Верно, 5 больше, чем 4.

Перед нами простейший пример работы программы по условию. Если переводить с Python (а это почти чистый английский — настолько порой понятен его код), мы написали буквально следующее: «Если 5 больше 4, напечатать: Верно, 5 больше, чем 4».

Таким образом, if служит для выполнения блока кода по условию: если условие истинно (то есть Python рассматривает его как True), код блока будет исполнен, а если ложно (False), то нет. Давайте приведем и пример False, введите и нажмите Enter:

if 5 < 4:
print('Верно, 4 больше 5')

Интерпретатор молчит — и правильно делает, потому что условие ложно, а значит запись Верно, 4 больше 5 (сама по себе тоже ошибочная) никогда не будет выведена.

Но в большинстве случаев одного условия нам будет не хватать и придется использовать более сложные конструкции: if-else и if-elif-else.

Условная конструкция if-else

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

money = int(input('Какую сумму вы бы хотели потратить на покупки у нас? Введите цифру: '))
if money >= 100:
    print('Добро пожаловать! Отправили каталог на вашу электронную почту.')
else:
    print('К сожалению, у нас нет товаров дешевле 100 рублей. Заходите еще.')
input('Нажмите Enter для выхода.')

Первая строка нужна для ввода, за который отвечает инструкция input. Если в двух словах, то функция input состоит в приеме пользовательского ввода и, при необходимости, в передаче введенного значения в переменную (в данном случае в качестве переменной выступает money).

А далее в дело вступает условная конструкция: если введенная сумма равна или больше ста рублей, программа дает положительный ответ. Если же введенная сумма 99 рублей или меньше, выдается другой ответ.

В последней строчке мы также добавили оператор input, который в данном случае не передает никакого значения в переменную, а нужен для перевода на следующую строку кода. А поскольку этой строки у нас нет, по нажатию Enter выполняется выход из программы: это еще одна особенность input.

Условная конструкция if-elif-else

Давайте усложним предыдущий пример и заставим программу выбирать из трех вариантов. Сделать это можно, добавив дополнительное условие, которое будет задано оператором elif:

money = int(input('Какую сумму вы бы хотели потратить на покупки у нас? Введите цифру: '))
if money >= 10000:
    print('Рады приветствовать оптового покупателя! Для вас у нас есть специальные скидки.')
elif money >= 100:
    print('Добро пожаловать! Отправили каталог на вашу электронную почту.')
else:
    print('К сожалению, у нас нет товаров дешевле 100 рублей. Заходите еще.')
input('Нажмите Enter для выхода.')

Теперь, если пользователь введет сумму равную или больше указанного значения (10000), программа выдаст текст из первого блока с if. А если сумма будет меньше этого значения, но равна или больше 100, будет выполнено условие оператора elif, и пользователь увидит второй текст.

Чтобы вам было удобнее читать код с условиями, операторы удобно переводить так: if — «если», elif — «а если», else — «в ином случае».

Добавим, что elif может быть сколь угодно много, главное правило: в первом условии обязательно должен быть указан оператор if. Вот пример кода с несколькими elif. Представим, что мы хотим сгенерировать стартовую звездную систему для нашей цивилизации в космической стратегии:

import random
star = random.randint(1, 5)
planets = random.randint(1, 10)
if star == 1:
    print('Ваша цивилизация живет в системе голубого гиганта, вокруг которого вращаются', planets, 'планет')
elif star == 2:
    print('Ваша цивилизация живет в системе белого карлика, вокруг которого вращаются', planets, 'планет')
elif star == 3:
    print('Ваша цивилизация живет в системе солнцеподобного желтого карлика, вокруг которого вращаются', planets, 'планет')
elif star == 4:
    print('Ваша цивилизация живет в системе оранжевого гиганта, вокруг которого вращаются', planets, 'планет')
else:
    print('Ваша цивилизация живет в системе красного сверхгиганта, вокруг которого вращаются', planets, 'планет')
input('Нажмите Enter для выхода')

Вот какую систему подарил рандом нам:

Ваша цивилизация живет в системе солнцеподобного желтого карлика, вокруг которого вращаются 6 планет
Нажмите Enter для выхода

Почти солнечная, только планет поменьше. Обратите внимание, что мы создали две переменные (star и planets), генерацию значений для которых доверили модулю random, который сначала нужно вызвать:

import random

Далее при помощи инструкции random.randint мы задали диапазон генерируемых значений, из которого генератор случайных чисел (далее — ГСЧ) выбирает одно: для звезд из 5 и для планет из 10:

star = random.randint(1, 5)
planets = random.randint(1, 10)

Поскольку типов звезд у нас пять, блоков кода с условиями должно быть столько же, поэтому нам и пригодились несколько операторов elif. А вот количество планет будет произвольным для любого куска кода, потому что переменная planets включена во все.

И еще один момент: вы уже заметили, что в коде одни операции обозначаются знаком =, а другие знаком двойного равенства: ==. В Python один знак «равно» (=) используется только для присвоения значений переменным, а вот двойное равенство равно арифметическому. Поэтому в примере выше код:

star = random.randint(1, 5)

означает, что переменная star принимает случайное значение, сгенерированное модулем random, а выражение:

if star == 1:

означает, что переменная star с уже присвоенным значением сравнивается со значением 1 (и в случае истинности этого условия, начинает выполняться код этого блока).

Игровые примеры для закрепления

Лучше всего учиться играя, поэтому давайте продемонстрируем, как работает условный оператор if else в Python, на примере простейших игр, а заодно познакомимся с другими полезными функциями.

Подбрасываем монетку

Напишем такую программу с использованием условной конструкции if-elif-else и шаг за шагом рассмотрим, как эта программа устроена. Итак, наберите в редакторе, не забывая про отступы:

import random
coin = random.randint(1, 2)
attempts = 0
orel = 0
reshka = 0
while attempts < 100:
    if coin == 1:
        orel += 1
        attempts += 1
        coin = random.randint(1, 2)
    elif coin == 2:
        reshka += 1
        attempts += 1
        coin = random.randint(1, 2)
    else:
        print('Монетка упала ребром. Неужели такое бывает? Хорошо, перебрасываем.')
        attempts += 1
        coin = random.randint(1, 2)
print('Орёл выпал', orel, 'раз(-а), а решка', reshka, 'раз(-а).')
input('Нажмите Enter для выхода')

Броски монетки мы будем имитировать при помощи уже знакомого нам ГСЧ, за который отвечает модуль random. Его мы и вызываем в первой строчке кода:

import random

Далее вводим несколько переменных:

• coin — для бросков монетки,
• attempts — для подсчета количества бросков,
• orel — будет добавлять число выпавших «орлов»,
• reshka — будет добавлять число выпавших «решек».

При подбрасывании монетки мы будем сразу же использовать ГСЧ, поэтому пишем:

coin = random.randint(1, 2)

Это значит, что значение будет генерироваться случайным образом в пределах от 1 до 2, то есть может выпасть либо единица, либо двойка. Теперь осталось присвоить эти значения орлам и решкам соответственно, указать максимальное количество бросков и сделать так, чтобы при каждом броске их число увеличивалось на один. Для этого используем условную конструкцию if-elif-else внутри цикла while:

while attempts < 100:

Эта часть кода означает: до тех пор пока бросков меньше 100:

 if coin == 1:
        orel += 1
        attempts += 1
        coin = random.randint(1, 2)

если ГСЧ выдал 1:

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

elif coin == 2:
        reshka += 1
        attempts += 1
        coin = random.randint(1, 2)

То же самое, но с решкой.

 else:
        print('Монетка упала ребром. Неужели такое бывает? Хорошо, перебрасываем.')
        attempts += 1
        coin = random.randint(1, 2)

Код, добавленный на случай невозможного (ребром монетка никогда не упадет, поскольку наш ГСЧ может выдать только 1 или 2). В данном случае эта часть кода не обязательна, но заведите себе привычку добавлять последний блок с else — «невозможные» условия порой всё же могут выполняться, поскольку программисты не всегда могут учесть все сценарии работы программы. И поэтому блок с else в таких случаях сделает программу более стабильной в случае выполнения неучтенного условия.

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

print('Орёл выпал', orel, 'раз(-а), а решка', reshka, 'раз(-а).')
input('Нажмите Enter для выхода')

Программа выйдет из цикла while и выдаст, сколько раз выпал орел, а сколько решка: изучаем статистику и выходим. По сути, пользователю будет виден только результат примерно в таком виде:

Орёл выпал 53 раз(-а), а решка 47 раз(-а).
Нажмите Enter для выхода

Конечно, понаблюдать за работой ГСЧ интересно, но всё же играми в полной мере что генератор звезд и планет, что броски монетки назвать сложно, поэтому напишем программу поинтереснее.

Играем с компьютером в кости

В этой игре будем по очереди бросать кубики с компьютером, а в конце объявим победителя. Это делает следующий код:

import random
score1 = 0
score2 = 0
games = 0
die1 = 0
die2 = 0
total1 = 0
die3 = 0
die4 = 0
total2 = 0
input('Бросай кости, жми Enter!\n')
while score1 < 6 and score2 < 6 and games <= 11:
    die1 = random.randint(1, 6)
    die2 = random.randint(1, 6)
    total1 = die1 + die2
    print(die1, die2)
    print(total1,'\n')
    input('Теперь я, жми Enter!\n')
    die3 = random.randint(1, 6)
    die4 = random.randint(1, 6)
    total2 = die3 + die4
    print(die3, die4)
    print(total2,'\n')
    if total1 > total2:
        score1 += 1
        games += 1
    elif total1 < total2:
        score2 += 1
        games += 1
    else:
        games += 1
        print('Ничья\n')
    print('Счёт', score1, ':', score2,'\n')
    input('Жми Enter!\n')
if score1 > score2:
    input('Ты победил! Жми Enter для выхода')
elif score1 < score2:
    input('Я победил! Жми Enter для выхода')
else:
    input('Победила дружба! Жми Enter для выхода')

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

Сначала вызываем уже знакомый модуль random, затем задаем следующие переменные, которые перед началом игры будут, разумеется, равны 0:

• score1 и score2 для подсчета побед, наших и компьютера;
• games для количества партий (их мы затем ограничим, чтобы предотвратить долгую игру в случае частых ничьих);
• die1, die2, die3, die4 для бросков отдельных костей;
• total1 и total2 для подсчета суммы очков в каждом броске двух игроков: для игрока-человека это будет сумма total1 костей die1, die2, а для компьютера — total2 и die3, die4 соответственно.

Далее идет призыв к началу игры (игрок первым увидит именно это), а затем программа входит в цикл:

while score1 < 6 and score2 < 6 and games < 11:

Как видим, условий несколько, и они соединены операторами and. Это значит, что программа выйдет из цикла, если одно из них перестанет быть истинным (то есть либо score1 или score2 станет равным 6, либо games будет равно 11). Играем почти теннисный сет: как только один из игроков выигрывает шесть партий, игра заканчивается его победой. При этом количество партий не может быть больше 11. Таким образом, если из-за ряда ничьих в партиях ни один из игроков не одержит 6 побед, игра всё равно закончится после 11-й партии.

Теперь бросает кости игрок, а программа считает их сумму (total1 = die1 + die2) и печатает результат. После по нажатию Enter то же самое делает компьютер (у него сумма будет total2 = die3 + die4). Конечно, на самом деле вся игра выполняется целиком и полностью силами ГСЧ, но так уж устроено большинство простых игр: даже за игрока здесь всё решает рандом. А мы переходим к самой важной части программы: двум блокам if-elif-else. Первый из них является частью цикла while:

if total1 > total2:
    score1 += 1
    games += 1
elif total1 < total2:
    score2 += 1
    games += 1
else:
    games += 1
    print('Ничья\n')
print('Счёт', score1, ':', score2,'\n')
input('Жми Enter!\n')

Тут тоже всё просто: если наша сумма больше, мы получаем очко, если в партии выиграл компьютер, очко начисляется ему, а при ничьей — никому, но партия засчитывается как сыгранная в любом случае. Далее на экран выводится текущий счет и предлагается играть дальше. Как только выполняется условие цикла while, то есть один из игроков одержал 6 побед или количество сыгранных партий достигло 11, программа выходит из цикла и переходит к последнему блоку:

if score1 > score2:
    input('Ты победил! Жми Enter для выхода')
elif score1 < score2:
    input('Я победил! Жми Enter для выхода')
else:
    input('Победила дружба! Жми Enter для выхода')

Первое условие с if выполняется, когда игрок выиграл больше партий, чем компьютер. Условие с elif — если удачливее был компьютерный оппонент. Но что если партий было сыграно 11 и при этом игроки выиграли равное число? Для этого мы и добавили блок с else, выполнение которого выдаст на экран примирительный текст.

Осталось добавить, что Python проверяет условия последовательно и исполняет первое, которое является истинным: то есть сначала всегда будет проверено условие с if, затем с elif (если их несколько, то одно за другим сверху вниз) и последним с else. Таким образом, если в сложной программе вдруг оказались выполнены сразу несколько условий, будет исполнен только тот блок, который стоит первым: учитывайте это при написании кода.

Условия (if, else, elif) и операторы сравнения

Содержание

1. Ввод данных и преобразование типов
2. Почему нужно конвертировать строки в числа
3. Условия
4. Операторы сравнения
5. Вложенные условные инструкции
6. Тип данных bool
7. Логические операторы
8. Конструкция elif
9. Задачи
   1. Знак числа
   2. Високосный год
10. Ссылки по теме
11. Домашнее задание

Ввод данных и преобразования типов

На прошлом занятии мы научились выводить данные с помощью функции print(). Например, чтобы вывести число 5 на экран нужно написать в интерпретаторе print(5), и он сделает свое дело.

Но что, если нужно что-то ввести в программу из внешнего мира? Например, если наш самописный калькулятор умеет складывать 2 числа и выводить ответ, то как ввести эти самые 2 числа? На помощь придет функция input(). Попробуем написать вышеописанный калькулятор.

Функции input() можно передать в качестве аргумента строку, которую увидит пользователь перед вводом.

>>> a = input('Введите число a: ')
Введите число a: 56
>>> b = input('Введите число b: ')
Введите число b: 23
>>> print(a + b)
5623

Как видно из примера, что-то пошло не так. Вместо заветных 46 после сложения 12 и 34 мы получили 1234. Все дело в типах данных. Функция input() всегда считывает данные в виде строки. Так и в примере она считала 12 и 34 как 2 строки и просто «слепила» их вместе. Мы же хотим складывать числа. Чтобы все работало хорошо, нужно выполнить преобразование типов данных.

В данном случае можно сделать вот так:

>>> a = int(input('Введите число a: '))
Введите число a: 56
>>> b = (input('Введите число b: '))
Введите число b: 23
>>> print(a + b)
79

То, чего мы и хотели.

Преобразовывать можно не только строку в целое число, но и наоборот. Вот несколько допустимых преобразований:

>>> # Преобразование числа в строку
>>> a = 34
>>> b = str(a)
>>> print('Преобразованное число:', b, ', его тип:', type(b))
Преобразованное число: 34 , его тип: <class 'str'>

>>> # Преобразование строки в число с плавающей точкой
>>> a = '45.34'
>>> b = float(a)
>>> print(a, type(a))
45.34 <class 'str'>
>>> print(b, type(b))
45.34 <class 'float'>
>>> b**2
2055.7156000000004

>>> # Преобразовать строку с НЕ числом в число не получится
>>> a = 'python'
>>> b = int(a)
Traceback (most recent call last):
  File "<pyshell#22>", line 1, in <module>
    b = int(a)
ValueError: invalid literal for int() with base 10: 'python'

В примерах мы используем функцию type(). Как должно быть понятно из её названия, она выясняет тип переменной. Возвращает она что-то
страшное вида <class 'str'>. Сейчас не стоит вникать почему так. Нам
важно, что преобразование прошло правильно и получился тип str.

Как вы уже поняли, чтобы преобразовать что-то во что-то, надо взять и вызвать функцию, совпадающую по имени с названием типа данных. В нашем примере это str(), int() и float().

Почему нужно конвертировать строки в числа

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

>>> a = input('Введите целое число:')
Введите целое число:12
>>> b = input('Введите целое число:')
Введите целое число:45
>>> if a > b:
...     print('Большее число:', a)
... else:
...     print('Большее число:', b)
Большее число: 45

Вы удовлетворитесь ответом и пойдете домой. Но потом выяснится, что если ввести другие 2 числа, то все сломается:

>>> a = input('Введите целое число:')
Введите целое число:4
>>> b = input('Введите целое число:')
Введите целое число:30
>>> if a > b:
...     print('Большее число:', a)
... else:
...     print('Большее число:', b)
Большее число: 4

Значит, не все так просто…

Чтобы разобраться в вопросе, нужно знать как сравниваются строки.

Компьютер умеет работать только с одним типом данных — числами. Мы же помимо чисел используем кучу разных типов данных: числа, строки, списки, словари, кортежи (последние 3 будут обсуждаться дальше в курсе). Оказывается, что и они все хранятся и обрабатываются компьютером в виде чисел. Разберемся со строчками.

Когда люди задумались, как можно обрабатывать строки, им прошла в голову простая идея — а давайте создадим единую таблицу, в которой каждому символу поставим в соответствие число.
Так появилась таблица ASCII (American standard code for information interchange).

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

• Windows-1251
• КОИ-8
• ISO-8859
• Юникод
• и множество других…

Python версии 3 использует Unicode — кодировку, которая на данный момент включает в себя знаки почти всех письменных языков мира. Emoji в ней, кстати, тоже есть 😀😃😇👩‍💻🐁

При сравнении строк, Python переводит все символы строки в числа и производит сравнение чисел.

Если перевести “числовые” строки из примеров выше в списки чисел, то получится:

• '12' = [49, 50]
• '45' = [52, 53]
• '4' = [52]
• '30' = [51, 48]

Когда мы пишем '12' < '45', то Python сравнивает числа обоих строк по очереди: 49 < 52 — True, значит строка '12' меньше, чем строка '45'.

Когда же мы пишем '4' < '30', то Python снова сравнивает числа обоих строк по очереди, но на этот раз получается иначе: 52 < 51 — False и ответ получается '4' > '30', что абсолютно верно с точки зрения сравнения строк, но абсолютный бред с точки зрения сравнения чисел.

Python сравнивает числа по очереди. Если он уже на первом числе может ответить на вопрос “кто больше”, он прекращает сравнение и выдает ответ. Если же строки имеют одинаковую первую букву, то сравниваться они будут по второй и так далее. Такое сравнение называется лексикографическим

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

Условия

Все рассматриваемые нами ранее программы имели линейную структуру — программа просто выполняла инструкции одну за другой сверху вниз. При этом никаких способов повлиять на ход выполнения у нас не было (разве что только на уровне выводимых на экран параметров).
Также важно то, что наши предыдущие программы обязаны были выполнить все инструкции сверху вниз, в противном случае они бы завершались ошибкой.

Теперь предположим, что мы хотим определить абсолютное значение любого числа. Наша программа должна будет напечатать сам x в случае, если он неотрицателен и -x в противном случае. Линейной структурой программы здесь не обойтись*, поэтому нам на помощь приходит инструкция if (если). Вот как это работает в питоне:

>>> # Ввод данных с преобразованием типа
>>> x = int(input())
>>>
>>> if x > 0:
...     print(x)
>>> else:
...     print(-x)

На самом деле в python есть функция abs(), с помощью
которой можно взять модуль числа. Но в качестве примера
использования конструкции if и так хорошо.

Разберем этот кусочек кода. После слова if указывается проверяемое условие (x > 0), завершающееся двоеточием (это важно). После этого идет блок (последовательность) инструкций, который будет выполнен, если условие истинно. В нашем примере это вывод на экран величины x. Затем идет слово else (иначе), также завершающееся двоеточием (и это важно), и блок инструкций, который будет выполнен, если проверяемое условие неверно. В данном случае будет выведено значение -x.

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

Небольшая ремарка относительно табуляции.
Мы используем 4 пробела!
В современных текстовых редакторах при нажатии на tab автоматически
вставляется 4 пробела. Не надо жать 4 раза кнопку space как вот
тут. Никакой войны,
никаких табов. Просто 4 пробела.

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

Таким образом, условные конструкции в питоне имеют следующий общий вид:

if Условие:
    блок инструкций, в случае если условие истинно
else:
    блок инструкций, в случае если условие не выполняется

Вторая часть условной конструкции (та, что с else) может и отсутствовать, например так:

>>> x = int(input())
>>>
>>> if x < 0:
...     x = -x
...
>>> print(x)

Эта программа тоже выведет абсолютное значение x, как и та, что была ранее.

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

Все операторы сравнения в питоне достаточно интуитивны. Вот список основных:

> — больше. Условие истинно, если то, что слева от знака больше того, что справа.
< — меньше. Условие истинно, если то, что слева от знака меньше того, что справа.
>= — больше либо равно.
<= — меньше либо равно.
== — в точности равно.
!= — не равно.

Вложенные условные инструкции

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

>>> a = int(input())
>>> b = int(input())
>>>
>>> if a > 0:
...     if b > 0:
...         print("a, b > 0")
...     else:
...         print("a > 0, b < 0")
... else:
...     if b > 0:
...         print("a, b < 0")
...     else:
...         print("a < 0, b > 0")
...

Главное, не забывать отступы и двоеточия.

Тип данных bool

Операторы сравнения возвращают значения специального логического типа bool. Значения логического типа могут принимать одно из двух значений: True (истина) или False (ложь).

Если преобразовать логическое True к типу int, то получится 1, а преобразование False даст 0. При обратном преобразовании число 0 преобразуется в False, а любое ненулевое число в True. При преобразовании str в bool пустая строка преобразовывается в False, а любая непустая строка в True.

Рассмотрим несколько примеров:

>>> # Сравнение строки
>>> name = input('Введите своё имя:')
>>> if name != '':
>>> 	print('Привет,', name)
>>> else:
>>> 	print('Вы не ввели своё имя!')

>>> # Преобразование bool к int
>>> print(int(True))
1
>>> print(int(False))
0

Обратите внимание, ключевые слова True или False пишутся с
большой буквы. Если написать их с маленькой, то python подумает, что это переменная, попытается её найти и сломается, когда не найдет
:(. А если вы вздумаете называть свои переменные false или true, то сдать зачет
по курсу вам не светит :). Учитесь сразу хорошему стилю программирования.

>>> # Преобразование bool к int
>>> print(int(true))
Traceback (most recent call last):
  File "<pyshell#32>", line 1, in <module>
    print(int(true))
NameError: name 'true' is not defined

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

Если мы хотим проверить два или более условий за раз, мы можем воспользоваться операторами and, or или not. Вот как они работают:

and (логическое И) возвращает истину (True) только в случае если оба условия по отдельности верны (тоже возвращают True)
or (логическое ИЛИ) вернет истину в случае, если хотя бы одно из условий верно.
not (логическое НЕТ) возьмет результат условия и “обратит” его. То есть, если результат условия True, то not примененный к этому условию вернет False и наоборот.

Давайте посмотрим как это работает на примере. Код ниже проверяет, что хотя бы одно число из двух нацело делится на 10 (кончается на 0) и если так, то печатает YES, а если нет, то печатает NO:

>>> a = int(input())
>>> b = int(input())
>>>
>>> if a % 10 == 0 or b % 10 == 0:
...     print('YES')
... else:
...     print('NO')
...

Пусть теперь мы хотим проверить, что числа a и b должны быть еще и обязательно больше нуля:

>>> a = int(input())
>>> b = int(input())
>>>
>>> if (a % 10 == 0 and a > 0) or (b % 10 == 0 and b > 0):
...     print('YES')
... else:
...     print('NO')
...

Как видите, мы можем не только использовать and и or в одном if, но и группировать условия скобками для того, чтобы явно обозначить приоритет вычисления условий.

Посмотрим пример с not. Пусть мы хотим проверить, что число a — положительное, а число b — неотрицательное.
Это можно проверить вот таким условием:

>>> if a > 0 and not (b < 0):
...     pass
...

Оператор pass очень полезен, когда нужно ничего не делать. Если его
не поставить, то будет синтаксическая ошибка. А так, код считается правильным!

Кстати, not (b < 0) можно было бы и заменить на b >= 0 и код бы работал точно так же.

Конструкция elif

Иногда писать конструкции if-else долго и утомительно, особенно если приходится проверять много условий разом. В этом случае на помощь придет elif (сокращение от else if). По сути elif позволяет существенно упростить конструкцию ниже:

>>> if a > 0:
...     pass
... else:
...     if b > 0:
...         pass
...

И сделать ее вот такой:

>>> if a > 0:
...     pass
... elif b > 0:
...     pass
...

Обратите внимание, мы избавились от одного уровня вложенности. То есть, сам код стал более читаемым, но при этом нисколько не проиграл в функциональности. Разумеется, конструкции типа if-elif могут завершиться и блоком else, например так:

>>> if a > 0:
...     pass
... elif b > 0:
...     pass
... elif c > 0:
...     pass
... else:
...     pass
...

Задача: знак числа

В математике есть функция sgn, показывающая знак числа. Она определяется так: если число больше 0, то функция возвращает 1. Если число меньше нуля, то функция возвращает -1. Если число равно 0, то функция возвращает 0. Реализуйте данную функцию — для введенного числа выведите число, определяющее его знак. Используйте операторы сравнения и конструкцию if-elif-else.

Возможное решение:

>>> x = int(input())
>>>
>>> if x > 0:
...     print(1)
... elif x < 0:
...     print(-1)
... else:
...     print(0)
...

Задача: високосный год

Дано натуральное число. Требуется определить, является ли год с данным номером високосным. Если год является високосным, то выведите YES, иначе выведите NO. Напомним, что в соответствии с григорианским календарем, год является високосным, если его номер кратен 4, но не кратен 100, а также если он кратен 400.

Возможное решение:

>>> year = int(input())
>>> if (year % 4 == 0 and year % 100 != 0) or (year % 400 == 0):
...     print('YES')
... else:
...     print('NO')
...

Ссылки по теме

• http://pythontutor.ru/lessons/ifelse/
• http://pythonicway.com/python-conditionals

Домашнее задание

Вам надо написать на питоне 6 программ, каждая из которых будет спрашивать у пользователя
3 числа (a, b, c) и печатать на экран удовлетворяют ли введенные числа перечисленным свойствам:

1. a и b в сумме дают c
2. a умножить на b равно c
3. a даёт остаток c при делении на b
4. c является решением линейного уравнения ax + b = 0
5. a разделить на b равно c
6. a в степени b равно c

Оформите каждую программу в виде отдельного файла с расширением .py.

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

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

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

Условные конструкции и оператор if в языке Python

Условные конструкции – это основной инструмент программиста для реализации алгоритмов, в которых поведение программы зависит от того, какие данные она обрабатывает. Оператор if – это ключевой элемент условных конструкций в языке программирования Python.

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

if выражение:
блок кода



  


                       
  

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

Оператор if можно также дополнить операторами else и elif. Оператор else позволяет выполнить блок кода в том случае, если выражение оператора if ложно. Конструкция if-else выглядит следующим образом:

if выражение:
блок кода1
else:
блок кода2

Оператор elif – это сокращение от «else if». Конструкция elif позволяет проверять следующее условие, если предыдущее было ложным. Такая конструкция может быть повторена несколько раз. Конструкция if-elif-else выглядит следующим образом:

if выражение1:
блок кода1
elif выражение2:
блок кода2
else:



  


                       
  




блок кода3

Оператор if в языке Python можно также использовать для проверки наличия определенного элемента в списке или словаре, для проверки соответствия строк заданному шаблону и многое другое. Кроме того, оператор if можно использовать вместе с другими операторами, такими как and, or, not, для составления сложных логических выражений.

Синтаксис оператора if

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

Затем следует блок кода, который будет выполнен, если логическое выражение истинно. Этот блок кода должен быть с отступом относительно ключевого слова if.

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

Для выполнения проверки нескольких условий в Python используется конструкция if-elif-else. Синтаксис такой же, как и для обычного оператора if, только вместо else используется ключевое слово elif, которое также должно содержать логическое условие:

Это позволяет задавать проверку сразу для нескольких условий и выполнять соответствующий блок кода, если одно из них истинно.

Простейший пример if

Условный оператор if в Python используется для выполнения определенных действий в зависимости от истинности выражения.

Рассмотрим простейший пример:

1. Зададим переменную x со значением 5.
2. Напишем условие: если x равно 5, выведем на экран фразу «x равно 5».
3. Завершим блок условия.

В данном примере, так как значение переменной x равно 5, условие сработало и на экран была выведена соответствующая фраза.

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

Условный оператор if может быть использован для выполнения более сложных действий в программе в зависимости от различных условий.

Использование логических операторов в условиях

Оператор if позволяет создавать условия в программах на языке Python. Но что делать, если необходимо проверить несколько условий одновременно? В этом случае приходят на помощь логические операторы.

В Python есть три логических оператора:

• and – возвращает True, если оба условия истинны
• or – возвращает True, если хотя бы одно условие истинно
• not – инвертирует значение – True превращает в False, а False – в True

Пример использования оператора and:

age = 25
income = 50000
if age > 18 and income > 40000:
print("Вы можете взять кредит")

В этом коде мы проверяем два условия – возраст больше 18 лет и доход больше 40000. Если оба условия истинны, будет выведено сообщение о возможности взять кредит.

Пример использования оператора or:

color = "green"
if color == "red" or color == "blue":
print("Цвет красный или синий")



  


                       
  

Здесь мы проверяем, равен ли переменной color красный или синий цвет. Если условие хотя бы одного из значений истинно, в консоли будет выведено сообщение о соответствии цвета.

Пример использования оператора not:

door = "closed"
if not door == "open":
print("Дверь закрыта")

В этом примере мы проверяем, закрыта ли дверь, но мы добавляем оператор not, что инвертирует значение. Таким образом, если дверь закрыта, будет выведено сообщение о её закрытости.

Вложенность и else

Оператор if в Python может быть вложенным в другой оператор if. Это позволяет проверять более сложные условия и принимать решения на основе нескольких проверок.

Вложенный if может содержать свой оператор else, который будет выполнен только в случае, если условие вложенного if ложно. Также может быть использован else для первого if, если нужно выполнить какое-то действие в случае, если все условия ложны.

Рассмотрим пример:

age = 25

if age > 18:

    print(«Вы совершеннолетний»)

    if age > 25:

        print(«Вы уже давно совершеннолетний»)

    else:

        print(«Вы еще молоды»)

else:

    print(«Вы несовершеннолетний»)

В данном примере вложенный if проверяет условие age > 25 и выводит сообщение в зависимости от результата. Если условие ложно, то выводится сообщение «Вы еще молоды». Если бы вложенный if не содержал оператор else, то в этом случае бы ничего не вывелось.

Также в примере используется else для первого if, чтобы вывести сообщение «Вы несовершеннолетний», если все условия ложны.

Оператор if в комбинации с else и elif

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

Однако, зачастую в программировании возникает необходимость выполнять определенные действия в зависимости от разных условий. Для этого в Python используются комбинации оператора if с else и elif.

Конструкция оператора if с else позволяет выполнять один блок кода, если условие истинное, и другой блок, если условие ложное. При этом используется следующий синтаксис:

if <условие>:

<блок кода, если условие ложное>

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

Конструкция оператора if с elif позволяет выполнить условный блок кода из нескольких блоков в зависимости от разных условий. При этом используется следующий синтаксис:

if <условие1>:

<блок кода, если все условия ложные>

В такой конструкции сначала проверяется условие1, если оно истинно, то будет выполнен соответствующий блок кода. Если условие1 ложно, то проверяется условие2 и так далее, пока не будет выполнен соответствующий блок кода или пока не закончатся условия. Если все условия ложные, то будет выполнен блок кода в блоке else.

Комбинация оператора if с else и elif позволяет создавать гибкие условные конструкции в Python и выполнить нужный блок кода в зависимости от разных условий.

Примеры комбинации if-else

Оператор if может быть использован в сочетании с оператором else для проверки двух условий: одно, если условие if верно, и другое, если условие if неверно.

Вот пример, использующий условие if-else:

1. Пример 1:

   x = 10
   if x > 5:
   print("x больше 5")
   else:
   print("x меньше или равно 5")
   

   В этом примере x равно 10. Условие if проверяет, что x больше 5, и выводит соответствующее сообщение. Если условие if неверно, выводится сообщение из блока else.

2. Пример 2:

   x = 7
   if x < 5:
   print("x меньше 5")
   elif x < 10:
   print("x меньше 10")
   else:
   print("x больше или равно 10")
   

   В этом примере x равно 7. Условие if проверяет, что x меньше 5, но это неверно, поэтому проверка переходит к блоку elif. Условие elif проверяет, что x меньше 10, и выводит соответствующее сообщение. Если оба условия if и elif неверны, проверка переходит к блоку else, который выводит сообщение.

3. Пример 3:

   age = 28
   legal_age = 18
   if age < legal_age:
   print("Вы не можете голосовать.")
   else:
   print("Вы можете голосовать.")
   

   В этом примере age равно 28, а legal_age равно 18. Условие if проверяет, что age меньше legal_age, что неверно. Поэтому проверка переходит к блоку else, который выводит сообщение.

Вы можете использовать несколько блоков elif для проверки разных условий. Если все условия оказываются неверными, выполняется блок else.

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

Примеры цепочки elif

Цепочка elif используется в операторе if для проверки нескольких условий, если предыдущие условия оказались ложными. Ниже приведены примеры цепочки elif.

x = 7
if x > 10:
print("x больше 10")
elif x > 5:
print("x больше 5, но меньше 10")
else:
print("x меньше или равен 5")

x = "банан"
if x == "яблоко":
print("фрукт - яблоко")
elif x == "банан":
print("фрукт - банан")
elif x == "апельсин":
print("фрукт - апельсин")
else:
print("это не фрукт")

Цепочка elif может иметь сколько угодно блоков, но стоит помнить, что чем больше блоков, тем сложнее понимать логику кода.

Краткая запись if-else

В языке Python есть возможность записать конструкцию if-else в более краткой форме, используя тернарный оператор. Тернарный оператор состоит из трех элементов: условия, значения, возвращаемого при выполнении условия, и значения, возвращаемого в противном случае. Такая запись удобна в случаях, когда необходимо быстро проверить какое-то условие и выполнить соответствующую операцию.

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

(значение_если_истина) if (условие) else (значение_если_ложь)

Рассмотрим пример кода:

x = 5
value = 10 if x > 3 else 0
print(value)  # результат: 10

В данном примере мы сначала задаем значение переменной x равным 5. Затем мы записываем значение переменной value, используя тернарный оператор. Условие в данном случае звучит так: «если x больше 3». Если условие истинно, то значение переменной value будет равным 10. Если же условие ложно, то значение переменной value будет равным 0.

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

Условный оператор в современном Python

Условный оператор if является одним из фундаментальных элементов языка программирования Python. Он позволяет выбирать, какой блок кода выполнить, основываясь на условии, которое определяется после ключевого слова if.

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

Конструкция if-else является самой простой из всех возможных вариантов. Она позволяет задать условие, которое проверяется при выполнении блока кода. Если оно истинно, то выполняется код, записанный после ключевого слова if, а если оно ложно, то выполнение переходит к блоку else.

Конструкция if-elif-else позволяет задать более сложные условия. Она позволяет проверять несколько различных условий, и выполнять различные действия в зависимости от их истинности. В этом случае, блок кода после первого истинного условия будет выполнен, остальные блоки кода будут проигнорированы.

Условный оператор if очень важен для программирования на Python, т.к. позволяет выполнять различные действия при изменении условий выполнения блока кода. Вместе с оператором if можно использовать множество функций и методов, что делает его бесценным инструментом для работы с данными и разработки комплексных приложений.

Пример использования условного выражения

Условное выражение позволяет программе принимать решения в зависимости от того, выполняется ли условие, описанное в выражении или нет. Рассмотрим пример использования оператора if в языке Python:

x = 20
if x > 10:
print("x больше 10")
else:
print("x меньше 10 или равен ему")

В данном примере переменная x получает значение 20, затем в условном выражении проверяется, больше ли оно 10. Если да, то программа выводит сообщение «x больше 10», если нет, то выводится другое сообщение «x меньше 10 или равен ему».

Кроме оператора if, в Python также есть операторы elif и else, которые позволяют задавать несколько условий:

x = 20
if x > 30:
print("x больше 30")
elif x > 10:
print("x больше 10, но меньше 30")
else:
print("x меньше или равен 10")

В данном примере, если x больше 30, то выводится сообщение «x больше 30». Если x больше 10, но меньше 30, то выводится сообщение «x больше 10, но меньше 30». Если x меньше или равен 10, то выводится сообщение «x меньше или равен 10».

Также можно использовать условное выражение для задания значений переменных:

x = 10
y = 20 if x > 5 else 30
print(y)

В данном примере, если x больше 5, то переменной y присваивается значение 20, иначе – 30. В результате выводится значение переменной y, которая в данном случае равна 20.

Множественные условия с условным выражением

В языке Python условный оператор if может также использоваться для множественной проверки условий. Для этого используется конструкция elif (сокращение от else if).

Синтаксис выглядит следующим образом:

if уcлoвиe_1:

блок_n+1

Выполнение программы начнется с проверки условия_1. Если оно истинно, будет выполнен блок_1 и программа выйдет из конструкции if. Если условие_1 ложно, то программа перейдет к проверке условия_2. Если условие_2 истинно, будет выполнен блок_2 и программа выйдет из конструкции if. Если условие_2 ложно, то программа перейдет к проверке условия_3 и т.д. Если все условия ложны, будет выполнен блок_n+1.

Пример использования множественной проверки условий:

number = int(input("Введите число: "))

print("Вы ввели ноль")

В этом примере программа проверяет введенное число и выводит соответствующее сообщение в зависимости от значения числа.

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

Ограничения использования условного выражения

Условное выражение – это мощный инструмент в языке программирования Python, но его использование имеет некоторые ограничения. Рассмотрим некоторые из них:

1. Ограничение на тип данных: условное выражение в Python может содержать только данные логического типа: True или False. Это означает, что если вы попытаетесь выполнить условие с другим типом данных, Python вызовет ошибку.
2. Ограничение на число вложенных условий: использование условных выражений может привести к множеству вложенных условий (if-else), которые могут быть сложными для чтения и отладки. Кроме того, слишком много вложенных условий может снизить производительность вашей программы.
3. Ограничение на использование комплексных условий: условное выражение может содержать только одно условие. Комплексные условия (состоящие из нескольких условий, объединенных с помощью логических операторов) не могут быть использованы в запрещенном для них контексте.

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

Our life is full of conditions even if we don’t notice them most of the time. Let’s look at a few examples:

• If tomorrow it doesn’t rain, I’ll go out with my friends in the park. Otherwise, I’ll stay home with a cup of hot tea and watch TV.
• If tomorrow it isn’t too hot, I’ll go to the sea, but if it is, I’ll have a walk in the forest. However, if it rains, I’ll stay home.

You get the idea. Let’s see how conditions work in computers. You may already know that programs in Python are executed line by line. However, sometimes, we need to skip some code and execute only some of it only if certain conditions are met. This is where control structures become useful. Conditional statements in Python are built on these control structures. They will guide the computer in the execution of a program.

In this tutorial, you’ll learn how to use conditional statements. This guide is for beginners in Python, but you’ll need to know some basics of coding in Python. If you don’t, then check this free Python Fundamentals course.

Basic if Statement

In Python, if statements are a starting point to implement a condition. Let’s look at the simplest example:

if <condition>:
    <expression>

When <condition> is evaluated by Python, it’ll become either True or False (Booleans). Thus, if the condition is True (i.e, it is met), the <expression> will be executed, but if <condition> is False (i.e., it is not met), the <expression> won’t be executed.

We are pretty free to decide what conditions and expressions can be because Python is very flexible.

Let’s look at a concrete example.

# Basic if statement
x = 3
y = 10

if x < y:
    print("x is smaller than y.")

x is smaller than y.

First of all, we define two variables, x and y. Then we say that if variable x is smaller than variable y, print out x is smaller than y). Indeed, if we execute this code, we’ll print out this output because 3 is smaller than 10.

Output: x is smaller than y.

Let’s look at a more complex example.

# A slightly more complex example
x = 3
y = 10
z = None

if x < y:
    z = 13
print(f"Variable z is now {z}.")

Variable z is now 13.

In this case, if the condition is met, then a value of 13 will be assigned to the variable z. Then Variable z is now 13. will be printed out (note that the print statement can be used both outside and inside the if statement).

As you can see, we aren’t restrained in the choice of an expression to execute. You can now practice more by writing more complex code.

Let’s know see what happens if we execute the following code:

# What happens here?
x = 3
y = 10

if x > y:
    print("x is greater than y.")

Here we changed the direction of the comparison symbol (it was less than, and now it’s greater than). Can you guess the output?

There will be no output! This happened because the condition hadn’t been met. 3 is not greater than 10, so the condition evaluated to False, and the expression wasn’t executed. How do we solve this problem? With the else statement.

else Statement

What if we want to execute some code if the condition isn’t met? We add an else statement below the if statement. Let’s look at an example.

# else statement
x = 3
y = 10

if x > y:
    print("x is greater than y.")
else:
    print("x is smaller than y.")

x is smaller than y.

Output: x is smaller than y.

Here, Python first executes the if condition and checks if it’s True. Since 3 is not greater than 10, the condition isn’t met, so we don’t print out “x is greater than y.” Then we say that in all other cases we should execute the code under the else statement: x is smaller than y.

Let’s get back to our first example of a conditional statement:

If tomorrow it doesn’t rain, I’ll go out with my friends in the park. Otherwise, I’ll stay home with a cup of hot tea and watch TV.

Here the else statement is “Otherwise.”

What happens if the condition is met?

# What if the condition is met?
x = 3
y = 10

if x < y:
    print("x is smaller than y.")
else:
    print("x is greater than y.")

x is smaller than y.

In this case, Python just prints out the first sentence as before.

Output: x is smaller than y.

What if x is equal to y?

# x is equal to y
x = 3
y = 3

if x < y:
    print("x is smaller than y.")
else:
    print("x is greater than y.")

x is greater than y.

The output is clearly wrong because 3 is equal to 3! We have another condition outside the greater or less than comparison symbols; thus, we have to use the elif statement.

elif Statement

Let’s rewrite the above example and add an elif statement.

# x is equal to y with elif statement
x = 3
y = 3

if x < y:
    print("x is smaller than y.")
elif x == y:
    print("x is equal to y.")
else:
    print("x is greater than y.")

x is equal to y.

Output: x is equal to y.

Python first checks if the condition x < y is met. It isn’t, so it goes on to the second condition, which in Python, we write as elif, which is short for else if. If the first condition isn’t met, check the second condition, and if it’s met, execute the expression. Else, do something else. The output is “x is equal to y.”

Let’s now get back to one of our first examples of conditional statements:

If tomorrow it isn’t too hot, I’ll go to the sea, but if it is, I’ll have a walk in the forest. However, if it rains, I’ll stay home.

Here, our first condition is that tomorrow it’s not too hot (if statement). If this condition isn’t met, then we go for a walk in the forest (elif statement). Finally, if neither condition is met, we’ll stay home (else statement).

Now let’s translate this sentence into Python.

In this example, we’re going to use strings instead of integers to demonstrate the flexibility of the if condition in Python.

# elif condition
tomorrow = "warm"

if tomorrow == "warm":
    print("I'll go to the sea.")
elif tomorrow == "very hot":
    print("I'll go to the forest.")
else:
    print("I'll stay home.")

I'll go to the sea.

Python first checks if the variable tomorrow is equal to “warm” and if it is, then it prints out I'll go to the sea. and stops the execution. What happens if the first condition isn’t met?

# Tomorrow is very hot
tomorrow = "very hot"

if tomorrow == "warm":
    print("I'll go to the sea.")
elif tomorrow == "very hot":
    print("I'll go to the forest.")
else:
    print("I'll stay home.")

I'll go to the forest.

In this case, Python evaluates the first condition to False and goes to the second condition. This condition is True, so it prints out I'll go to the forest. and stops the execution.

If neither of the two conditions is met, then it’ll print out I’ll stay home.

Of course, you can use whatever number of elif statements you want. Let’s add more conditions and also change what is printed out under the else statement to Weather not recognized. (for example, if tomorrow is “f”, we don’t know what it means).

# Several elif conditions
tomorrow = "snowy"

if tomorrow == "warm":
    print("I'll go to the sea.")
elif tomorrow == "very hot":
    print("I'll go to the forest.")
elif tomorrow == "snowy":
    print("I'll build a snowman.")
elif tomorrow == "rainy":
    print("I'll stay home.")
else:
    print("Weather not recognized.")

I'll build a snowman.

Guess what’s printed out?

Multiple Conditions

Let’s now add some complexity. What if we want to meet multiple conditions in one if statement?

Let’s say we want to predict a biome (i.e., desert or tropical forest) based on two climate measurements: temperature and humidity. For example, if it’s hot and dry, then it’s a hot desert, but if it’s cold and dry, then it’s an arctic desert. You can see that we cannot classify these two biomes based only on their humidity (they are both dry) so we also have to add the temperature measure.

In Python, we can use logical operators (i.e., and, or) to use multiple conditions in the same if statement.

Look at the code below.

# Biome prediction with and logical operator
humidity = "low"
temperature = "high"

if humidity == "low" and temperature == "high":
    print("It's a hot desert.")
elif humidity == "low" and temperature == "low":
    print("It's an arctic desert.")
elif humidity == "high" and temperature == "high":
    print("It's a tropical forest.")
else:
    print("I don't know!")

It's a hot desert.

The output will be It's a hot desert. because only when humidity is low and temperature is high, the combined condition is True. It’s not sufficient to have only one of the conditions to be True.

Formally, Python checks if the first condition of humidity is True (indeed, it is), then it checks if the second condition of temperature is True (and it is) and only in this case the combined condition is True. If at least one of these conditions isn’t met, then the combined condition evaluates to False.

What if we want either of two (or more) conditions is met? In this case we should use the or logical operator.

Let’s look at an example. Say you have a list of numbers from 1 to 14 (inclusive), and you want to extract all the numbers that are smaller than 3 or greater or equal to 10. You can achieve the result using an or operator!

# or logical operator
nums = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
nums_less_3_greater_equal_10 = []

for num in nums:
    if num < 3 or num >= 10:
        nums_less_3_greater_equal_10.append(num)

print(nums_less_3_greater_equal_10)

[1, 2, 10, 11, 12, 13, 14]

Output: [1, 2, 10, 11, 12, 13, 14]

Here Python checks whether the current number in the for loop is less than 3, and if it’s True, then the combined if statement evaluates to True. The same happens if the current number is equal to or greater than 10. If the combined if statement is True, then the expression is executed and the current number is appended to the list nums_less_3_greater_equal_10.

For the sake of experiment, let’s change or to and.

# Change or to and
nums = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
nums_less_3_greater_equal_10 = []

for num in nums:
    if num < 3 and num >= 10:
        nums_less_3_greater_equal_10.append(num)

print(nums_less_3_greater_equal_10)

[]

Output: []

In this case, the current number should be simultaneously smaller than 3 and greater or equal to 10, which is clearly not possible so the combined if statement evaluates to False and the expression isn’t executed.

To make things even more clear, look at this print statement.

print(False or True)

True

Output: True

Here Python evaluates the combination of False and True, and since we have the or logical operator, it’s sufficient that at least one of these Booleans is True to evaluate the combined statement to True.

Now, what happens if we change or to and?

print(False and True)

False

Output: False

Both Booleans should be True to evaluate the combined condition to True. Since one of them is False, the combined condition is also False. This is what happens in the example with numbers.

You can even combine multiple logical operators in one expression. Let’s use the same list of numbers, but now, we want to find all the numbers that are either smaller than 3 or greater or equal to 10 and simultaneously are even numbers.

We will be using the


# More complex logical statements
nums = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
nums_less_3_greater_equal_10_multiple_2 = []

for num in nums:
    if (num < 3 or num >= 10) and num 
        nums_less_3_greater_equal_10_multiple_2.append(num)

print(nums_less_3_greater_equal_10_multiple_2)

[2, 10, 12, 14]

# More complex logical statements without parentheses
nums = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
nums_less_3_greater_equal_10_multiple_2 = []

for num in nums:
    if num < 3 or num >= 10 and num 
        nums_less_3_greater_equal_10_multiple_2.append(num)

print(nums_less_3_greater_equal_10_multiple_2)

[1, 2, 10, 12, 14]

# Nested if statements
mark =  85

if mark >= 60 and mark <= 100:
    if mark >= 90:
        print("You are the best!")
    elif mark >= 80:
        print("Well done!")
    elif mark >= 70:
        print("You can do better.")
    else:
        print("Pass.")
elif mark > 100:
    print("This mark is too high.")
elif mark < 0:
    print("This mark is too low.")
else:
    print("Failed.")

Well done!

# Previous example
tomorrow = "snowy"

if tomorrow == "warm":
    print("I'll go to the sea.")
elif tomorrow == "very hot":
    print("I'll go to the forest.")
elif tomorrow == "snowy":
    print("I'll build a snowman.")
elif tomorrow == "rainy":
    print("I'll stay home.")
else:
    print("Weather not recognized.")

I'll build a snowman.

# Pattern matching with match..case syntax
tomorrow = "snowy"

match tomorrow:
    case "warm":
        print("I'll go to the sea.")
    case "very hot":
        print("I'll go to the forest.")
    case "snowy":
        print("I'll build a snowman.")
    case "rainy":
         print("I'll stay home.")
    case _:
        print("Weather not recognized.")

I'll build a snowman.

# Without pass
num = 3
if num == 3:

print("I'll write this code later.")

  Input In [24]
    print("I'll write this code later.")
    ^
IndentationError: expected an indented block after 'if' statement on line 3

File "", line 4
    print("I'll write this code later.")
    ^
IndentationError: expected an indented block

# With pass
num = 3
if num == 3:
    pass

print("I'll write this code later.")

I'll write this code later.

# With pass
num = 4
if num == 3:
    pass
elif num == 4:
    print("The variable num is 4.")
else:
    print("The variable num is neither 3 nor 4.")

The variable num is 4.

Условные конструкции в Python позволяют программе принимать решения на основе заданных условий.

Например, если у нас есть программа, которая должна проверять, является ли число четным или нечетным, мы можем использовать условную конструкцию для проверки этого условия. Если число четное, программа может выводить сообщение «Число четное», а если число нечетное, программа может выводить сообщение «Число нечетное».

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

• Проверка, входит ли пользовательское значение в определенный диапазон значений.
• Выбор правильной формы слова в зависимости от его рода (например, «яблоко» или «яблоки»).
• Проверка наличия правильных данных в форме входа.
• Определение, кто является победителем в игре на основе результатов игры.

Оператор if

Синтаксис if

Оператор if в Python позволяет проверить, выполняется ли заданное условие, и выполнить определенные действия, если условие истинно.

Синтаксис простого оператора if выглядит следующим образом:

if условие:
    блок кода

Где:

• условие — это выражение, которое должно быть оценено как истинное или ложное.
• блок кода — это блок инструкций, который будет выполнен, если условие истинно. Блок кода должен быть с отступом в 4 пробела (или 1 табуляция).

Например, давайте посмотрим на простой пример. Мы хотим проверить, является ли число x положительным, и если это так, мы хотим вывести сообщение «Число положительное». Если число отрицательное или равно нулю, мы не будем выводить никакого сообщения.

x = 5

if x > 0:
    print("Число положительное")

В этом примере, условие x > 0 оценивается как истинное, поэтому блок кода после оператора if будет выполнен, и выведется сообщение «Число положительное».

Если бы значение переменной x было отрицательным или равным нулю, блок кода не был бы выполнен, и никаких сообщений не было бы выведено.

Вложенные инструкции и отступы

Обратите внимание, что в примере выше, инструкция print("Число положительное") смещена вправо относительно инструкции if. Это сделано специально, для того, чтобы показать Python, что вывод сообщения «Число положительное», будет сделан только, если выполнится условие x > 0

В этом случае говорят, что инструкция print("Число положительное") является вложенной для инструкции if.

То есть, она подчинена ей, и будет выполнена только в случае выполнения условия.

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

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

if условие1:
    if условие2:
        инструкция1
        инструкция2
    else:
        инструкция3
else:
    инструкция4

Здесь мы имеем вложенные инструкции: инструкция1 и инструкция2 находятся внутри блока кода, который связан с условие2, и этот блок кода находится внутри блока кода, который связан с условие1.

Важно понимать, что в Python для обозначения вложенных блоков кода используется отступ (4 пробела или 1 табуляция).

Отступы очень важны в Python, и неправильное их использование может привести к ошибкам в вашем коде!

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

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

Тип данных bool, значение True и False

Тип данных bool в Python представляет логические значения True (истина) и False (ложь). Он используется для представления результатов логических операций и условий.

Например, при выполнении операции сравнения 2 > 1 мы получим логическое значение True, а при выполнении операции сравнения 2 < 1 — логическое значение False.

Тип данных bool может быть преобразован из других типов данных. В Python любое значение может быть преобразовано в логическое значение bool. Логическое значение True соответствует числу 1, а логическое значение False — числу 0.

Приведем несколько примеров:

bool(0)    # False
bool(1)    # True
bool(2)    # True
bool(-1)   # True
bool("")   # False
bool("hello")  # True
bool([])   # False
bool([1, 2, 3])  # True
bool(None)  # False

Также тип данных bool может быть преобразован в другие типы данных, например, в целое число или строку. Логическое значение True при преобразовании в целое число будет равно 1, а False — 0. При преобразовании в строку логическое значение True будет преобразовано в строку «True», а логическое значение False — в строку «False».

int(True)   # 1
int(False)  # 0
str(True)   # 'True'
str(False)  # 'False'

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

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

Операторы сравнения — это операторы, которые сравнивают два значения и возвращают значение типа bool (True или False) в зависимости от результата сравнения.

Вот некоторые из наиболее распространенных операторов сравнения в Python:

Вот примеры использования операторов сравнения:

a = 10
b = 5

print(a == b)  # False, потому что a не равно b
print(a != b)  # True, потому что a не равно b
print(a > b)   # True, потому что a больше b
print(a < b)   # False, потому что a меньше b
print(a >= b)  # True, потому что a больше или равно b
print(a <= b)  # False, потому что a меньше или равно b

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

Например:

print("hello" == "hello")  # True, потому что оба значения равны
print("hello" != "world")  # True, потому что значения не равны
print(True == False)       # False, потому что значения не равны

Операторы сравнения широко используются в условных операторах для принятия решений в зависимости от результатов сравнения.

Несколько примеров использования if и операторов сравнения

1. Напишем программу, которая просит пользователя ввести свой возраст и выводит сообщение, является ли он совершеннолетним или нет.

age = int(input("Введите ваш возраст: "))
if age >= 18:
    print("Вы совершеннолетний!")
else:
    print("Вы несовершеннолетний.")

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

a = float(input("Введите первое число: "))
b = float(input("Введите второе число: "))

if a > b:
    print("Первое число больше второго.")
elif b > a:
    print("Второе число больше первого.")
else:
    print("Оба числа равны.")

1. Напишем программу, которая запрашивает у пользователя его имя и проверяет, совпадает ли оно с заданным именем (Анна).

name = input("Введите ваше имя: ")
if name == "Анна":
    print("Вы ввели верное имя.")
else:
    print("Вы ввели неверное имя.")

Использование else

В примерах выше, мы увидели с вами незнакомые инструкции else и elif. Разберем, для чего нужна первая из них — else.

Оператор else используется вместе с условным оператором if и указывает на то, что нужно выполнить определенный блок кода, если условие в if не выполняется.

Вот синтаксис использования else вместе с if:

num = int(input("Введите число: "))
if num % 2 == 0:
    print("Число", num, "является четным.")
else:
    print("Число", num, "является нечетным.")

1. Пример программы, которая запрашивает у пользователя пароль и проверяет, верен ли он:

password = input("Введите пароль: ")
if password == "qwerty":
    print("Добро пожаловать!")
else:
    print("Неверный пароль. Попробуйте еще раз.")

В обоих примерах, если условие в if истинно, то выполняется соответствующий блок кода, а если условие ложно, то выполняется блок кода, указанный в else.

Задания на закрепление if-else и операторов сравнения

Задание 1. Напишите программу, которая запрашивает у пользователя его возраст и проверяет, является ли он совершеннолетним (18 лет и старше). Если пользователь совершеннолетний, то программа должна выводить сообщение «Добро пожаловать на сайт!», а если нет, то «Вы не совершеннолетний, доступ запрещен.».

age = int(input("Введите свой возраст: "))
if age >= 18:
    print("Добро пожаловать на сайт!")
else:
    print("Вы не совершеннолетний, доступ запрещен.")

Задание 2. Напишите программу, которая запрашивает у пользователя год его рождения и определяет, является ли он високосным. Если год високосный, программа должна выводить сообщение «Ваш год рождения — високосный!», а если нет, то «Ваш год рождения не является високосным.»

year = int(input("Введите год вашего рождения: "))
if year % 4 == 0 and (year % 100 != 0 or year % 400 == 0):
    print("Ваш год рождения - високосный!")
else:
    print("Ваш год рождения не является високосным.")

Задание 3. Напишите программу, которая запрашивает у пользователя два числа и определяет, какое из них больше. Если первое число больше, программа должна выводить «Первое число больше», если второе — «Второе число больше», а если числа равны, то «Числа равны»

num1 = float(input("Введите первое число: "))
num2 = float(input("Введите второе число: "))
if num1 > num2:
    print("Первое число больше")
elif num1 < num2:
    print("Второе число больше")
else:
    print("Числа равны")

Конструкция elif

Конструкция elif используется вместе с if и позволяет проверять несколько условий одновременно. Если первое условие не истинно, то проверяется следующее, и так далее, до тех пор, пока не найдется условие, которое является истинным. Если ни одно из условий не является истинным, то выполняется блок else (если он присутствует).

Вот синтаксис использования elif:

if условие1:
    # код, который выполняется, если условие1 истинно
elif условие2:
    # код, который выполняется, если условие1 ложно, а условие2 истинно
elif условие3:
    # код, который выполняется, если условие1 и условие2 ложны, а условие3 истинно
...
else:
    # код, который выполняется, если все предыдущие условия ложны

Вот несколько примеров использования elif:

Пример 1: Проверка возраста и определение категории посетителей парка развлечений

age = int(input("Введите свой возраст: "))

if age < 5:
    print("Младенец - вход свободный")
elif age < 18:
    print("Дети - стоимость билета 10 долларов")
elif age < 65:
    print("Взрослые - стоимость билета 20 долларов")
else:
    print("Пожилые - стоимость билета 10 долларов")

В этом примере if используется для проверки возраста посетителя. Если возраст меньше 5 лет, программа напечатает сообщение «Младенец — вход свободный». Если возраст не меньше 5, то проверяется следующее условие в блоке elif. Если возраст меньше 18, то программа напечатает сообщение «Дети — стоимость билета 10 долларов». Если возраст не меньше 18, то проверяется следующее условие в блоке elif. Если возраст меньше 65, то программа напечатает сообщение «Взрослые — стоимость билета 20 долларов». Если ни одно из предыдущих условий не истинно, то выполняется блок else, и программа напечатает сообщение «Пожилые — стоимость билета 10 долларов».

Пример 2: использования elif с else:

age = int(input("Введите возраст: "))
if age < 18:
    print("Вы еще не совершеннолетний")
elif age < 25:
    print("Вы молодой человек")
else:
    print("Вы уже взрослый")

В этом примере мы сначала проверяем, является ли человек несовершеннолетним (меньше 18 лет). Если это не так, то проверяем, является ли он молодым человеком (от 18 до 24 лет). Если и это не так, то выводим, что он уже взрослый.

Пример использования только elif:

x = int(input("Введите число: "))
if x > 0:
    print("Число положительное")
elif x < 0:
    print("Число отрицательное")
else:
    print("Число равно нулю")

В этом примере мы проверяем, является ли введенное число положительным. Если это не так, то проверяем, является ли оно отрицательным. Если и это не так, то выводим, что число равно нулю.

Задания для закрепления elif

Задание 4. Напишите программу, которая принимает на вход возраст человека и выводит сообщение о его возрастной категории: «ребенок» (до 12 лет), «подросток» (от 12 до 18 лет), «взрослый» (от 18 до 60 лет) или «пенсионер» (старше 60 лет).

age = int(input("Введите возраст: "))

if age < 12:
    print("Ребенок")
elif age < 18:
    print("Подросток")
elif age < 60:
    print("Взрослый")
else:
    print("Пенсионер")

Задание 5. Напишите программу, которая принимает на вход три числа и выводит сообщение о том, какие два числа из них наибольшие.

a = int(input("Введите первое число: "))
b = int(input("Введите второе число: "))
c = int(input("Введите третье число: "))

if a >= b and a >= c:
    print("Первое число наибольшее")
    if b >= c:
        print("Второе число второе по величине")
    else:
        print("Третье число второе по величине")
elif b >= a and b >= c:
    print("Второе число наибольшее")
    if a >= c:
        print("Первое число второе по величине")
    else:
        print("Третье число второе по величине")
else:
    print("Третье число наибольшее")
    if a >= b:
        print("Первое число второе по величине")
    else:
        print("Второе число второе по величине")

Логические операторы and, or, not

Логические операторы — это специальные операторы, которые позволяют соединять логические выражения между собой и строить более сложные условия. В Python есть три логических оператора: and, or и not.

Оператор and возвращает True, если оба операнда равны True, иначе он возвращает False. Например:

x = 5
y = 10
if x < 10 and y > 5:
    print("Оба условия выполнены")

Оператор or возвращает True, если хотя бы один операнд равен True, иначе он возвращает False. Например:

x = 5
y = 3
if x < 10 or y > 5:
    print("Хотя бы одно условие выполнено")

Оператор not инвертирует (делает противоположным) значение операнда. Если операнд равен True, то not возвращает False, и наоборот. Например:

x = True
if not x:
    print("x равно False")
else:
    print("x равно True")

При использовании логических операторов совместно с операторами сравнения, следует помнить о приоритете выполнения операторов. В Python порядок выполнения операций определяется следующим образом: сначала выполняются операции в скобках, затем унарные операции (например, not), затем умножение и деление, затем сложение и вычитание, затем операции сравнения (например, < и >), затем логические операторы and и or.

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

x = 5
y = 10
z = 15

if x < y and y < z:
    print("y находится между x и z")

if x == 5 or y == 5:
    print("x или y равны 5")

if not (x > y):
    print("x меньше или равно y")

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

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

num = int(input("Введите число: "))

if num > 0 and num % 3 == 0:
    print("Число положительное и кратно 3.")
else:
    print("Число не положительное и/или не кратно 3.")

Задание 7. Напишите программу, которая проверяет, является ли введенный пользователем год високосным.

year = int(input("Введите год: "))

if year % 4 == 0 and (year % 100 != 0 or year % 400 == 0):
    print("Год является високосным.")
else:
    print("Год не является високосным.")

Задание 9. Напишите программу, которая проверяет, является ли введенное пользователем число отрицательным, или равным нулю, или кратным 7.

num = int(input("Введите число: "))

if num <= 0 or num % 7 == 0:
    print("Число отрицательное или равно нулю или кратно 7.")
else:
    print("Число не отрицательное и не равно нулю и не кратно 7.")

Вложенные инструкции if

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

Пример использования вложенного if:

num = int(input("Введите число: "))

if num % 2 == 0:
    if num % 3 == 0:
        print("Число делится и на 2, и на 3")
    else:
        print("Число делится только на 2")
else:
    if num % 3 == 0:
        print("Число делится только на 3")
    else:
        print("Число не делится ни на 2, ни на 3")

В данном примере мы проверяем, делится ли введенное число на 2 и/или на 3, и выводим соответствующее сообщение. Если число делится на 2, то мы проверяем, делится ли оно еще и на 3. Если да, то выводим сообщение «Число делится и на 2, и на 3», иначе выводим «Число делится только на 2». Если число не делится на 2, то мы проверяем, делится ли оно на 3. Если да, то выводим «Число делится только на 3», иначе выводим «Число не делится ни на 2, ни на 3».

В данном примере мы использовали две вложенные инструкции if.

Также можно использовать каскадную конструкцию if-elif-else, которая позволяет проводить несколько проверок подряд, пока не будет найдено соответствующее условие. Пример:

num = int(input("Введите число: "))

if num > 0:
    print("Число положительное")
elif num < 0:
    print("Число отрицательное")
else:
    print("Число равно нулю")

В данном примере мы проверяем, является ли введенное число положительным, отрицательным или нулем, и выводим соответствующее сообщение. Если число больше нуля, то выводим «Число положительное», иначе проверяем, меньше ли число нуля. Если да, то выводим «Число отрицательное», иначе выводим «Число равно нулю».

Здесь мы использовали каскадную конструкцию if-elif-else.

Задание на тренировку

Задание 10. Напишите программу, которая запрашивает у пользователя 2 числа и определяет, какое из них больше, и насколько оно отличается от другого. Если числа равны, программа должна вывести сообщение «Числа равны».

num1 = int(input("Введите первое число: "))
num2 = int(input("Введите второе число: "))

if num1 > num2:
    print(f"Число {num1} больше на {num1 - num2}")
elif num2 > num1:
    print(f"Число {num2} больше на {num2 - num1}")
else:
    print("Числа равны")

Цепочки сравнений

В Python можно использовать несколько операторов сравнения в одном выражении. Такая запись называется цепочкой сравнений (chained comparison) и позволяет проверить, удовлетворяет ли переменная нескольким условиям одновременно.

Например, чтобы проверить, находится ли число x в диапазоне от 5 до 9 включительно, можно написать:

5 <= x <= 9

Такая запись эквивалентна следующей последовательности двух операторов сравнения:

5 <= x and x <= 9

Также можно применять цепочки сравнений с переменными разных типов, например:

'a' <= my_char <= 'z'

В этом случае мы проверяем, является ли символ my_char строчной буквой латинского алфавита.

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

Тернарный оператор

Тернарный оператор — это оператор условия в Python, который имеет следующий синтаксис: value_if_true if condition else value_if_false.

Тернарный оператор позволяет сократить код при проверке условия, вместо написания полной конструкции if-else. Он принимает три операнда: сначала условие, затем значение, которое будет возвращено, если условие истинно, и значение, которое будет возвращено, если условие ложно.

Вот пример использования тернарного оператора:

x = 5
y = 10
max_value = x if x > y else y
print(max_value)

В этом примере переменной max_value присваивается значение x, если x больше y, и значение y в противном случае. Результатом выполнения программы будет число 10.

Еще один пример использования тернарного оператора:

age = 18
is_adult = True if age >= 18 else False
print(is_adult)

В этом примере переменной is_adult присваивается значение True, если возраст (age) больше или равен 18, и значение False в противном случае. Результатом выполнения программы будет значение True.

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

Оператор is

Оператор is используется для проверки идентичности объектов в Python. Он возвращает значение True, если два объекта имеют одинаковый идентификатор (адрес в памяти) и False, если идентификаторы объектов разные.

Синтаксис оператора is выглядит следующим образом:

x is y

где x и y — переменные или объекты.

Примеры использования оператора is:

a = [1, 2, 3]
b = a
c = [1, 2, 3]

print(a is b)  # True, т.к. a и b ссылаются на один и тот же объект
print(a is c)  # False, т.к. a и c имеют разные объекты, даже если они имеют одинаковое значение

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

a = [1, 2, 3]
b = a

if a is b:
    print("a и b ссылаются на один и тот же объект")
else:
    print("a и b ссылаются на разные объекты")

Кроме оператора is, в Python также есть оператор ==, который используется для проверки равенства значений переменных. Разница между is и == в том, что is проверяет идентичность объектов, а == — равенство их значений.

Оператор in

Оператор in используется для проверки наличия элемента в коллекции (например, в списке, кортеже, множестве, строке и др.). Как использовать данный оператор в строках, я подробно описывал на уроке работа со строками.

Синтаксис оператора in:

элемент in коллекция

где элемент – значение, которое необходимо проверить на наличие в коллекции.

Результатом выполнения оператора in является булевое значение True, если элемент содержится в коллекции, и False в противном случае.

Рассмотрим примеры использования оператора in:

# проверка наличия элемента в списке
fruits = ['apple', 'banana', 'cherry']
if 'banana' in fruits:
    print('Ура! Мы нашли банан!')

# проверка наличия символа в строке
word = 'hello'
if 'h' in word:
    print('Первая буква слова - "h"')

# проверка наличия ключа в словаре
person = {'name': 'John', 'age': 30, 'city': 'New York'}
if 'age' in person:
    print('Персона имеет возраст')

# проверка наличия элемента в множестве
set1 = {1, 2, 3, 4, 5}
if 3 in set1:
    print('Число 3 содержится в множестве set1')

В результате выполнения программы будет выведено:

Ура! Мы нашли банан!
Первая буква слова - "h"
Персона имеет возраст
Число 3 содержится в множестве set1

Также оператор in можно использовать вместе с условной конструкцией not для проверки отсутствия элемента в коллекции:

# проверка отсутствия элемента в списке
fruits = ['apple', 'banana', 'cherry']
if 'orange' not in fruits:
    print('Апельсина в списке нет :(')

# проверка отсутствия символа в строке
word = 'hello'
if 'z' not in word:
    print('Буквы "z" в слове нет')

Результатом выполнения программы будет:

Апельсина в списке нет :(
Буквы "z" в слове нет

Пример задания на закрепление оператора in

Допустим, мы хотим написать программу, которая проверяет, является ли заданное слово палиндромом, то есть словом, которое читается одинаково как слева направо, так и справа налево. Например, слова «ротор», «топот» и «довод» являются палиндромами, а слова «мама» и «папа» нет.

Мы можем использовать оператор in для проверки наличия символов в строке. Для этого сначала перевернем заданную строку и затем сравним ее с оригинальной строкой.

Вот код решения:

word = input("Введите слово: ")
if word == word[::-1]:
    print("Слово является палиндромом")
else:
    print("Слово не является палиндромом")

Здесь мы считываем слово из пользовательского ввода и затем проверяем, равно ли оно перевернутому слову. Если да, то это палиндром, и программа выводит соответствующее сообщение. Если нет, то это не палиндром.

С использованием оператора in мы могли бы написать это условие так:

if all(word[i] == word[-i-1] for i in range(len(word)//2)):
    print("Слово является палиндромом")
else:
    print("Слово не является палиндромом")

Здесь мы использовали оператор all() для проверки того, что каждый символ в слове равен соответствующему символу в перевернутом слове. Для этого мы проходимся по половине длины слова с помощью range(len(word)//2) и проверяем равенство символов, используя индексы -i-1 для доступа к символам с конца слова.

Заглушки кода. Ключевое слово pass

Ключевое слово pass в Python используется в тех случаях, когда требуется указать пустое тело блока кода, чтобы избежать ошибок синтаксиса.

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

Создание условной конструкции, которая должна быть заполнена позже:

if x > 0:
    pass
else:
    print("x is negative")

Таким образом, pass — это полезный инструмент, который помогает избежать ошибок синтаксиса при написании кода, когда необходимо создать заглушку для блока кода, который будет заполнен позже.

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

Задания для тренировки

Задание 11. Известны два расстояния: одно в километрах, другое — в футах ( 1 фут 0,305 м ). Какое из расстояний меньше?

distance_km = 10
distance_ft = 32808.4

distance_m_km = distance_km * 1000
distance_m_ft = distance_ft * 0.305

if distance_m_km < distance_m_ft:
    print("Расстояние в километрах меньше")
else:
    print("Расстояние в футах меньше")

Задание 12. Даны радиус круга и сторона квадрата. У какой фигуры площадь больше?

import math

radius = float(input("Введите радиус круга: "))
side = float(input("Введите длину стороны квадрата: "))

area_circle = math.pi * radius ** 2
area_square = side ** 2

if area_circle > area_square:
    print("Площадь круга больше")
else:
    print("Площадь квадрата больше")

Задание 13. Поле шахматной доски определяется парой натуральных чисел, каждое из которых не превосходит 8: первое число — номер вертикали (при счете слева направо), второе — номер горизонтали (при счете снизу вверх). Даны натуральные числа a, b, c, d, каждое из которых не превосходит 8. На поле (a, b) расположена ладья. Может ли ладья пойти в клетку с координатами c,d?

a = int(input("Введите номер вертикали (от 1 до 8) для начальной клетки: "))
b = int(input("Введите номер горизонтали (от 1 до 8) для начальной клетки: "))
c = int(input("Введите номер вертикали (от 1 до 8) для конечной клетки: "))
d = int(input("Введите номер горизонтали (от 1 до 8) для конечной клетки: "))

if a == c or b == d:
    print("Ладья может пойти в клетку ({}, {})".format(c, d))
else:
    print("Ладья не может пойти в клетку ({}, {})".format(c, d))

Введите номер вертикали (от 1 до 8) для начальной клетки: 2
Введите номер горизонтали (от 1 до 8) для начальной клетки: 3
Введите номер вертикали (от 1 до 8) для конечной клетки: 4
Введите номер горизонтали (от 1 до 8) для конечной клетки: 3
Ладья может пойти в клетку (4, 3)

Задание 14. Поле шахматной доски определяется парой натуральных чисел, каждое из которых не превосходит 8: первое число — номер вертикали (при счете слева направо), второе — номер горизонтали (при счете снизу вверх). Даны натуральные числа a, b, c, d, каждое из которых не превосходит 8. На поле (a, b) расположена фигура — слон. Может ли слон пойти в клетку с координатами c,d?

a, b, c, d = 2, 3, 5, 6

dx = abs(c - a)
dy = abs(d - b)

if dx == dy:
    print("Слон может пойти в клетку ({}, {})".format(c, d))
else:
    print("Слон не может пойти в клетку ({}, {})".format(c, d))

Слон может пойти в клетку (5, 6)

Задание 15. Поле шахматной доски определяется парой натуральных чисел, каждое из которых не превосходит 8: первое число — номер вертикали (при счете слева направо), второе — номер горизонтали (при счете снизу вверх). Даны натуральные числа a, b, c, d, каждое из которых не превосходит 8. На поле (a, b) расположена фигура — король. Может ли король пойти в клетку с координатами c,d?

if abs(a-c) <= 1 and abs(b-d) <= 1:
    print("Король может пойти в клетку с координатами", c, d)
else:
    print("Король не может пойти в клетку с координатами", c, d)

Задание 16. Поле шахматной доски определяется парой натуральных чисел, каждое из которых не превосходит 8: первое число — номер вертикали (при счете слева направо), второе — номер горизонтали (при счете снизу вверх). Даны натуральные числа a, b, c, d, каждое из которых не превосходит 8. На поле (a, b) расположена фигура — ферзь. Может ли ферзь пойти в клетку с координатами c,d?

if a == c or b == d or abs(a-c) == abs(b-d):
    print("Ферзь может пойти в клетку (", c, ",", d, ")")
else:
    print("Ферзь не может пойти в клетку (", c, ",", d, ")")

Задание 17. Поле шахматной доски определяется парой натуральных чисел, каждое из которых не превосходит 8: первое число — номер вертикали (при счете слева направо), второе — номер горизонтали (при счете снизу вверх). Даны натуральные числа a, b, c, d, каждое из которых не превосходит 8. На поле (a, b) расположена фигура — конь. Может ли конь пойти в клетку с координатами c,d?

# координаты начальной позиции фигуры
a = 2
b = 3

# координаты конечной позиции
c = 4
d = 6
if abs(a-c) == 2 and abs(b-d) == 1 or abs(a-c) == 1 and abs(b-d) == 2:
    print("Фигура может пойти в клетку с координатами", c, d)
else:
    print("Фигура не может пойти в клетку с координатами", c, d)

Задание 18. Если целое число m делится нацело на целое число n, то вывести на экран частное от деления, в противном случае вывести сообщение «m на n нацело не делится».

m = 20
n = 5

if m % n == 0:
    quotient = m // n
    print("Частное от деления:", quotient)
else:
    print("m на n нацело не делится")

Частное от деления: 4

Задание 19. Дано двузначное число. Определить: а) какая из его цифр больше: первая или вторая; б) одинаковы ли его цифры.

num = 56

# определяем первую и вторую цифры
digit1 = num // 10
digit2 = num % 10

# выводим результаты
if digit1 > digit2:
    print("Первая цифра больше второй")
elif digit2 > digit1:
    print("Вторая цифра больше первой")
else:
    print("Цифры равны")

Задание 20. Дано число. Определить, является ли число палиндромом («перевертышем»), т. е. таким числом, десятичная запись которого читается одинаково слева направо и справа налево.

num = input("Введите число: ")
if num == num[::-1]:
    print("Число является палиндромом")
else:
    print("Число не является палиндромом")

Задание 21. Дано трехзначное число. Определить: а) является ли сумма его цифр двузначным числом; б) является ли произведение его цифр трехзначным числом; в) больше ли числа а произведение его цифр; г) кратна ли пяти сумма его цифр; д) кратна ли сумма его цифр числу а.

number = input("Введите трехзначное число: ")
a = int(number[0]) # первая цифра
b = int(number[1]) # вторая цифра
c = int(number[2]) # третья цифра

# а) проверка суммы цифр на двузначность
if (a + b + c) > 9 and (a + b + c) < 100:
    print("Сумма цифр является двузначным числом")
else:
    print("Сумма цифр не является двузначным числом")

# б) проверка произведения цифр на трехзначность
if a * b * c > 99 and a * b * c < 1000:
    print("Произведение цифр является трехзначным числом")
else:
    print("Произведение цифр не является трехзначным числом")

# в) сравнение числа а и произведения цифр
if a > (b * c):
    print("Число а больше произведения цифр")
else:
    print("Произведение цифр больше числа а")

# г) проверка кратности пяти суммы цифр
if (a + b + c) % 5 == 0:
    print("Сумма цифр кратна пяти")
else:
    print("Сумма цифр не кратна пяти")

# д) проверка кратности суммы цифр числу а
if (a + b + c) % int(number) == 0:
    print("Сумма цифр кратна числу а")
else:
    print("Сумма цифр не кратна числу а")

Введите трехзначное число: 456
Сумма цифр является двузначным числом
Произведение цифр не является трехзначным числом
Произведение цифр больше числа а
Сумма цифр не кратна пяти
Сумма цифр не кратна числу а

Идеи для задач взяты из Сборника задач по программированию Д.М. Златопольского