Python if elif: Python IF…ELIF…ELSE Statements

Проверка условий, конструкция if/elif/else в Python.

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

>>> x = int(input("Please enter an integer: "))
# Please enter an integer: 42
>>> if x < 0:
...     x = 0
...     print('Negative changed to zero')
... elif x == 0:
...     print('Zero')
... elif x == 1:
...     print('Single')
... else:
...     print('More')
# More

Ключевое слово elif является сокращением от else if. Инструкции elif и else могут отсутствовать и не являются обязательными. Инструкция elif может повторяться сколько угодно раз if/elif/else. Такая последовательность инструкций elif является заменой для конструкции

switch или case, которые есть в других языках программирования.

Составная инструкция if, elif и else обеспечивает условное выполнение блоков инструкций.
Она имеет следующий синтаксис:

if выражение:
    блок кода
elif выражение:
    блок кода
elif выражение:
    блок кода
...
...
else:
    блок кода

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

False), выполняется блок кода инструкции else, если он присутствует.

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

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

Это наиболее ясная и соответствующая духу Python форма кода.

Примеры

if/elif/else конструкций

Использование None в конструкции if:

a = None
if a is not None:
    print('a НЕ равно None')
else:
    print('a равно None')

Использование False и True в конструкции if:

bul = False
if bul:
    print('bul = True')
else:
    print('bul = False')

Использование integer числа 0 в конструкции if:

number = 0
if number:
    print('number не равно 0')
else:
    print('number = 0')

Использование числовых сравнений в конструкции if:

a = 10
b = 20
if  a != b and a > b:
    print('a не равно b и a больше b')
else:
    print('a не равно b и a меньше b')

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

a = 15
b = 3
if  a != b 
    if a > b:
        print('a больше b')
    else:
        print('a меньше b')
else:
    print('a равно b')

Проверка наличия слова в строке str с помощью конструкции if:

string1 = 'Привет мир'
string2 = 'мир'
if string2 in string1:
    print('Слово "мир" присутствует в строке "Привет мир"')
else:
    print('Слово "мир" отсутствует в строке "Привет мир"')

Проверка вхождения элемента в список list с помощью конструкции if:

a = 'bc'
lst = ['ac', 'bc', 0, 1, 3, 'abc']
if a in lst:
    print('Значение "bc" входит в список', lst)
else:
    print('Значение "bc" не входит в список', lst)

Проверка вхождения элемента в кортеж tuple с помощью конструкции if:

a = 'bc'
tpl = ('ac', 'bc', 0, 1, 3, 'abc')
if a in tpl:
    print('Значение "bc" входит в кортеж', tpl)
else:
    print('Значение "bc" не входит в кортеж', tpl)

Проверка вхождения элемента в множество set с помощью конструкции if:

a = 'bc'
set_ = {'ac', 'bc', 0, 1, 3, 'abc'}
if a in set_:
    print('Значение "bc" входит в множество', set_)
else:
    print('Значение "bc" не входит в множество', set_)

Проверка наличия ключа key в словаре dict с помощью конструкции if:

key = 'bc'
dct = {'ac':None, 'bc':False, '0':0, '1':3, '3':1, 'abc':True}
if key in dct:
    print('Ключ "bc" присутствует в словаре', dct)
else:
    print('Ключ "bc" отсутствует в словаре', dct)

Условный оператор if – elif – else в Python

Условный оператор — это оператор, который позволяет выполнять определенный участок кода, если указанное условие истинно (т. е. равно True).

Синтаксис оператора if

if (условное выражение):
    код
    код

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

Как работает условный оператор

Разберем работу if на примере:

a = 1
if a > 0:
    print('Условие верно!')
#Условие верно!

Мы присвоили переменной a единицу, далее создали условие:
Если a больше нуля, то выполняем инструкции, т.е. печатаем Условие верно!.
Т.к. 1 больше 0, значим условие истинно и равно True, то мы увидели выполнение функции print.

Если же условие не будет выполняться и вернется False

, то все инструкции внутри этого блока пропускаются:

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

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

Для этого случая и используется необязательный оператор else:

a = 1
if a < 0:
    print('Отрицательное число')
else:
    print('Положительное число')
#Положительное число

Работает эта конструкция так:
Если выражение истинно, выполняем инструкции, иначе — выполняем другие инструкции.

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

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

a = 1
if a < 0:
    print('Отрицательное число')
elif a > 0:
    print('Положительное число')
else:
    print('Ноль')
#Положительное число

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

else.

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

Конструкция if — else в одну строку

