Питон как написать если тогда условие

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

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

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

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.

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

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

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 встроенные функции можно посмотреть на этой странице.

Привет-привет, DTF! В этом лонге, я продолжаю цикл статей, которые помогут Вам в изучении Python. Всё с примерами и наглядно. Читай, узнавай, подписывайся!

План статей:

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

Весь код я предлагаю писать в Google Colab, для этого нам понадобиться там зарегистрироваться (подойдет учетка Google) и создать новый блокнот (Файл -> Создать блокнот).

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

Что такое условие? Зачем оно нужно?

Условие — это способ описать событие, при выполнении которого, произойдёт определенный сценарий действий.

Для начала, разберемся, а какие в принципе, бывают условия

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

Мы пишем ключевое слово, говорящее Python, что сейчас начнётся запись условия. Лайфхак, если Вы слышите предложение, которое начинается со слова «если» — то перед Вами ставят условие. В английском языке если переводится как if и именно с него начинается всякое условие.

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

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

Получаем, вот такую конструкцию:

если условие верно тогда:

____описание последующих действий

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

Теперь, поговорим про каждое из них более подробно.

< Меньше — условие верно, если левое значение меньше правого.

Здесь стоит проверить, что было бы, если бы условие не выполнилось?

Давайте, рассмотрим это на примере следующего типа условий:

> Больше — условие верно, если левое значение больше правого

Зеленая галочка слева от if, указывает нам на то, что программа отработала, однако вывода не последовало. Почему? Потому что условие неверно и действие лежащее внутри этого условия никогда не будет выполнено.

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

На очереди новый тип условий.

>= Больше или равно — условие верно, если левое значение меньше или равно правому

Условие работает, аналогично прошлому, с той лишь оговоркой, что в случае равенства между собой чисел — условие всё равно будет выполнено. Лучше всего, это будет видно на примере двух рядом стоящих условий.

<= Меньше или равно — условие верно, если левое значение больше или равно правому

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

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

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

С точностью до наоборот, работает условие неравенства

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

Что такое else?

Все условия проверены и работают ровно так, как мы от них ожидаем. Но на этом моменте, внимательный ученик заметит, что я сравнивал только числа. Но будут ли эти условия работать со строкой? Будут.

Создадим переменную name и добавим пользователю возможность записать в неё свое имя. Затем напишем условие, что если содержимое переменной равняется строке, то выведется надпись — «Я знаю, как тебя зовут».

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

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

Напишем такое условие, при котором, если пользователь ввёл ‘Pavel’ — программа ответит, что знает, как нас зовут, во всех иных случаях — что не знает.

Как объединять несколько условий в одно?

А что делать, если в данной программе, мы хотим учитывать регистр? Ну, например, кому-то будет лень писать своё имя с большой буквы, он напишет просто «pavel», как быть тогда?

Тут нам на помощь придут логические операторы OR (или) и AND (и). Они позволяют объединять несколько условий в одно.

OR —выполнит последующие действия, если достигнуто выполнение хотя бы одного условия.

Попробуем объединить условие с равенством переменной «Pavel» или «pavel» для вывода необходимого текста.

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

AND —работает по принципу, что последующие действия будут выполнены, в случае, если все перечисленные условия верны.

Например, мы хотим полностью идентифицировать нашего пользователя и проверить его на соответствие и имени, и фамилии.

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

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

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

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

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

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

Теперь, можно спроецировать этот пример в виде кода.

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

Новый тип данных — bool

В питоне существует также тип данных bool, в нём храниться всего два значения — True (Истина) и False (Ложь).

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

Попробуем, вывести на экран наши сравнения без if.

На основе этого, можно сделать вывод, что если условие True — последующие действия будут выполняться и напротив, если False — не будут.

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

При этом обратите внимание, нам не нужно сравнивать game с True, т.к. game, и есть True, то для истинности условия требуется лишь записать в нём эту переменную.

Что такое elif?

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

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

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

Закрепляем материал

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

Вам необходимо создать две переменные admin_login и admin_password и записать в них секретную информацию. Затем, предложим пользователю ввести логин и пароль от админ панели и запишем эту информацию в переменные user_login и user_password.

В случае, если логин и пароль будут совпадать — вывести сообщение об успешном входе.

Если не верен логин, вывести сообщение об этом.

Если не верен пароль, вывести сообщение об этом.

Если Вам что-то непонятно — можете писать вопросы в комментарии, я отвечу на каждый. Буду признателен подписке (особенно на YouTube канал), до встречи в новых постах!

На этом занятии
поговорим об условном операторе. Что это такое? Представьте, что вам нужно
вычислить модуль числа, хранящегося в переменной x. Как это
сделать? Очевидно, нужно реализовать такой алгоритм.

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

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

