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

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

Что делает условный оператор в Python

Проще всего это понять на примере. Введите в интерпретаторе 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. Таким образом, если в сложной программе вдруг оказались выполнены сразу несколько условий, будет исполнен только тот блок, который стоит первым: учитывайте это при написании кода.