Иначе в питоне как пишется

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

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

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 else

• Синтаксис

• Отступы

• Примеры

• Оператор elif
• Заглушка pass
• if else в одну строку
• Вложенные условия
• Конструкция switch case

Зачем нужны условные инструкции

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

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

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

Как работает if else

Синтаксис

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

# самый простой пример, где есть всего одно условие
a = 1
if a == 1:
print("It is true")

> It is true

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

1. сначала записывается часть if с условным выражением, которое возвращает истину или ложь;
2. затем может следовать одна или несколько необязательных частей elif (в других языках вы могли встречать else if);
3. Завершается же запись этого составного оператора также необязательной частью else.

count = 1
# условное выражение может быть сколь угодно сложным,
# и может быть сколь угодно много elif-частей
if True and count == 1 and count == 2:
print("if")
elif count == 'count':
print("First elif")
elif count == 14.2:
print("Second elif")
elif count == 1:
print("Nth elif")
else:
print("Else")

> Nth elif

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

b = 10
if b == 10:
# любое количество инструкций
print(b)
b = b * 15
b = b - 43
b = b ** 0.5
print(b)
elif b == 20:
print("You will not see me")
else:
print("And me")

> 10
> 10.344080432788601

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

Отступы

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

# начало кода
# код
# код
# код
# начало первого отступа
# первый отступ
# первый отступ
# начало второго отступа
# второй отступ
# второй отступ
# конец второго отступа
# конец первого отступа

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

var_a = 5
var_b = 10
var_c = 20
if var_c**2 > var_a * var_b:
# блок №1
if var_c < 100:
# блок №2
if var_c > 10:
# блок №3
var_a = var_a * var_b * var_c
# блок №2
var_b = var_a + var_c
# блок №1
var_c = var_a - var_b
print(var_a)
print(var_b)
print(var_c)

> 1000
> 1020
> -20

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

Примеры

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

Пример №1: создание ежедневного бэкапа (например базы данных):

from datetime import datetime

daily_backup(datetime(2020, 8, 15))
> backup on [2020-08-15] already exists

Пример №2: Проверка доступа пользователя к системе. В данном примере if проверяет наличие элемента в списке:

BLACK_LIST = ['192.34.12.3', '192.34.12.5', '192.34.10.23']
USERS = ['rolli34', 'constantinpetrovv', 'kate901']

if access_available("devnull", "192.34.10.11"):
print(f"Hello!!")
> write to log: user devnull [ip: 192.34.10.11] does not exists

Пример №3: Валидация входных данных. В примере к нам приходят данные в формате json. Нам необходимо выбрать все записи определенного формата:

NEED = {
"name": str,
"weight": int,
"age": int,
}

if is_valid({"name": "Alex", "weight": 60, "age": 18}):
print("data is valid")
> data is valid

Оператор elif

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

shinobi = 'Naruto'
if shinobi == 'Orochimaru':
print('fushi tensei')
elif shinobi == 'Naruto':
print('RASENGAN')
elif shinobi == 'Sasuke':
print('chidori')

> RASENGAN

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

Но помните, что первое условие всегда задается с if

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

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

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

Заглушка pass

Оператор-заглушка pass заменяет собой отсутствие какой-либо операции.

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

Наличие тела инструкции в Python обязательно

sum = 100000
account_first = 12000
account_second = 360000

if account_first > sum:
pass
elif account_second > sum:
pass
else:
print(sum)

if else в одну строку

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

# так выглядит условие в одну строку в JavaScript
const accessAllowed = (age > 21) ? true : false;

Читается это выражение так: если age больше 21, accessAllowed равен true, иначе — accessAllowed равен false.

В Python отсутствует тернарный оператор

Вместо тернарного оператора, в Питоне используют инструкцию if else, записанную в виде выражения (в одно строку):

<expression if True> if <predicate> else <expression if False>

Пример:

number = -10
abs_number = number if number >= 0 else -number

print(abs_number)

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

Стоит ли использовать такой синтаксис? Если пример простой, то однозначно да:

# полная версия
count = 3
if count < 100:
my_number = count
else:
my_number = 100

# сокращенная версия
count = 3
my_number = count if count < 100 else 100

Вполне читаемо смотрятся и следующие 2 примера:

x = "Kate" if "Alex" in "My name is Alex" else "Mary"
print(x)
> Kate

y = 43 if 42 in range(100) else 21
print(y)
> 43

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

x = 10
result = 100 if x > 42 else 42 if x == 42 else 0

print(result)
> 0

Вложенные условия

Ограничений для уровней вложенности в Python не предусмотрено, а регулируются они все теми же отступами:

# делать код менее читаемым можно до бесконечности
def run(action):
if action:
print(some_func())
else:
if some_func():
num = one_func()
if num:
if 0 < num < 100:
print(num)
else:
print('-')

Стоит ли использовать такие вложенности? Скорее нет, чем да. Одно из положений Python Zen гласит:

Flat is better than nested (развернутое лучше вложенного).

Большая вложенность имеет следующие недостатки:

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

Но что делать, если в скрипте не получается уйти от большой вложенности if-else? 🤷‍♂️

Чтобы уйти от большой вложенности, попробуйте не использовать оператор else

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

def run(action):
if action:
print(some_func())
return

print('-')

