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

if

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

В Python есть несколько способов проверки, исходов всегда два: истина (True) или ложь (False).

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

В Python есть несколько ключевых слов для создания ветвления. Начнем с if, для этого рассмотрим следующую программу: language = input('Какой язык программирования мы изучаем?')
if language == 'Python':
print('Верно! Мы изучаем Python =)')
print('Изучать Python весело!')

Программа просит пользователя ввести текст и проверяет результат ввода. Если введенный текст равен строке "Python", то выводит пользователю текст: Верно! Мы изучаем Python =) Изучать Python весело!

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

Следующий пример вызовет ошибку: if language == 'Python':
print('Верно! Мы изучаем Python =)')

name = input("Как тебя зовут?")
print('Изучать Python весело!')
# IndentationError: unexpected indent

Программа выводит текст в случае, если условие истинно. Но если условие ложно, то программа ничего не выводит. Для того, чтобы обеспечить возможность выполнять что-либо, если условие оказалось ложным, мы используем ключевое слово else: language = input('Какой язык программирования мы изучаем?')
if language == 'Python':
print('Верно! Мы изучаем Python =)')
print('Изучать Python весело!')
else:
print('Мы это не изучаем.')

В новой программе мы обрабатываем сразу два случая: если условие истинно (пользователь ввел «Python»), и если условие ложно (пользователь ввел что угодно, кроме «Python»).

Отступы

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

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

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

Оператор присваивания (=) присваивает переменным значения: num = 2023
s = 'Hello'

Для проверки двух элементов на равенство Python использует удвоенный знак равно (==). Вот так: if answer == 'Python':

Всего в Python существует 6 операторов сравнения:

  1. if n == 2 - если n равен 2;
  2. if n > 2 - если n больше 2;
  3. if n >= 2 - если n больше либо равен 2;
  4. if n < 2 - если n меньше 2;
  5. if n <= 2 - если n меньше либо равен 2;
  6. if n != 2 - если n не равен 2.

Пример использования: num1 = int(input())
num2 = int(input())

if num1 < num2:
print(num1, 'меньше чем', num2)
if num1 > num2:
print(num1, 'больше чем', num2)
if num1 == num2: # используем двойное равенство
print(num1, 'равно', num2)
if num1 != num2:
print(num1, 'не равно', num2)

Операторы сравнения в Python можно объединять в цепочки (в отличии от большинства других языков программирования, где для этого нужно использовать логические связки), например,
x == y == z или 1 <= number <= 5.
Пример кода, который проверяет, находится ли значение переменной age в диапазоне от 13 до 19: age = int(input())
if 13 <= age <= 19:
print("You're a teenager")

Код, проверяющий равенство трех переменных, может выглядеть так: if x == y == z:
print('Все числа равны')
else:
print('Все числа не равны')

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

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

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

  • Логическое умножение, конъюнкция - and, &;
  • Логическое сложение, дизъюнкция - or, |;
  • Логическое отрицание - not.

Для подготовки к ЕГЭ может потребоваться знание еще двух логических операторов:

  • Эквивалентность - в Python это два знака равно "==";
  • Импликация - в Python это "<="

Предположим, мы написали программу для учеников от двенадцати лет, которые учатся по крайней мере в седьмом классе. Доступ к ней тем, кто младше, надо запретить. Следующий код решает поставленную задачу: age = int(input('Сколько вам лет?: '))
grade = int(input('В каком классе вы учитесь?: '))

if age >= 12 and grade >= 7: # То же самое будет if age >= 12 & grade >= 7:
print('Доступ разрешен.')
else:
print('Доступ запрещен.')

Мы объединили два условия при помощи оператора and. Оно означает, что в этом ветвлении блок кода выполняется только при выполнении обоих условий одновременно! Можно объединить более двух условий одновременно: age = int(input('Сколько вам лет?: '))
grade = int(input('В каком классе вы учитесь?: '))
city = int(input('В каком городе вы живете?: '))

if age >= 12 and grade >= 7 and city == 'Челябинск':
print('Доступ разрешен.')
else:
print('Доступ запрещен.')