Python позволяет записывать условия и в одну строку, в таком формате:

<инструкции если True> if <условие> else <инструкции если False>

Возьмем код, записанный стандартным способом:

a = 1
if a < 0:
    print('Отрицательное число')
else:
    print('Положительное число')
#Положительное число

И запишем его в одну строку:

a = 1
print('Отрицательное число') if a < 0 else print('Положительное число')
#Положительное число

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

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

Можно без проблем размещать одни условия внутри других. Ограничений по этому поводу нет.

Для примера напишем код, который будет переводить 100 бальную оценку в 5 бальную:

points = 75
if points >= 90:
    print(5)
else:
    if points >= 80:
        print(4)
    else:
        if points >= 70: 
            print(3)
        else:
            if points >= 60:
                print(2)
            else:
                print(1)
#3

Как видно, не очень удобно читать, гораздо проще так:

points = 75
if points >= 90:
    print(5)
elif points >= 80:
    print(4)
elif points >= 70:
    print(3)
elif points >= 60:
    print(2)
else:
    print(1)
#3

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

В Python есть 6 основных операторов сравнения.

Выражение	Описание
if x > 5	если x больше 5
if x < 5	если x меньше 5
if x >= 5	если x больше либо равен 5
if x <= 5	если x меньше либо равен 5
if x == 5	если x равен 5
if x != 5	если x не равен 5

x = 5
y = 5
if x < y:
    print(f'{x} меньше чем {y}')
if x > y:
    print(f'{x} больше чем {y}')
if x == y:                      
    print(f'{x} равно {y}')
if x != y:
    print(f'{x} не равно {y}')
#5 равно 5

Цепочки сравнений

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

• 1 <= x <= 10 (х больше или равно 1 и меньше или равно 10, т. е. находится в промежутке от 1 до 10)
• a == b == c (все три переменные равны друг другу)

x = 5
if 1 <= x <= 10:
    print('Верно')
#Верно

a = 5
b = 5
c = 5
if a == b == c:
    print('числа равны')
#числа равны

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

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

• and — логическое ‘И’;
• or — логическое ‘ИЛИ’;
• not — логическое ‘НЕ’.

Рассмотрим, как работает каждый логический оператор на примерах.

Оператор and

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

Таблица истинности для оператора and:

a	b	a and b
False	False	False
False	True	False
True	False	False
True	True	True

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

Для того чтобы определить четное число используем остаток от деления a % 2, если остаток от деления равен 0, то число четное.
Второе условие a > 10 будет просто проверять, что наше число больше 10.
И объединим эти два условия с помощью оператора and.

Теперь, мы получим ответ ‘YES’, если оба условия будут True, если хоть одно из двух условий будет False, то мы получим ответ ‘NO’:

a = 12
if a % 2 == 0 and a > 10:
    print('YES')
else:
    print('NO')
#YES

a = 8
if a % 2 == 0 and a > 10:
    print('YES')
else:
    print('NO')
#NO

a = 223
if a % 2 == 0 and a > 10:
    print('YES')
else:
    print('NO')
#NO

Стоит заметить, что количество операторов and может быть любым.

Оператор or

Служит для объединения условий, означает, что инструкции будут выполняться, если хотя бы одно из условий будет истинно.

Таблица истинности для оператора or:

a	b	a or b
False	False	False
False	True	True
True	False	True
True	True	True

Напишем код, который проверят переменную и если она равна 10 или 20, то выводит соответствующее сообщение.

a = 20
if a == 10 or a == 20:
    print('YES')
else:
    print('NO')
#YES

a = 10
if a == 10 or a == 20:
    print('YES')
else:
    print('NO')
#YES

a = 1
if a == 10 or a == 20:
    print('YES')
else:
    print('NO')
#NO

Оператор not

Оператор not позволяет заменить на противоположный результат логического выражения.

Таблица истинности для оператора not:

a	not a
False	True
True	False

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

passw = 'jtu4i5ud3f4wg43w'
if not (len(passw) < 10):
    print('YES')
else:
    print('NO')
#YES

Условие в этом случае можно прочитать так: если длина пароля не меньше 10.

Этот код будет делать то же самое:

passw = 'jtu4i5ud3f4wg43w'
if len(passw) > 10:
    print('YES')
else:
    print('NO')
#YES

Здесь условие читается так: если длина пароля больше 10.

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

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

• в первую очередь выполняется логическое ‘НЕ’ — not;
• далее выполняется логическое ‘И’ — and;
• далее выполняется логическое ‘ИЛИ’ — or.