Конструкция switch case

В Python отсутствует инструкция switch case

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

# пример на C++
int main() {
int n = 5;
# сравниваем значение n поочередно со значениями case-ов
switch (n) {
case 1:
cout << n;
break;
case 2:
cout << n;
break;
# так как 5 не равняется ни 1-у, ни 2-м, то выполняется блок default
default:
cout << "There is not your number";
break;
}
return 0;
}

> There is not your number

Свято место пусто не бывает, поэтому в питоне такое множественное ветвление, в обычном случае, выглядит как последовательность проверок if-elif:

n = 5
if n == 1:
print(n)
elif n == 2:
print(n)
else:
print("There is not your number")

> "There is not your number"

Однако есть и более экзотический вариант реализации этой конструкции, задействующий в основе своей python-словари:

switch_dict = {
1: 1,
2: 2,
3: 3,
}
print(switch_dict.get(5, "There is not your number"))

> "There is not your number"

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

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

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

Операторы управления бывают следующих типов:

1. Оператор-выражение if
2. Оператор-выражение if-else
3. Оператор-выражение if-elif-else
4. Цикл while
5. Цикл for
6. Оператор-выражение break
7. Оператор-выражение continue

В этом уроке речь пойдет о первых трех операторах управления.

Синтаксис оператора if следующий:

if condition:
    <indented statement 1>
    <indented statement 2>

<non-indented statement>

Первая строчка оператора, то есть if condition: — это условие if, а condition — это логическое выражение, которое возвращает True или False. В следующей строке блок инструкций. Блок представляет собой одну или больше инструкций. Если он идет следом за условием if, такой блок называют блоком if.

Стоит обратить внимание, что у каждой инструкции в блоке if одинаковый отступ от слова if. Многие языки, такие как C, C++, Java и PHP, используют фигурные скобки ({}), чтобы определять начало и конец блока, но в Python используются отступы.

Каждая инструкция должна содержать одинаковое количество пробелов. В противном случае программа вернет синтаксическую ошибку. В документации Python рекомендуется делать отступ на 4 пробела. Такая рекомендация актуальная для и для этого .

Как это работает:

Когда выполняется инструкция if, проверяется условие. Если условие истинно, тогда все инструкции в блоке if выполняются. Но если условие оказывается неверным, тогда все инструкции внутри этого блока пропускаются.

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

Например:

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

if number > 10:
    print("Число больше 10")

Первый вывод:

Введите число: 100
Число больше 10

Второй вывод:

Введите число: 5

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

Рассмотрим следующий код:

number = int(input("Введите число: "))
if number > 10:
    print("первая строка")
    print("вторая строка")
    print("третья строка")

print("Выполняется каждый раз, когда вы запускаете программу")
print("Конец")

Первый вывод:

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

Второй вывод:

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

Здесь важно обратить внимание, что только выражения на строках 3, 4 и 5 относятся к блоку if. Следовательно, они будут исполнены только в том случае, когда условие if будет истинно. Но инструкции на строках 7 и 8 выполнятся в любом случае.

Консоль Python реагирует иначе при использовании операторов управления прямо в ней. Стоит напомнить, что для разбития выражения на несколько строк используется оператор продолжение (). Но в этом нет необходимости с операторами управления. Интерпретатор Python автоматически активирует мультистрочный режим, если нажать Enter после условия if. Например:

>>>
>>> n = 100
>>> if n > 10:
...

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

Чтобы закончить инструкцию if, нужно добавить еще одну инструкцию в блок if:

>>>
>>> n = 100
>>> if n > 10:
...     print("n v 10")
...

Python не будет автоматически добавлять отступ. Это нужно сделать самостоятельно. Закончив ввод инструкции, нужно дважды нажать Enter, чтобы исполнить инструкцию. После этого консоль вернется к изначальному состоянию.

>>>
>>> n = 100
>>> if n > 10:
...     print("n больше чем 10")
...
n больше чем 10
>>>

Все эти программы заканчиваются внезапно, не показывая ничего, если условие не истинно. Но в большинстве случаев пользователю нужно показать хотя бы что-нибудь. Для этого используется оператор-выражение if-else.

Оператор if-else

Оператор if-else исполняет одну порцию инструкций, если условие истинно и другое — если нет. Таким образом этот оператор предлагает два направления действий. Синтаксис оператора if-else следующий:

if  condition:
    # блок if
    statement 1
    statement 2
    and so on
else:
    # блок else
    statement 3
    statement 4
    and so on:

Как это работает:

Когда оператор if-else исполняется, условие проверяется, и если оно возвращает True, когда инструкции в блоке if исполняются. Но если возвращается False, тогда исполняются инструкции из блока else.

Пример 1: программа для расчета площади и длины окружности круга.

radius = int(input("Введите радиус: "))

if radius >= 0:
    print("Длина окружности = ",  2  *  3.14  *  radius)
    print("Площадь = ", 3.14 * radius ** 2)
else:
    print("Пожалуйста, введите положительное число")

Первый вывод:

Введите радиус: 4
Длина окружности = 25.12
Площадь = 50.24

Второй вывод:

Введите радиус: -12
Пожалуйста, введите положительное число

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

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

radius = int(input("Введите радиус: "))