Оператор or также применяется для объединения условий. Однако, в отличие от and, для выполнения блока кода достаточно выполнения хотя бы одного из условий: city = int(input('В каком городе вы живете?: '))
if city == 'Челябинск' or city == 'Санкт-Петербург' or city == 'Екатеринбург':
print('Доступ разрешен.')
else:
print('Доступ запрещен.') Доступ будет разрешен в случае, если хотя бы одно из условий выполнится.

Мы можем использовать все логические оператора одновременно или, например, два из них: age = int(input('Сколько вам лет?: '))
grade = int(input('В каком классе вы учитесь?: '))
city = int(input('В каком городе вы живете?: '))

if age >= 12 and grade >= 7 and (city == 'Челябинск' or city == 'Санкт-Петербург' or city == 'Екатеринбург'):
print('Доступ разрешен.')
else:
print('Доступ запрещен.') Такой код проверяет на то, что возраст учеников от двенадцати лет, учатся они по крайней мере в 7-м классе и живут в Челябинске, в Екатеринбурге или в Санкт-Петербурге.

Оператор not позволяет инвертировать (т.е. заменить на противоположный) результат логического выражения. Например, следующий код: age = int(input('Сколько вам лет?: '))

if not (age < 12):
print('Доступ разрешен.')
else:
print('Доступ запрещен.') Полностью эквивалентен коду: age = int(input('Сколько вам лет?: '))

if age >= 12:
print('Доступ разрешен.')
else:
print('Доступ запрещен.') В первом примере мы поместили выражение age < 12 в скобки для того, чтобы было четко видно, что мы применяем оператор not к значению выражения age < 12, а не только к переменной age.

Приоритеты логических операторов

Логические операторы, подобно арифметическим операторам (+, -, *, /), имеют приоритет выполнения. Приоритет выполнения следующий:

  1. В первую очередь выполняется логическое отрицание not;
  2. Далее выполняется логическое умножение and;
  3. Далее выполняется логическое сложение or.
Для явного указания порядка выполнения условных операторов используют скобки.

Вложенный оператор

Внутри условного оператора можно использовать любые инструкции языка Python, в том числе и условный оператор. Получаем вложенное ветвление: после одной развилки в ходе исполнения программы появляется другая развилка. Вот пример: money = int(input()) # считываем количество денег
if money < 10:
print("У тебя маловато денег")
else:
if money > 50:
print("У тебя много денег")
else:
print("У тебя не очень много денег") В данном случае уровень вложенности равен двум, так что программа хорошо читается.

Рассмотрим программу, которая переводит стобалльную оценку в пятибалльную. Для ее реализации нужно воспользоваться вложенным условным оператором: money = int(input('Введите вашу отметку по 100-балльной системе: '))
if grade >= 90:
print(5)
else:
if grade >= 80:
print(4)
else:
if grade >= 70:
print(3)
else:
if grade >= 60:
print(2)
else:
print(1) В этом примере уровень вложенности настолько глубок, что код становится трудно понять. Лучше всего избегать такого глубокого уровня вложения. В Python есть для этого отдельный условный оператор elif (сокращенние от else if)

elif

elif позволяет избегать нам глубоких вложенностей, добавляя в него какие-либо условия, которые выполняются если не выполнено первое if или предыдущее elif, изменим код из последнего примера: money = int(input('Введите вашу отметку по 100-балльной системе: '))

if grade >= 90:
print(5)
elif grade >= 80:
print(4)
elif grade >= 70:
print(3)
elif grade >= 60:
print(2)
else:
print(1)
 Этот код выполняется как предыдущий, но читается проще.

Может показаться, что следующий код будет работать также: money = int(input('Введите вашу отметку по 100-балльной системе: '))

if grade >= 90:
print(5)
if grade >= 80:
print(4)
if grade >= 70:
print(3)
if grade >= 60:
print(2)
else:
print(1)
 Но на самом деле, если мы, например, введем 95 в первую программу, то в консоль выведется 5, а если введем во вторую программу, то в консоле мы увидим:
5
4
3
2

elif проверяет условие только в том случае, если не выполнено условие в первом if или предыдущем elif.

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