if(<условное выражение>) : оператор

или так:

if <условное выражение> : оператор

Если условное выражение
истинно, то выполняется оператор, записанный в if. Иначе этот
оператор не выполняется. Используя оператор ветвления, запишем программу для
вычисления модуля числа:

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

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

Какие операторы
сравнения существуют в Python и как они работают? Многие из
них нам известны из школьного курса математики, это:

Все эти
операторы при сравнении возвращают булевое значение: True – истина или False – ложь.
Например:

print(2 > 1)
print(2 == 1)
print(2 != 1)

Результат
сравнения можно присвоить переменной, как и любое значение:

result = 7 > 5
print(result)

Сравнение строк

Как вы видите,
сравнение двух числовых значений выполняется вполне очевидным образом. Но можно
ли, например, сравнивать строки между собой? Оказывается да, можно. Чтобы
определить, что одна строка больше другой, Python использует
«алфавитный» или «лексикографический» порядок. Другими словами, строки сравниваются
посимвольно. Например:

print('Я' > 'А' )
print( 'Кот' > 'Код' )
print( 'Сонный' > 'Сон' )

Алгоритм
сравнения двух строк довольно прост:

1. Сначала
   сравниваются первые символы строк.

2. Если первый
   символ первой строки больше (меньше), чем первый символ второй, то первая
   строка больше (меньше) второй.

3. Если первые
   символы равны, то таким же образом сравниваются уже вторые символы строк.

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

В примерах выше
сравнение ‘Я’ > ‘А’ завершится на первом шаге, тогда как строки
«Кот» и «Код» будут сравниваться посимвольно:

1. К равна К.
2. о равна о.
3. т больше чем д.

На этом сравнение заканчивается. Первая строка больше.

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

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

x = -5
if x < 0 : print("x отрицательное число")
if x >= 0 : print("x неотрицательное число")

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

x = 5
if x < 0:
    print("x отрицательное число")
else:
    print("x неотрицательное число")

Теперь, у нас
здесь всего одно условие. Если оно истинно, то выполнится первый print, а иначе –
второй. Такая программа будет работать быстрее. И обратите внимание на
синтаксис записи функции print: перед ней необходимо записать хотя бы
один пробел (обычно ставится 4 пробела или символ табуляции). Эти пробелы в Python означают блок
кода, который выполняется по некоторому условию. В данном случае блок кода
состоит всего из одного оператора print. То же самое и
для else.

В общем случае,
синтаксис оператора if else следующий:

if(<выражение>):
оператор 1

else: оператор 2

или

if(<выражение>):

    оператор 1

else:

    оператор 2

Если же мы хотим
по такому принципу выполнить три проверки: x > 0; x < 0; x == 0, то предыдущую
программу можно записать так:

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

И вообще таких
конструкций

if – elif – elif –…– elif – else

может быть
много. Далее, обратим внимание на такой факт: во всех наших примерах по условию
шел один оператор – print. Но что если нужно выполнить несколько
операторов по некоторому условию? Для этого их нужно записывать по такому
синтаксису:

if <условие>:

    оператор 1

    оператор 1

    …

    оператор N

Например:

x = -10; sgn = 0
if x < 0:
    sgn = -1
    print("x отрицательное число", sgn)
elif x > 0:
    sgn = 1
    print("x положительное число", sgn)
else:
    print("x равен 0", sgn)

Здесь по первым
двум условиям выполняется два оператора: присвоение значения переменной sgn и вывод
результата в консоль.

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

result = значение1 if <условие>
else значение2

При истинности
условия возвращается значение1, в противном случае – значение2. Например:

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

Получим True, если возраст (age) больше или равен 18, иначе – False. Кстати, проверку из данного примера можно сделать короче, просто прописав

accessAllowed = age >= 18

здесь оператор >=
вернет True при возрасте
больше или равен 18 и False – в противном
случае.

Теперь, когда мы
разобрались с базовыми моментами проверки условий, сделаем следующий шаг и
попробуем реализовать проверку попадания переменной x в диапазон [2;
7], то есть, условие должно быть истинным, когда x принимает
значения в этом диапазоне чисел. Очевидно, что здесь должно быть две проверки:
первая – мы проверяем, что x >= 2 и вторая – проверяем, что x <= 7. Если
оба этих условия выполняются одновременно, то x попадает в наш
диапазон. Реализовать такую проверку на Python можно так:

x = 4
if x >= 2 and x <= 7 : print("x попадает в [2; 7]")
else: print("x не попадает в [2; 7]")

Смотрите, здесь
записано два условия, объединенных по И (and – это И). В
результате, общее составное условие будет считаться истинным, если истинно и
первое и второе условие. Если хотя бы одно из этих условий ложно, то ложно и
все составное условие. В результате мы корректно реализуем проверку на
вхождение значения переменной в диапазон [2; 7].