if radius >= 0:
    print("Длина окружности = ",  2  *  3.14  *  radius)
    print("Площадь = ", 3.14 * radius ** 2)

    else:
        print("Пожалуйста, введите положительное число")

Если попробовать запустить эту программу, то появится следующая ошибка:

$ python3 if_and_else_not_aligned.py
  File "if_and_else_not_aligned.py", line 6
    else:
       ^
SyntaxError: invalid syntax
$

Для исправления проблемы нужно вертикально выровнять if и else

Другой пример:

Пример 2: программа для проверки пароля, введенного пользователем.

password = input("Введите пароль: ")
if password == "sshh":
    print("Добро пожаловать")
else:
    print("Доступ запрещен")

Первый вывод:

Введите пароль: sshh
Добро пожаловать

Второй вывод:

Введите пароль: abc
Доступ запрещен

Вложенные операторы if и if-else

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

Оператор if внутри другого if-оператора

Пример 1: программа, проверяющая, имеет ли студент право на кредит.

gre_score = int(input("Введите текущий лимит: "))
per_grad = int(input("Введите кредитный рейтинг: "))

if per_grad > 70:
    # внешний блок if
        if gre_score > 150:
            # внутренний блок if
	    print("Поздравляем, вам выдан кредит")
else:
    print("Извините, вы не имеете права на кредит")

Здесь оператор if используется внутри другого if-оператора. Внутренним называют вложенный оператором if. В этом случае внутренний оператор if относится к внешнему блоку if, а у внутреннего блока if есть только одна инструкция, которая выводит “Поздравляем, вам выдан кредит”.

Как это работает:

Сначала оценивается внешнее условие if, то есть per_grad > 70. Если оно возвращает True, тогда управление программой происходит внутри внешнего блока if. Там же проверяется условие gre_score > 150. Если оно возвращает True, тогда в консоль выводится "Congratulations you are eligible for loan". Если False, тогда программа выходит из инструкции if-else, чтобы исполнить следующие операции. Ничего при этом не выводится в консоль.

При этом если внешнее условие возвращает False, тогда выполнение инструкций внутри блока if пропускается, и контроль переходит к блоку else (9 строчка).

Первый вывод:

Введите текущий лимит: 160
Введите кредитный рейтинг: 75
Поздравляем, вам выдан кредит

Второй вывод:

Введите текущий лимит: 160
Введите кредитный рейтинг: 60
Извините, вы не имеете права на кредит

У этой программы есть одна маленькая проблема. Запустите ее заново и введите gre_score меньше чем 150, а per_grade — больше 70:

Вывод:

Введите текущий лимит: 140
Введите кредитный рейтинг: 80

Программа не выводит ничего. Причина в том, что у вложенного оператора if нет условия else. Добавим его в следующем примере.

Пример 2: инструкция if-else внутри другого оператора if.

gre_score = int(input("Введите текущий лимит: "))
per_grad = int(input("Введите кредитный рейтинг: "))

if per_grad > 70:
    if gre_score > 150:
        print("Поздравляем, вам выдан кредит")
    else:
        print("У вас низкий кредитный лимит")
else:
    print("Извините, вы не имеете права на кредит")

Вывод:

Введите текущий лимит: 140
Введите кредитный рейтинг: 80
У вас низкий кредитный лимит

Как это работает:

Эта программа работает та же, как и предыдущая. Единственное отличие — у вложенного оператора if теперь есть инструкция else. Теперь если ввести балл GRE меньше, чем 150, программа выведет: “У вас низкий кредитный лимит”

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

Оператор if-else внутри условия else

Пример 3: программа для определения оценки студента на основе введенных баллов.

score = int(input("Введите вашу оценку: "))

if score >= 90:
    print("Отлично! Ваша оценка А")
else:
    if score >= 80:
	print("Здорово! Ваша оценка - B")
    else:
	if score >= 70:
	    print("Хорошо! Ваша оценка - C")
	else:
	    if score >= 60:
		print("Ваша оценка - D. Стоит повторить материал.")
	    else:
		print("Вы не сдали экзамен")

Первый вывод:

Введите вашу оценку: 92
Отлично! Ваша оценка А

Второй вывод:

Введите вашу оценку: 72
Хорошо! Ваша оценка - C

Третий вывод:

Введите вашу оценку: 56
Вы не сдали экзамен

Как это работает:

Когда управление программой переходит к оператору if-else, проверяется условие на строке 3 (score >= 90). Если оно возвращает True, в консоль выводится “Отлично! Ваша оценка А”. Если значение неверное, управление переходит к условию else на 5 строке. Теперь проверяется условие score >= 80 (6 строка). Если оно верное, тогда в консоли выводится “Здорово! Ваша оценка — B”.

В противном случае управление программой переходит к условию else на 8 строке. И здесь снова имеется вложенный оператор if-else. Проверяется условие (score >= 70). Если оно истинно, тогда в консоль выводится “Хорошо! Ваша оценка — C”. В противном случае управление переходит к блоку else на 11 строке. В конце концов, проверяется условие (score >= 60). Если оно возвращает True, тогда в консоль выводится “Ваша оценка — D. Стоит повторить материал.” Если же False, тогда в консоли будет “Вы не сдали экзамен”. На этом этапе управление переходит к следующим инструкциям, написанным после внешнего if-else.

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

