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

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

Рассмотрим его синтаксис на примере. Пусть от пользователя требуется ввести два целых числа: температуру на улице вчера и сегодня. А программа ответит — сегодня теплее, холоднее или же температура не изменилась:

yesterday_temp = int(input())
today_temp = int(input())
if today_temp > yesterday_temp:
    print("Сегодня теплее, чем вчера.")
elif today_temp < yesterday_temp:
    print("Сегодня холоднее, чем вчера.")
else:
    print("Сегодня такая же температура, как вчера.")

Оператор if является началом условной конструкции. Далее идёт условие, которое возвращает логическое значение True (истина) или False (ложь). Завершается условие символом «двоеточие». Затем — обязательный отступ в четыре пробела, он показывает, что строки объединяются в один блок. Отступ аналогичен использованию фигурных скобок или ключевых слов begin и end в других языках программирования.

Тело условной конструкции может содержать одно или несколько выражений (строк). По завершении тела может идти следующее условие, которое начинается с оператора elif (сокращение от else if — «иначе если»). Оно проверяется только в случае, если предыдущее условие не было истинным.

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

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

• > (больше);
• >= (больше или равно);
• < (меньше);
• <= (меньше или равно);
• == (равно);
• != (не равно).

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

• and — логическое «И» для двух условий. Возвращает True, если оба условия истинны, иначе возвращает False;
• or — логическое «ИЛИ» для двух условий. Возвращает False, если оба условия ложны, иначе возвращает True;
• not — логическое «НЕ» для одного условия. Возвращает False для истинного условия, и наоборот.

Ниже приведена таблица истинности для логических операций.

Рассмотрим следующий пример. Пользователь должен ввести первую и последнюю буквы русского алфавита. Ввод производится в двух отдельных строках и в любом регистре.

print("Введите первую и последнюю буквы русского алфавита.")
first_letter = input()
last_letter = input()
if (first_letter == "а" or first_letter == "А") and (
        last_letter == "я" or last_letter == "Я"):
    print("Верно.")
else:
    print("Неверно.")

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

if x >= 0 and x < 100:
    ...

лучше записать так:

if 0 <= x < 100:
    ...

Строки также можно сравнивать между собой с помощью операций >, < и т. д. В отличие от чисел, строки сравниваются посимвольно в соответствии с кодами символов в таблице кодировки (в Python рекомендуется использовать кодировку UTF-8).

Компьютер изначально работает только с двоичными числами. Поэтому для работы с символами им назначаются коды — числа, а сами таблицы соответствия символов и кодов называются таблицами кодировки. Кодировок существует достаточно много, одной из самых популярных на данный момент является UTF-8. Например, сравним две односимвольные строки:

letter_1 = "t"
letter_2 = "w"
print(letter_1 > letter_2)

Программа выведет False, поскольку символ t стоит в таблице кодировки раньше, чем w (как и по алфавиту, то есть лексикографически). Чтобы убедиться в этом, можно использовать встроенную функцию ord(), которая возвращает код символа из таблицы кодировки:

print(ord("t"), ord("w"))

В консоли отобразится:

116 119

Поскольку 116 меньше 119, в предыдущем примере мы и получили False.

Чтобы получить символ по его коду, необходимо вызвать встроенную функцию chr() с соответствующим кодом:

print(chr(116), chr(119))

В результате увидим:

t w

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

Для проверки условия наличия подстроки в строке (и для некоторых других вещей, о которых будет рассказано позже) используется оператор in. Например, проверим, что во введённой строке встречается корень «добр» (для слов «добрый», «доброе» и подобных):

text = input()
if "добр" in text:
    print("Встретилось 'доброе' слово.")
else:
    print("Добрых слов не найдено.")

В Python версии 3.10 появился оператор match. В простейшем случае он последовательно сравнивает значение выражения с заранее заданными в операторах case. А затем выполняет код в операторе case, значение в котором соответствует проверяемому. Напишем программу, которая сравнивает значение текущего сигнала светофора с одним из трёх вариантов (красный, жёлтый или зелёный):

color = input()
match color:
    case 'красный' | 'жёлтый':
        print('Стоп.')
    case 'зелёный':
        print('Можно ехать.')
    case _:
        print('Некорректное значение.')

Обратите внимание, что для проверки выполнения условия «ИЛИ» в операторе case не используется логическая операция or. Её нельзя использовать, поскольку она применяется для переменных логического типа, а в примере перечисляются значения-строки. Вместо неё мы используем специальный оператор |.

Последний оператор case выполняется всегда и сработает в случае, если ни одно из предыдущих условий не сработало. Оператор match похож на оператор switch других языков программирования — C++, JavaScript и т. д.

Рассмотрим некоторые полезные встроенные функции.

• Для определения длины строки (а также других коллекций, о которых будет рассказано позже) используется функция len().
• Для определения максимального и минимального из нескольких значений (не только числовых) используются функции max() и min() соответственно.
• Функция abs() используется для определения модуля числа.

Рассмотрим применение встроенных функций в следующем примере. Обратите внимание на строки, начинающиеся со знака #. Так в Python обозначаются комментарии — линии, которые не выполняются интерпретатором, а служат для пояснения кода.

m = 12
n = 19
k = 25

# максимальное число
print(max(m, n, k))

line_1 = "m"
line_2 = "n"
line_3 = "k"

# минимальная лексикографически строка
print(min(line_1, line_2, line_3))

# количество цифр в числе 2 в степени 2022
print(len(str(2 ** 2022)))

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

Ещё по теме

• Оператор match также используется для так называемой проверки шаблона (pattern matching), почитать о которой можно в этом материале.
• Все доступные в Python встроенные функции можно посмотреть на этой странице.

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

• условный оператор 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 test1:
    state1
elif test2:
    state2
else:
    state3

>>> if 1:
...     print('true')
... else:
...     print('false')
...
true

a = int(input())
if a < -5:
    print('Low')
elif -5 <= a <= 5:
    print('Mid')
else:
    print('High')

X and Y

X or Y

not X

if X:
    A = Y
else:
    A = Z

A = Y if X else Z

>>> A = 't' if 'spam' else 'f'
>>> A
't'

Для вставки кода на Python в комментарий заключайте его в теги <pre><code class=»python3″>Ваш код</code></pre>