Если нужно изменить очередность, то нужно использовать скобки, так же, как и с арифметическими операциями.

if, else, условия elif (с примерами)

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

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

 если [логическое выражение]:
    заявление1
    заявление2
    ...
    заявление N
 

Любое логическое выражение, вычисляющее значение True или False , появляется после ключевого слова if . Используйте символ : и нажмите Enter после выражения, чтобы начать блок с увеличенным отступом. Один или несколько операторов, написанных с одинаковым уровнем отступа, будут выполнены , если логическое выражение оценивается как True .

Чтобы закончить блок, уменьшите отступ. Последующие операторы после блока будут выполняться из , если условие . В следующем примере демонстрируется условие , если .

 цена = 50
если цена < 100:
    print("цена меньше 100")
 

 цена меньше 100 

В приведенном выше примере выражение price < 100 оценивается как True , поэтому блок будет выполнен. Блок if начинается с новой строки после : и всех операторов под , если условие начинается с увеличенного отступа, пробела или табуляции. Выше блок if содержит только один оператор. В следующем примере есть несколько операторов в условии if.

 цена = 50
количество = 5
если цена*количество < 500:
    print("цена*количество меньше 500")
    напечатать("цена = ", цена)
    print("количество = ", количество)
 

 цена*количество меньше 500
цена = 50
количество = 5 

Выше условие if содержит несколько операторов с одинаковым отступом. Если все операторы не находятся в одном и том же отступе, будь то пробел или табуляция, тогда он поднимет 9IdentationError: неожиданный отступ

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

 цена = 50
количество = 5
если цена*количество < 100:
    print("цена меньше 500")
    напечатать("цена = ", цена)
    print("количество = ", количество)
print("Нет, если блок выполнен.")
 

 Нет, если блок выполнен.
 

В следующем примере показано несколько условий if.

 цена = 100
если цена > 100:
 print("цена больше 100")
если цена == 100:
  print("цена 100")
если цена < 100:
    print("цена меньше 100")
 

 цена 100 

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

Рекомендуется использовать 4 пробела или табуляцию в качестве уровня отступа по умолчанию для большей удобочитаемости.

иначе Условие

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

 если [логическое выражение]:
    заявление1
    заявление2
    ...
    заявление N
еще:
    заявление1
    заявление2
    ...
    заявление N
 

Как упоминалось ранее, блок с отступом начинается после 9.0005 : символ после логического выражения. Он будет выполнен, когда условие будет True . У нас есть еще один блок, который должен выполняться, когда условие if равно False . Сначала завершите блок if с помощью backspace и напишите else , добавьте символ : перед новым блоком, чтобы начать его, и добавьте необходимые операторы в блок.

 цена = 50
если цена >= 100:
    print("цена больше 100")
еще:
    print("цена меньше 100")
 

 цена меньше 100 

В приведенном выше примере условие if price >= 100 равно False , поэтому блок else будет выполнен. Блок else также может содержать несколько операторов с одинаковым отступом; в противном случае будет вызвана ошибка IndentationError .

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

Элиф Состояние

Использовать условие elif используется для включения нескольких условных выражений после условия if или между условиями if и else .

 если [логическое выражение]:
    [заявления]
элиф [логическое выражение]:
    [заявления]
элиф [логическое выражение]:
    [заявления]
еще:
    [заявления]
 

Блок elif выполняется, если указанное условие оценивается как True .

 цена = 100
если цена > 100:
    print("цена больше 100")
Элиф цена == 100:
    print("цена 100")
Элиф цена < 100:
    print("цена меньше 100")
 

 цена 100 

В приведенном выше примере условия elif применяются после условия if . Python оценит условие , если , и если он оценит False , тогда он оценит блоки elif и выполнит elif блок, выражение которого оценивается как True . Если несколько условий elif становятся True , то будет выполнен первый блок elif .

В следующем примере демонстрируются условия if, elif и else.

 цена = 50
если цена > 100:
    print("цена больше 100")
Элиф цена == 100:
    print("цена 100")
иначе цена < 100:
    print("цена меньше 100")
 

 цена меньше 100 9IdentationError: unindent не соответствует ни одному внешнему уровню отступа
 

Вложенные условия if, elif, else

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

 цена = 50
количество = 5
сумма = цена*количество
если количество > 100:
    если сумма > 500:
        print("Сумма больше 500")
    еще:
        если сумма < 500 и сумма > 400:
            print("Сумма")
        elif сумма < 500 и сумма > 300:
            print("Сумма от 300 до 500")
        еще:
            print("Сумма от 200 до 500")