Оператор if-elif-else

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

if condition_1:
    # блок if
    statement
    statement
    more statement
elif condition_2:
    # первый блок elif
    statement
    statement
    more statement
elif condition_3:
    # второй блок elif
    statement
    statement
    more statement

...

else
    statement
    statement
    more statement

Примечание: … означает, что можно писать сколько угодно условий eilf.

Как это работает:

Когда исполняется инструкция if-elif-else, в первую очередь проверяется condition_1. Если условие истинно, тогда исполняется блок инструкций if. Следующие условия и инструкции пропускаются, и управление переходит к операторам вне if-elif-else.

Если condition_1 оказывается ложным, тогда управление переходит к следующему условию elif, и проверяется condition_2. Если оно истинно, тогда исполняются инструкции внутри первого блока elif. Последующие инструкции внутри этого блока пропускаются.

Этот процесс повторяется, пока не находится условие elif, которое оказывается истинным. Если такого нет, тогда исполняется блок else в самом конце.

Перепишем программу с помощью if-elif-else.

score = int(input("Введите вашу оценку: "))

if score >= 90:
    print("Отлично! Ваша оценка А")
elif score >= 80:
    print("Здорово! Ваша оценка - B")
elif score >= 70:
    print("Хорошо! Ваша оценка - C")
elif score >= 60:
    print("Ваша оценка - D. Стоит повторить материал.")
else:
    print("Вы не сдали экзамен")

Первый вывод:

Введите вашу оценку: 78
Хорошо! Ваша оценка - C

Второй вывод:

Введите вашу оценку: 91
Отлично! Ваша оценка А

Третий вывод:

Введите вашу оценку: 55
Вы не сдали экзамен

Такую программу намного легче читать, чем в случае с вложенными if-else.

Условный оператор. Если то иначе. Программирование на языке Питон для начинающих

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

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

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

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

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

<  Меньше — условие верно, если первый операнд меньше второго. 

>  Больше — условие верно, если первый операнд больше второго. 

<= Меньше или равно. 

>= Больше или равно. 

== Равенство. Условие верно, если два операнда равны. 

!= Неравенство. Условие верно, если два операнда неравны.

Например, условие (x * x < 1000) означает “значение x * x меньше 1000”, а условие (2 * x != y) означает “удвоенное значение переменной x не равно значению переменной y”.

Операторы сравнения в Питоне можно объединять в цепочки (в отличии от большинства других языков программирования, где для этого нужно использовать логические связки / логические операторы), например, a == b == c или 1 <= x <= 10.

Операторы сравнения возвращают значения специального логического типа bool. Значения логического типа могут принимать одно из двух значений: True (истина) или False (ложь). Если преобразовать логическое True к типу int, то получится 1, а преобразование False даст 0. При обратном преобразовании число 0 преобразуется в False, а любое ненулевое число в True. При преобразовании str в bool пустая строка преобразовывается в False, а любая непустая строка в True. Булевы значения истина и ложь всегда возвращаютсятся в качестве результата, когда выражение сравнивается или оценивается (Попробуйте сами. Нажмите кнопку RUN):


x = 2
print(x == 2) #True
print(x == 3) #False
print(x < 3) #True


Допустим мы хотим по данному числу x определить его абсолютную величину (модуль). Программа должна напечатать значение переменной x, если x>0 или же величину -x в противном случае. Линейная структура программы нарушается: в зависимости от справедливости условия x>0 должна быть выведена одна или другая величина. Соответствующий фрагмент программы на Питоне имеет вид (Попробуйте сами. Нажмите кнопку RUN) Можно изменить значение переменной х и увидеть что вывод программы всегда будет положительным числом:


x = -7
if x > 0:
print(x)
else:
print(-x)


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

Этот фрагмент кода на Python интуитивно понятен каждому, кто помнит, что if по-английски значит «если», а else — «иначе». Оператор ветвления имеет в данном случае две части, операторы каждой из которых записываются с отступом вправо относительно оператора ветвления. Более общий случай — оператор выбора — можно записать с помощью следующего синтаксиса:

if Условие:
   Блок инструкций 1
else:
   Блок инструкций 2

 Блок инструкций 1 будет выполнен, если Условие истинно. Если Условие ложно, будет выполнен Блок инструкций 2.

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

1
2
3

if x < 0:
    x = -x
print(x)

В этом примере переменной x будет присвоено значение -x, но только в том случае, когда x<0. А вот инструкция print(x) будет выполнена всегда, независимо от проверяемого условия.

Напомню еще раз (так как это очень важно для языка Python) для выделения блока инструкций, относящихся к инструкции if или else в языке Питон используются отступы. Все инструкции, которые относятся к одному блоку, должны иметь равную величину отступа, то есть одинаковое число пробелов в начале строки. Рекомендуется использовать отступ в 4 пробела и не рекомедуется использовать в качестве отступа символ табуляции.

Это одно из существенных отличий синтаксиса Питона от синтаксиса большинства языков, в которых блоки выделяются специальными словами, например, нц… кц в Кумире, begin… end в Паскале или {фигурными} скобками в Си.

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