А теперь давайте
реализуем противоположное условие, что x не принадлежит
диапазону [2; 7]. Условие будет таким:

x = 40
if(x < 2 or x > 7): print("x не попадает в [2; 7]")
else: print("x попадает в [2; 7]")

Здесь в
составном условии используется связка по ИЛИ (or – это ИЛИ) и
оно будет истинно, если истинно или первое, или второе условие. То есть, в
нашем случае, если x < 2 или x > 7, то
делается вывод о невхождении переменной x в указанный
диапазон.

Итак, запомните следующие правила:

• условие
  x >= 2 and x <= 7 истинно,
  если истинно каждое из подусловий (x>=2 и x <= 7) и
  ложно, если ложно хотя бы одно из них;

• условие
  x < 2 or x > 7 истинно,
  если истинно хотя бы одно из подусловий (x < 2 или x > 7) и
  ложно, когда оба ложны.

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

x = 4; y = -2
if x >= 2 and x <= 7 and (y < 0 or y > 5):
   print("x попадает в [2; 7], y не попадает в [0; 5]")

Здесь
реализована проверка, что x должно
принадлежать [2; 7], а y не принадлежать [0; 5]. И обратите
внимание вот на эти круглые скобки. Дело в том, что приоритет у операции and выше, чем у or, поэтому без
скобок у нас бы получилась вот такая проверка:

if (x
>= 2 and x <= 7 and y < 0) or (y > 5)

то есть, мы
проверяли бы, что x принадлежит [2; 7] и y меньше нуля ИЛИ y больше 5. Как вы
понимаете – это уже совсем другая проверка. Поэтому учитывайте приоритет этих
операций при формировании составного условия. Если нужно изменить приоритет – используйте
круглые скобки.

Одиночные проверки

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

x = 4; y = True; z = False
if(x): print("x = ", x, " дает true")
if(not 0): print("0 дает false")
if("0"): print("строка 0 дает true")
if(not ""): print("пустая строка дает false")
if(y): print("y = true дает true")
if(not z): print("z = false дает false")

Вот этот оператор
not – это отрицание
– НЕ, то есть, чтобы проверить, что 0 – это false мы
преобразовываем его в противоположное состояние с помощью оператора отрицания
НЕ в true и условие
срабатывает. Аналогично и с переменной z, которая равна false.

Из этих примеров
можно сделать такие выводы:

1. Любое число,
   отличное от нуля, дает True. Число 0 преобразуется в False.

2. Пустая строка –
   это False, любая другая
   строка с символами – это True.

3. С помощью
   оператора not можно менять
   условие на противоположное (в частности, False превращать в True).

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

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>

Ветвление и условные операторы Python для начинающих

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

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

Проще всего будет показать, как этот оператор работает на примере. Для этого попробуем написать программу «Угадай число». Если вы начинающий программист, обязательно попробуйте именно написать эту программу, чтобы прочувствовать на практике, как это работает. Компьютер выбирает случайное число, игрок пытается угадать, программа сообщает пользователю, верен ли его ответ.

import random
num = random.randint(1,10)
guess = int(input('Введите число от 1 до 10: '))
if guess == num :
    print('Угадали!')

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

Все строки кода, которые должны выполнится при срабатывании условия, должны быть написаны с отступом в четыре пробела относительно ключевого слова if. По отступам
Python понимает, что эти строки относятся именно к if, и выполнит их только если
условие будет истинным. В нашем примере, вывод строки «Угадали!» будет выполнен только если
пользователь введет правильное число.

Да, про модули мы поговорим позже, но, как вы уже возможно догадались, random.randint возвращает
случайное число, а строка import random загружает модуль для работы со случайными числами в нашу программу.
Список того, что может этот модуль можно посмотреть вот на этой странице. Сейчас мы, однако, говорим
об условиях и поэтому продолжим:

import random
num = random.randint(1,10)
guess = int(input('Введите число от 1 до 10: '))
if guess == num :
    print('Угадали!')
else:
    print('Извините, было загадано число ', num)

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

Кроме операторов if и else в одной связке можно использовать оператор elif. Он пригодится,
если нужно что‑то посложнее реакции на верное или неверное условие. Например, нашу игру «Угадай число»
можно дополнить еще двумя условиями проверки выхода введенного числа за допустимые границы:

import random
num = random.randint(1,10)
guess = int(input('Введите число от 1 до 10: '))
if guess == num :
    print('Угадали!')
elif guess > 10:
    print('Число не может быть больше 10')
elif guess < 1:
    print('Число не может быть меньше 10')    
else:
    print('Извините, было загадано число ', num)