сумма Элиф == 100:
    print("Сумма 100")
еще:
    print("Сумма меньше 100")
 

 Сумма от 200 до 500 

Операторы if Python (if, elif, else)

В этой статье объясняется условное ветвление в Python с использованием операторов if ( if ... elif ... else ... ).

Содержание

• операторы if в Python: if, elif, else
  • if
  • если... иначе...
  • если... элиф...
  • если... элиф... иначе.. .
• Выражения условий в операторах if
  • Выражения, возвращающие логическое значение (операторы сравнения, оператор in и т. д.)
  • Небулевые случаи
• Несколько условий в операторах if: и, или
• Отрицание в операторах if: не
• Как написать условное выражение в несколько строк

Python также предоставляет тернарный оператор для написания однострочного условного ветвления. Дополнительные сведения см. в следующей статье:

• Условные выражения в Python

Базовая структура оператора if следующая. Блоки выражаются с помощью отступа (обычно четыре пробела).

 если выражение 1:
    Выполняется, когда выражение 1 истинно
Элиф выражение 2:
    Выполняется, когда выражение 1 равно False, а выражение 2 равно True
Элиф выражение 3:
    Выполняется, когда выражения 1 и 2 равны False, а выражение 3 равно True
...
еще:
    Выполняется, когда все выражения имеют значение False
 

Ниже приведены некоторые примеры. Используется оператор def для определения функций и f-строки для встраивания переменных в строки.

• Определение и вызов функций в Python (def, return)
• Как использовать f-строки в Python

, если

При использовании только , если , указанный процесс выполняется, если условие оценивается как True , и ничего не происходит, если оно оценивается как False .

 по определению if_only(n):
    если п > 0:
        print(f'{n} положительное')
если_только (100)
# 100 положительный
если_только (-100)
 

источник: if_basic.py

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

if ... else ...

Предложение else позволяет добавить процесс, когда выражение условия оценивается как False .

 по определению if_else(n):
    если п > 0:
        print(f'{n} положительное')
    еще:
        print(f'{n} отрицательное значение или ноль')
если_иначе(100)
# 100 положительный
если_еще (-100)
# -100 отрицательное значение или ноль
 

источник: if_basic.py

if ... elif ...

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

Условия проверяются в порядке сверху, и выполняется блок, связанный с первым условием, которое определено как True . Если все условия равны False , ничего не делается.

 по определению if_elif(n):
    если п > 0:
        print(f'{n} положительное')
    Элиф п == 0:
        print(f'{n} равен нулю')
    Элиф п == -1:
        print(f'{n} минус один')
if_elif(100)
# 100 положительный
если_элиф (0)
# 0 равно нулю
если_элиф (-1)
# -1 минус один
if_elif(-100)
 

источник: if_basic. py

Как указано ниже, вы также можете использовать и и или для указания нескольких условий в одном выражении.

если... элиф... иначе...

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

Процесс в предложении else выполняется, когда все предыдущие условия оцениваются как False .

 по определению if_elif_else(n):
    если п > 0:
        print(f'{n} положительное')
    Элиф п == 0:
        print(f'{n} равен нулю')
    еще:
        print(f'{n} отрицательное')
if_elif_else(100)
# 100 положительный
if_elif_else (0)
# 0 равно нулю
if_elif_else(-100)
# -100 отрицательно
 

источник: if_basic.py

Выражения, возвращающие

bool (операторы сравнения, оператор in и т. д.) , False ) для выражений условий в операторах if, таких как операторы сравнения.

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

• 6. Выражения — Документация по Python 3.11.2

.

Оператор	Результат
х < у	True , если x меньше y
х <= у	True , если x меньше или равно y
х > у	True , если x больше y
х >= у	True , если x больше или равно y
х == у	True , если x равно y
х != у	True , если x не равно y
х есть у	True , если x и и — это один и тот же объект
х не у	True , если x и y не являются одним и тем же объектом

См. в следующей статье разницу между == и .

• Разница между операторами == и is в Python

В Python можно объединить несколько операторов сравнения, например a < x < b .

• Сцепленное сравнение (a < x < b) в Python

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

• Оператор in в Python (для списка, строки, словаря и т. д.)

 по умолчанию if_in(s):
    если 'а' в s:
        print(f'"a" находится в "{s}"')
    еще:
        print(f'"a" НЕ находится в "{s}"')
if_in('яблоко')
# "а" в "яблоке"
if_in('вишня')
# "a" НЕ находится в "cherry"
 