Иногда нужно проверить одновременно не одно, а несколько условий. Например, проверить, является ли данное число четным можно при помощи условия (n % 2 == 0) (остаток от деления n на 2 равен 0), а если необходимо проверить, что два данных целых числа n и m являются четными, необходимо проверить справедливость обоих условий: n % 2 == 0 и m % 2 == 0, для чего их необходимо объединить при помощи оператора and (логическое И): n % 2 == 0 and m % 2 == 0.

В Питоне существуют стандартные логические операторы: логическое И, логическое ИЛИ, логическое отрицание (НЕ).

Логическое И является бинарным оператором (то есть оператором с двумя операндами: левым и правым) и имеет вид and. Оператор and возвращает True тогда и только тогда, когда оба его операнда имеют значение True.

Логическое ИЛИ является бинарным оператором и возвращает True тогда и только тогда, когда хотя бы один операнд равен True. Оператор “логическое ИЛИ” имеет вид or.

Логическое НЕ (отрицание) является унарным (то есть с одним операндом) оператором и имеет вид not, за которым следует единственный операнд. Логическое НЕ возвращает True, если операнд равен False и наоборот.

Пример. Проверим, что хотя бы одно из чисел a или b оканчивается на 0:

if a % 10 == 0 or b % 10 == 0:

Проверим, что число a — положительное, а b — неотрицательное:

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

Или можно вместо not (b < 0) записать (b >= 0).

Инструкция множественного ветвления

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

1
2
3
4
5
6
7
8
9

x=2
if x==1:
    print "один"
elif x==2:
    print "два"
elif x==3:
    print "три"
else:
    print "другое число"

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

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

Внутри блока условной инструкции могут находится любые другие инструкции, в том числе и условная инструкция. Такие инструкции называются вложенными. Синтаксис вложенной условной инструкции такой:

     if условие1:
        ...
        if условие2:
           ...
        else:
           ...
        ...
     else:
        ...

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

Пример. У нас есть две ненулевые переменные x и y, мы хотим определить, в какой четверти координатной плоскости находится точка с координатами (x,y)


x=4
y=-6
if x>0:
print ("x>0")
if y>0:
print ("y>0")
print ("I (first)")
else:
print ("y<0")
print ("IV (fourth)")
else:
print ("x<0")
if y>0:
print ("y>0")
print ("II (second)")
else:
print ("y<0")
print ("III (third)")


Упражнение

Измените значение переменных так, чтобы все условия были Истинными, а программа в результате вывела на эеран цифры от 1 до 6. Попробуйте сами. Нажмите кнопку SOLUTION чтобы увидеть готовый код (Но лучше сначала попробовать самостоятельно). НУЖНА подсказака — пишите в комментарии! ))


number = 10
second_number = 10
first_array = []
second_array = [1,2,3]

if not second_number:
print("6")


number = 16
second_number = 0
first_array = [1,2,3]
second_array = [1,2]

if not second_number:
print("6")


test_object("number")
test_object("second_number")
test_object("first_array")
test_object("second_array")
success_msg("Super!")


Статья написана на основе материалов:

• http://informatics.mccme.ru/
• https://server.179.ru
• https://www.learnpython.org
• http://www.intuit.ru/

• Коменты VK
• Анонимные коменты, G+ или Facebook

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

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

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

Назад в начало

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

Попробую дать более популярное определение: условный оператор выполняет некоторое действие, если указанное условие истинно (равно True).

Вот так выглядит if…else в Python

if True:

    print(‘Условие истинно, поэтому я напечатаюсь’)

Приведу пример поинтереснее:

a = 10

b = 5

if a > b:

    print(‘a больше b равно True‘)

Если условие ложно, то код, находящийся под оператором if не выполнится:

a = 3

b = 9999999

