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

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

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

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

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

или так:

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

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

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

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

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

a > b

Истинно, если a больше b

a < b

Истинно, если a меньше b

a >= b

Истинно, если a больше или равно b

a <= b

Истинно, если a меньше или равно b

a == b

Истинно, если a равно b (обратите внимание, для сравнения используется двойной знак равенства)

a != b

Истинно, если a не равно b

Все эти операторы при сравнении возвращают булевое значение: 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.

Видео по теме