источник: if_basic.py

Вы также можете указать методы или функции, которые возвращают bool в качестве условия в операторе if . Например, метод startwith() проверяет, начинается ли строка с определенной подстроки.

• Сравнение строк в Python (точное/частичное совпадение и т. д.)

 по умолчанию if_startswith(s):
    если s.startswith('a'):
        print(f'"{s}" начинается с "a"')
    еще:
        print(f'"{s}" НЕ начинается с "a"')
if_startswith("яблоко")
# "яблоко" начинается с "а"
if_startswith("банан")
# "банан" НЕ начинается с "а"
 

источник: if_basic.py

Non-

bool case

В операторе if можно использовать неbool значения, такие как числа или списки, а также выражения, которые возвращают эти значения в качестве условий.

 если 100:
    распечатать('Верно')
# Истинный
если [0, 1, 2]:
    распечатать('Верно')
# Истинный
 

источник: if_basic.py

В Python считаются следующие объекты False :

• константы, определенные как ложные: Нет и Ложь .
• ноль любого числового типа: 0 , 0.0 , 0j , Decimal(0) , Fraction(0, 1)
• пустых последовательностей и коллекций: '' , () , [] , {} , set() , range(0) Встроенные типы — проверка истинности — документация по Python 3.11.2

Числовые значения, представляющие нуль и пустые строки и списки, считаются False , а все остальные значения считаются True .

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

 по определению if_is_empty(l):
    если я:
        print(f'{l} НЕ пусто')
    еще:
        print(f'{l} пусто')
if_is_empty([0, 1, 2])
# [0, 1, 2] НЕ пусто
if_is_пусто([])
# [] пусто
 

источник: if_basic.py

Обратите внимание, что непустые строки считаются True , поэтому строка 'False' также считается True . Чтобы преобразовать определенные строки, такие как «True» или «False» в 1 или 0 , используйте функцию strtobool() из модуля distutils.util . Дополнительные сведения см. в следующей статье:

• Преобразование bool (True, False) и других типов друг в друга в Python

Чтобы указать И или ИЛИ нескольких условий в операторе if, используйте и и или .

 по определению if_and(n):
    если n > 0 и n % 2 == 0:
        print(f'{n} положительно-четный')
    еще:
        print(f'{n} НЕ является положительно-четным')
если_и(10)
№ 10 положительно-четный
если_и(5)
# 5 НЕ положительный-четный
если_и(-10)
# -10 НЕ является положительно-четным
 

источник: if_basic.py

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

 по определению if_and_or(n):
    если n > 0 и n % 2 == 0 или n == 0:
        print(f'{n} положительно-четный или нулевой')
    еще:
        print(f'{n} НЕ является положительно-четным или нулевым')
если_и_или(10)
# 10 положительно-четное или ноль
если_и_или(5)
# 5 НЕ является положительно-четным или нулевым
если_и_или(0)
# 0 положительно-четный или ноль
 

источник: if_basic. py

Порядок приоритета логических операторов: не > и > или (причем не является наивысшим). Дополнительные сведения см. в следующей статье:

• Булевы операторы в Python (и или не)

Чтобы указать НЕ в условии оператора if, используйте вместо .

 по умолчанию if_not(s):
    если не s.startswith('a'):
        print(f'"{s}" НЕ начинается с "a"')
    еще:
        print(f'"{s}" начинается с "a"')
если_не ("яблоко")
# "яблоко" начинается с "а"
if_not("банан")
# "банан" НЕ начинается с "а"
 

источник: if_basic.py

Однако для таких операторов, как == или > , рекомендуется использовать их противоположные аналоги, например != или <= , а не not.

Как записать условное выражение в несколько строк

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

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

Следующие три функции эквивалентны, с той лишь разницей, что это стиль письма.

 по определению if_no_newline():
    если too_long_name_function_1() и too_long_name_function_2() и too_long_name_function_3():
        распечатать('Верно')
    еще:
        печать('Ложь')
 

источник: if_basic.py

 по определению if_backslash():
    если слишком_длинное_имя_функция_1() \
       и too_long_name_function_2() \
       и too_long_name_function_3():
        распечатать('Верно')
    еще:
        печать('Ложь')
 

источник: if_basic.py

 def if_parentheses():
    если (
        too_long_name_function_1()
        и too_long_name_function_2()
        и too_long_name_function_3()
    ):
        распечатать('Верно')
    еще:
        печать('Ложь')
 

источник: if_basic.