if a > b:

    print(‘Я никогда не напечатаюсь :(‘)

Дополним предыдущий пример оператором else

a = 3

b = 9999999

if a > b:

    print(‘Я никогда не напечатаюсь :(‘)

else:

    print(‘if не выполнился, так что печатаюсь я’)

Если условие в if ложно, то выполнится оператор под оператором else

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

# Вывести большее из двух чисел,

# введенных с клавиатуры

a = int(input())

b = int(input())

if a > b:

    print(‘Большее число a = ‘ + str(a))

else:

    print(‘Большее число b = ‘ + str(b))

# Проверить число a на четность

a = int(input())

if a % 2 == 0:

    print(‘четное’)

else:

    print(‘нечетное’)

Иногда двух вариантов недостаточно, для этого существует оператор elif, а для все остального есть…

age = int(input())

if age < 10:

    print(‘Ваш возраст — это одна цифра :)’)

elif age < 15:

    print(‘Геометрия — это жестко (хочу обратно в началку)’)

else:

    print(‘В школе было круто’)

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

a = int(input(‘Введите число от одного до 1 до 100‘))

if a < 10:

    print(‘Ваше число меньше 10‘)

elif a < 20:

    print(‘Ваше число меньше двадцатки’)

elif a < 30:

    print(’30 — это потолок’)

elif a < 40:

    print(‘Ваше число меньше 40‘)

elif a < 50:

    print(‘Много, но не больше полтинника’)

elif a < 60:

    print(‘Число меньше, чем шесть*десять’)

elif a < 70:

    print(‘Ваше число расположено в восьмом десятке’)

elif a <

80:

    print(‘Ваше число меньше 80’)

elif a < 90:

    print(‘Ваше число находится в 9 десятке’)

elif a < 100:

    print(‘Сотня больше вашего числа’)

else:

    print(‘Хитро, но меня не обманешь, число слишком большое’)

Да, мне нечем было заняться, ну и что? Никогда не делайте так, как написано в примере выше. Если в вашем коде больше трех elif значит что-то не так и стоит придумать новый алгоритм. Давайте еще разок: много elif — плохо!

Примеры решения задач

Проверить является ли клетка шахматной доски белой

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

# Вывести YES, если клетка белая, и NO, если клетка черная

from random import randint

x = randint(1,8)

y = randint(1,8)

print(x, y)

if (x + y) % 2 == 1:

    print(‘YES’)

else:

    print(‘NO’)

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

x = int(input(‘Введите координату x: ‘))

y = int(input(‘Введите координату y: ‘))

if (x + y) % 2 == 1:

    print(‘YES’)

else:

    print(‘NO’)

Проверить может ли слон ходить с первой шахматной на вторую

# Четыре числа выбираются случайным образом (координаты клетки шахматного поля, от 1 до

# Вывести YES, если ладья может сходить с первой клетки на вторую, и NO, если не может

# Напомню, что ладья ходит так:

# Л ——X

# |

# |

# |

# X

from random import randint

x1 = randint(1, 8)

x2 = randint(1, 8)

y1 = randint(1, 8)

y2 = randint(1, 8)

print(x1, y1)

print(x2, y2)

if x1 == x2 and y1 != y2 or x1 != x2 and y1 == y2:

    print(‘YES’)

else:

    print(‘NO’)

То же самое, но с помощью ввода с клавиатуры

x1 = int(input(‘Введите координату x1: ‘))

x2 = int(input(‘Введите координату y1: ‘))

y1 = int(input(‘Введите координату x2: ‘))

y2 = int(input(‘Введите координату y2: ‘))

if x1 == x2 and y1 != y2 or x1 != x2 and y1 == y2:

    print(‘YES’)

else:

    print(‘NO’)

Решение задач

1. Пользователь вводит два целых числа. Выведите меньшее из них.

2. Пользователь вводит свое имя и возраст. Если возраст пользователя больше 18, то вывести строку «Добрый вечер, name! Вы совершеннолетний, поздравляем!», иначе вывести строку «Привет, name! Приносим извинения, но вы не можете гулять после 22:00». Пример:

3. Пользователь вводит три строки. Одна из них равна строке «Python», выведите номер этой строки.

4. Пользователь вводит три целых числа. Два из них равны друг другу. Выведите третье число, не равное остальным. Если среди введенных чисел не оказалось двух равных друг другу, выведите строку «Ошибка».

5. Пользователь вводит целое число. Проверьте является ли это число четырехзначным, если является, то выведите строку «Успешно», иначе «Неудача».

6. Пользователь вводит целое число — текущее время в часах. Если количество часов находится между 7 и 10, то программа должна вывести строку «Пора вставать!», иначе выведется строка «Ты проспал!». Если введенное число отрицательно или больше 23, то программа должна вывести строку «Ошибка».

7. Пользователь вводит текущее время в часах. Если количество часов находится в диапазоне от 0 до 7, то программа выводит строку «Ночь». Если часовая стрелка находится между 7 и 11, то выведется строка «Утро». От 12 до 17 выведется строка «День». Если текущее время находится между 17 и 23, то программа должна вывести строку «Вечер». В случае, когда введенное число отрицательно или превосходит 23, программа должна вывести строку «Ошибка».

8. Пользователь вводит строку — название времени года. Если введенная строка — это лето, то выведите строку «Тополинный пух, жара, июль», если зима, то «Снеговик, снежки и горка», если осень, то «Пора в школу!», если весна, то «Весенняя капель». В случае, если введенная строка не равна ни одному из предложенных вариантов, программа должна выводить строку «Ошибка».

9. Пользователь вводит целое число — номер месяца своего рождения. Выведите строку «Вы родились летом», если номер месяц совпадает с номером одного из летних месяцев. Если номер месяца совпал с номером одного из зимних месяцев, то нужно вывести «К холодам вам не привыкать». Для людей, которые празднуют свой день рождения осенью выведите «Я тоже люблю осенний листопад». Если весна ваше время года выведите строку «Подснежник». В случае, если введенное число меньше единицы или больше 12, выведите строку «Ошибка».

10. Пользователь вводит номер года своего рождения. Если этот год является високосным выведите «Вы случайно родились не 29 февраля?», иначе выведите «Ничего необычного».
Для справки, в високосном году 366 дней, а в обычном — 365. Номер високосного года, делится на 4, за исключением номеров тех годов, которые делятся на 100 и не делятся на 400 (например, годы 300, 1300 и 1900 не являются високосными, а 1200 и 2000 — являются).

11. Пользователь вводит целое число. Выведите его строку-описание вида «отрицательное четное число», «нулевое число», «положительное нечетное число», например, численным описанием числа 190 является строка «положительное четное число».

12. Дано целое число, лежащее в диапазоне от 1 до 999. Если число двузначное, выведите строку «Двузначное», если число содержит одну значащую цифру, то выведите строку «Цифра», если число является трехзначным выведите «Трехзначное». В случае, если введенное число меньше 0 или больше 999, выведите строку «Ошибка!».

13. Шахматный король ходит по горизонтали, вертикали и диагонали, но только на 1 клетку. Даны две различные клетки шахматной доски, определите, может ли король попасть с первой клетки на вторую одним ходом. Программа получает на вход четыре числа от 1 до 8 каждое, задающие номер столбца и номер строки сначала для первой клетки, потом для второй клетки. Программа должна вывести YES, если из первой клетки ходом короля можно попасть во вторую или NO в противном случае. В случае, если хотя бы одно из введенных чисел не лежит в диапазоне от 1 до 8, выведите строку «Ошибка!».

14. Шахматный ферзь ходит по диагонали, горизонтали или вертикали. Даны две различные клетки шахматной доски, определите, может ли ферзь попасть с первой клетки на вторую одним ходом. В случае, если хотя бы одно из введенных чисел не лежит в диапазоне от 1 до 8, выведите строку «Ошибка!».

15. Шахматный конь ходит буквой «Г» — на две клетки по вертикали в любом направлении и на одну клетку по горизонтали, или наоборот. Даны две различные клетки шахматной доски, определите, может ли конь попасть с первой клетки на вторую одним ходом. В случае, если хотя бы одно из введенных чисел не лежит в диапазоне от 1 до 8, выведите строку «Ошибка!».

16. Треугольник существует только тогда, когда сумма любых двух его сторон больше третьей. Дано a, b, c — стороны предполагаемого треугольника. Требуется сравнить длину каждого отрезка-стороны с суммой двух других. Если хотя бы в одном случае отрезок окажется больше суммы двух других, то треугольника с такими сторонами не существует.

В этом уроке рассмотрим оператор ветвления if и операторы цикла while и for.  Основная цель – это дать общее представление об этих операторах и на простых примерах показать базовые принципы работы с ними.

Условный оператор ветвления if

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

1. Конструкция if

Синтаксис оператора if выглядит так.

if выражение:
    инструкция_1
    инструкция_2
    ...
    инструкция_n

После оператора if  записывается выражение. Если это выражение истинно, то выполняются инструкции, определяемые данным оператором. Выражение является истинным, если его результатом является число не равное нулю, непустой объект, либо логическое True. После выражения нужно поставить двоеточие “:”.

ВАЖНО: блок кода, который необходимо выполнить, в случае истинности выражения, отделяется четырьмя пробелами слева!

Примеры:

if 1:
   print("hello 1")

Напечатает: hello 1

a = 3
if a == 3:
    print("hello 2")

Напечатает: hello 2

a = 3
if a > 1:
   print("hello 3")

Напечатает: hello 3

lst = [1, 2, 3]
if lst :
   print("hello 4")

Напечатает: hello 4

2. Конструкция if – else

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

if выражение:
    инструкция_1
    инструкция_2
    ...
    инструкция_n
else:
    инструкция_a
    инструкция_b
    ...
    инструкция_x

Примеры.

a = 3
if a > 2:
   print("H")
else:
   print("L")

Напечатает: H

a = 1
if a > 2:
   print("H")
else:
   print("L")

Напечатает: L

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

a = 17
b = True if a > 10 else False
print(b)

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

3. Конструкция if – elif – else

Для реализации выбора из нескольких альтернатив можно использовать конструкцию if – elif – else.

if выражение_1:
    инструкции_(блок_1)
elif выражение_2:
    инструкции_(блок_2)
elif выражение_3:
    инструкции_(блок_3)
else:
    инструкции_(блок_4)

Пример.

a = int(input("введите число:"))
if a < 0:
   print("Neg")
elif a == 0:
   print("Zero")
else:
   print("Pos")

Если пользователь введет число меньше нуля, то будет напечатано “Neg“, равное нулю – “Zero“, большее нуля – “Pos“.

Оператор цикла while

Оператор цикла while  выполняет указанный набор инструкций до тех пор, пока условие цикла истинно. Истинность условия определяется также как и в операторе if. Синтаксис оператора while  выглядит так.

while выражение:
    инструкция_1
    инструкция_2
    ...
    инструкция_n

Выполняемый набор инструкций называется телом цикла.

Пример.

a = 0
while a < 7:
   print("A")
   a += 1

Буква “А” будет выведена семь раз в столбик.

Пример бесконечного цикла.

a = 0
while a == 0:
   print("A")

Операторы break и continue

При работе с циклами используются операторы break  и continue.

Оператор break  предназначен для досрочного прерывания работы цикла while.

Пример.

a = 0
while a >= 0:
   if a == 7:
       break
   a += 1
   print("A")

В приведенном выше коде, выход из цикла произойдет при достижении переменной a  значения 7. Если бы не было этого условия, то цикл выполнялся бы бесконечно.

Оператор continue  запускает цикл заново, при этом код, расположенный после данного оператора, не выполняется.

Пример.

a = -1
while a < 10:
   a += 1
   if a >= 7:
       continue
   print("A")

При запуске данного кода символ “А” будет напечатан 7 раз, несмотря на то, что всего будет выполнено 11 проходов цикла.

Оператор цикла for

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

Пример. 

for i in range(5):
   print("Hello")

В результате “Hello” будет выведено пять раз.

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

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

lst = [1, 3, 5, 7, 9]
for i in lst:
   print(i ** 2)

Также можно пройти по всем буквам в строке.

word_str = "Hello, world!"
for l in word_str:
   print(l)

Строка “Hello, world!” будет напечатана в столбик.

На этом закончим краткий обзор операторов ветвления и цикла.

P.S.

Если вам интересна тема анализа данных, то мы рекомендуем ознакомиться с библиотекой Pandas. На нашем сайте вы можете найти вводные уроки по этой теме. Все уроки по библиотеке Pandas собраны в книге “Pandas. Работа с данными”.

<<< Python. Урок 4. Арифметические операции   Python. Урок 6. Работа с IPython и Jupyter Notebook >>>

The if Statement and Conditionals

if in Python means: only run the rest of this code once, if the condition evaluates to True. Don’t run the rest of the code at all if it’s not.

Anatomy of an if statement: Start with the if keyword, followed by a boolean value, an expression that evaluates to True, or a value with “Truthiness”. Add a colon :, a new line, and write the code that will run if the statement is True under a level of indentation.

Remember, just like with functions, we know that code is associated with an if statement by it’s level of indentation. All the lines indented under the if statement will run if it evaluates to True.

>>> if 3 < 5:
...     print("Hello, World!")
...
Hello, World!

Remember, your if statements only run if the expression in them evaluates to True and just like with functions, you’ll need to enter an extra space in the REPL to run it.

Using not With if Statements

If you only want your code to run if the expression is False, use the not keyword.

>>> b = False
>>> if not b:
...     print("Negation in action!")
...
Negation in action!

if Statements and Truthiness

if statements also work with items that have a “truthiness” to them.

For example:

• The number 0 is False-y, any other number (including negatives) is Truth-y
• An empty list, set, tuple or dict is False-y
• Any of those structures with items in it is Truth-y

>>> message = "Hi there."

>>> a = 0
>>> if a:   # 0 is False-y
...     print(message)
...

>>> b = -1
>>> if b:  # -1 is Truth-y
...     print(message)
...
Hi there.

>>> c = []
>>> if c:  # Empty list is False-y
...     print(message)
...

>>> d = [1, 2, 3]
>>> if d:  # List with items is Truth-y
...     print(message)
...
Hi there.

if Statements and Functions

You can easily declare if statements in your functions, you just need to mindful of the level of indentation. Notice how the code belonging to the if statement is indented at two levels.

>>> def modify_name(name):
...    if len(name) < 5:
...         return name.upper()
...    else:
...         return name.lower()
...
>>> name = "Nina"
>>> modify_name(name)
'NINA'

Nested if Statements

Using the same technique, you can also nest your if statements.

>>> def num_info(num):
...    if num > 0:
...        print("Greater than zero")
...        if num > 10:
...            print("Also greater than 10.")
...
>>> num_info(1)
Greater than zero
>>> num_info(15)
Greater than zero
Also greater than 10.

How Not To Use if Statements

Remember, comparisons in Python evaluate to True or False. With conditional statements, we check for that value implicitly. In Python, we do not want to compare to True or False with ==.

Warning — pay attention, because the code below shows what you shouldn’t do.

# Warning: Don't do this!
>>> if (3 < 5) == True: # Warning: Don't do this!
...     print("Hello")
...
Hello

# Warning: Don't do this!
>>> if (3 < 5) is True: # Warning: Don't do this!
...     print("Hello")
...
Hello

Do this instead:

>>> if 3 < 5:
...     print("Hello")
...
Hello

If we want to explicitly check if the value is explicitly set to True or False, we can use the is keyword.

>>> a = True        # a is set to True
>>> b = [1, 2, 3]   # b is a list with items, is "truthy"
>>>
>>> if a and b:     # this is True, a is True, b is "truthy"
...     print("Hello")
...
Hello
>>> if a is True:   # we can explicitly check if a is True
...     print("Hello")
...
Hello
>>> if b is True:   # b does not contain the actual value of True.
...     print("Hello")
...
>>>

else

The else statement is what you want to run if and only if your if statement wasn’t triggered.

An else statement is part of an if statement. If your if statement ran, your else statement will never run.

>>> a = True
>>> if a:
...     print("Hello")
... else:
...     print("Goodbye")
...
Hello

And vice-versa.

>>> a = False
>>> if a:
...     print("Hello")
... else:
...     print("Goodbye")
...
Goodbye

In the REPL it must be written on the line after your last line of indented code. In Python code in a file, there can’t be any other code between the if and the else.

You’ll see SyntaxError: invalid syntax if you try to write an else statement on its own, or put extra code between the if and the else in a Python file.

>>> if a:
...     print("Hello")
...
Hello
>>> else:
  File "<stdin>", line 1
    else:
       ^
SyntaxError: invalid syntax

elif Means Else, If.

elif means else if. It means, if this if statement isn’t considered True, try this instead.

You can have as many elif statements in your code as you want. They get evaluated in the order that they’re declared until Python finds one that’s True. That runs the code defined in that elif, and skips the rest.

>>> a = 5
>>> if a > 10:
...     print("Greater than 10")
... elif a < 10:
...     print("Less than 10")
... elif a < 20:
...     print("Less than 20")
... else:
...     print("Dunno")
...
Less than 10