Условный оператор python: Условный оператор — Основы Python

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

• Если значение balance равно 0, программа выдаст сообщение оператора elif (Balance is equal to 0, add funds soon).
• Если значение переменной balance – положительное число, она выведет сообщение оператора else (Your balance is 0 or above).
• Если значение переменной balance – отрицательное число, программа отобразит сообщение оператора if (Balance is below 0, add funds now or you will be charged a penalty).

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

Вернёмся к тестовой программе grade.py. Попробуйте переписать её код и распределить оценки в зависимости от количества набранных баллов:

• 90 и больше = А
• 80-89 = B
• 70-79 = C
• 65-69 = D
• 64 и меньше = F

Чтобы написать такой код, нужно использовать одно выражение if, три выражения elif и одно else. Выражение else из предыдущего примера останется без изменений.

. . .
if grade >= 90:
print("A grade")
elif grade >=80:
print("B grade")
elif grade >=70:
print("C grade")
elif grade >= 65:
print("D grade")
else:
print("Failing grade")

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

• Сравнивает значение переменной grade со всеми выражениями. Если значение переменной не отвечает условию выражения, оно переходит к следующему выражению.
• Если значение отвечает условию одного из выражений, оно не передаётся дальше. Оператор выполняет соответствующее действие (в данном случае выводит на экран сообщение об оценке: A grade, B grade и т.д.).
• Если значение переменой не отвечает условиям операторов if и elif, оно переходит к оператору else, который отображает сообщение Failing grade.

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

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

if statement1:              #первичное выражение if
print("true")
if nested_statement:    #вложенное выражение if
print("yes")
else                    #вложенное выражение else
print("no")
else:                       #первичное выражение else


Программа может вернуть такие результаты:

• Если выражение statement1 истинно, программа оценит выражение nested_statement как истинное или ложное. Если вложенное выражение также истинно, она вернёт:

true
yes

• Если statement1 истинно, а nested_statement ложно, программа выведет на экран:

true
no

• Если выражение statement1 ложно, программа не будет оценивать вложенные выражения и выведет:

false

В код можно добавить неограниченное количество вложенных операторов: э

if statement1:                  #первичный if


Рассмотрим вложенные операторы на примере программы grade. py. К примеру, сначала программа может убедиться, что результаты теста можно засчитать (для этого нужно выполнить правильно минимум 65% заданий), а затем уже выставить оценки. Таким образом, если тест провален, программа не будет сверять значение переменной со всеми выражениями, а сразу выведет Failing grade.

. . .
if grade >= 65:
print("Passing grade of:")
if grade >= 90:
print("A")
elif grade >=80:
print("B")
elif grade >=70:
print("C")
elif grade >= 65:
print("D")
else:
print("Failing grade")

К примеру, если значение переменной grade – 92, то первое условие выполнено,  и программа вернёт:

Passing grade of:

Затем она сравнит значение переменной с остальными выражениями. Поскольку в данном случае значение соответствует первому условию (grade >= 90), программа выведет:

А

Попробуйте установить переменной grade значение 60 и посмотрите, как поведёт себя программа. В этом случае первичное выражение if ложно, потому она сразу перейдёт к первичному оператору else и выведет:

Failing grade

Вы можете добавить в программу больше параметров, например, разделить оценки на А+, А, А- и так далее. Такой код будет выглядеть так:

. . .
if grade >= 65:
print("Passing grade of:")
if grade >= 90:
if grade > 96:
print("A+")
elif grade > 93 and grade <= 96:
print("A")
elif grade >= 90:
print("A-")
. . .

Если переменная grade имеет значение 96, то:

• Программа убедится, что значение переменной больше или равно 65 (в данном случае это условие выполняется).
• Выведет на экран Passing grade of:.
• Затем она сравнит значение с условием grade >= 90 (в данном случае оно истинно).
• Программа проверит условие grade > 96 (ложно).
• После этого она убедится, что значение больше 93 и меньше или равно 96 (истинно).
• Программа выведет А.

Вывод команды будет выглядеть так:

Passing grade of:
A

Вложенные операторы if позволяют создать несколько дополнительных уровней кода и расширить его функции.

Заключение

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

Операторы можно комбинировать с помощью операторов and и or и объединять в циклы.

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

Смотреть материал на видео

На этом занятии поговорим об условном операторе. Что это такое? Представьте, что вам нужно вычислить модуль числа, хранящегося в переменной 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.

Видео по теме

#1. Первое знакомство с Python Установка на компьютер

#2. Варианты исполнения команд. Переходим в PyCharm

#3. Переменные, оператор присваивания, функции type и id

#4. Числовые типы, арифметические операции

#5. Математические функции и работа с модулем math

#6. Функции print() и input(). Преобразование строк в числа int() и float()

#7. Логический тип bool. Операторы сравнения и операторы and, or, not

#8. Введение в строки. Базовые операции над строками

#9. Знакомство с индексами и срезами строк

#10. Основные методы строк

#11. Спецсимволы, экранирование символов, row-строки

#12. Форматирование строк: метод format и F-строки

#13. Списки — операторы и функции работы с ними

#14. Срезы списков и сравнение списков

#15. Основные методы списков

#16. Вложенные списки, многомерные списки

#17. Условный оператор if. Конструкция if-else

#18. Вложенные условия и множественный выбор. Конструкция if-elif-else

#19. Тернарный условный оператор. Вложенное тернарное условие

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

#21. Операторы циклов break, continue и else

#22. Оператор цикла for. Функция range()

#23. Примеры работы оператора цикла for. Функция enumerate()

#24. Итератор и итерируемые объекты. Функции iter() и next()

#25. Вложенные циклы. Примеры задач с вложенными циклами

#26. Треугольник Паскаля как пример работы вложенных циклов

#27. Генераторы списков (List comprehensions)

#28. Вложенные генераторы списков

#29. Введение в словари (dict). Базовые операции над словарями

#30. Методы словаря, перебор элементов словаря в цикле

#31. Кортежи (tuple) и их методы

#32. Множества (set) и их методы

#33. Операции над множествами, сравнение множеств

#34. Генераторы множеств и генераторы словарей

#35. Функции: первое знакомство, определение def и их вызов

#36. Оператор return в функциях. Функциональное программирование

#37. Алгоритм Евклида для нахождения НОД

#38. Именованные аргументы. Фактические и формальные параметры

#39. Функции с произвольным числом параметров *args и **kwargs

#40. Операторы * и ** для упаковки и распаковки коллекций

#41. Рекурсивные функции

#42. Анонимные (lambda) функции

#43. Области видимости переменных. Ключевые слова global и nonlocal

#44. Замыкания в Python

#45. Введение в декораторы функций

#46. Декораторы с параметрами. Сохранение свойств декорируемых функций

#47. Импорт стандартных модулей. Команды import и from

#48. Импорт собственных модулей

#49. Установка сторонних модулей (pip install). Пакетная установка

#50. Пакеты (package) в Python. Вложенные пакеты

#51. Функция open. Чтение данных из файла

#52. Исключение FileNotFoundError и менеджер контекста (with) для файлов

#53. Запись данных в файл в текстовом и бинарном режимах

#54. Выражения генераторы

#55. Функция-генератор. Оператор yield

#56. Функция map. Примеры ее использования

#57. Функция filter для отбора значений итерируемых объектов

#58. Функция zip. Примеры использования

#59. Сортировка с помощью метода sort и функции sorted

#60. Аргумент key для сортировки коллекций по ключу

#61. Функции isinstance и type для проверки типов данных

#62. Функции all и any. Примеры их использования

#63. Расширенное представление чисел. Системы счисления

#64. Битовые операции И, ИЛИ, НЕ, XOR. Сдвиговые операторы

#65. Модуль random стандартной библиотеки

#66. Аннотация базовыми типами

#67. Аннотации типов коллекций

#68. Аннотации типов на уровне классов

#69. Конструкция match/case. Первое знакомство

#70. Конструкция match/case с кортежами и списками

#71. Конструкция match/case со словарями и множествами

#72. Конструкция match/case. Примеры и особенности использования

Оператор If-Else Python в одной строке — объяснение тернарного оператора

Однострочные условные операторы в Python? Вот когда их использовать, а когда НЕ использовать

if else Заявление на Python

Пожалуйста, включите JavaScript

if else Заявление на Python

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

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

Не хотите читать? Вместо этого посмотрите мое видео:

Хотите работать специалистом по данным? Может помочь ведение блога по науке о данных:

.

Может ли блог о науке о данных действительно привлечь вас в качестве специалиста по данным?

Абсолютно ничего. Разделение условных операторов на несколько строк кода было традицией на протяжении веков. Большинство языков программирования требуют использования фигурных скобок, и, следовательно, одна строка , если операторы не являются опцией. Другие языки позволяют записывать только простые условные операторы в одну строку.

А еще есть Python. Прежде чем углубиться в операторы If Else в одной строке, давайте сначала сделаем краткий обзор обычных условных выражений.

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

 возраст = 16
если возраст < 18:
    print('Иди домой.')
 

Переменная age в данном случае меньше 18, поэтому Иди домой. выводится на консоль. Вы можете оживить ситуацию, добавив условие else , которое оценивается, если первое условие равно False :

 age = 19
если возраст < 18:
    print('Иди домой.')
еще:
    печать('Добро пожаловать!')
 

На этот раз age больше 18, поэтому Добро пожаловать! выводится на консоль. Наконец, вы можете добавить один или несколько элиф условия. Они используются для захвата промежуточных случаев. Например, вы можете напечатать что-то совершенно другое, если age находится между 16 (включительно) и 18 (исключено):

 age = 17
если возраст < 16:
    print('Иди домой.')
Элиф 16 <= возраст < 18:
    print('Не уверен...')
еще:
    печать('Добро пожаловать!')
 

Переменная age равна 17, что означает, что условие под elif равно True , следовательно, Not sure... выводится на консоль.

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

Тернарный оператор в Python

Тернарный оператор существует в некоторых языках программирования и позволяет сократить простой блок If-Else. Он принимает 3 или более операндов:

1. Значение, если оно истинно — значение, которое возвращается, если условие оценивается как Истина.
2. Условие — логическое условие, которое должно быть выполнено, чтобы вернуть значение, если оно истинно.
3. Значение, если ложно — Значение, которое возвращается, если условие оценивается как ложное. В коде это будет выглядеть так:

 а если условие иначе б
 

Вы даже можете написать логику else-if в тернарном операторе Python. В этом случае синтаксис немного меняется:

 а если условие1 иначе б если условие2 иначе в
 

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

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

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

Вот как преобразовать наш двухстрочный оператор if в однострочный условный оператор:

 возраст = 17
если возраст < 18: print('Иди домой.')
 

Как и раньше, возраст меньше 18 лет, поэтому Иди домой. печатается.

Что делать, если вы хотите напечатать три строки вместо одной? Как было сказано ранее, лучше всего поместить код внутри функции:

 def print_stuff():
    print('Иди домой. ')
    Распечатать('.......')
    печать('Сейчас!')
    
возраст = 17
    
если возраст < 18: print_stuff()
 

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

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

Теперь мы можем в полной мере использовать возможности тернарного оператора Python. Фрагмент кода ниже хранит Иди домой. в новую переменную результат если возраст меньше 18 или Добро пожаловать! иначе:

 возраст = 19
результат = 'Иди домой.' если возраст < 18 еще 'Добро пожаловать!'
печать (результат)
 

Как вы уже догадались, Добро пожаловать! выводится на консоль, так как возраст установлен на 19. Если вы хотите напечатать несколько строк или обработать более сложную логику, оберните все, что вы хотите выполнить, в функцию — как и раньше.

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

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

Вам должно хватить двух условий в одной строке, так как код по-прежнему легко читается. В следующем примере печатается Go home. , если возраст меньше 16 лет, Not Sure... , если возраст находится в диапазоне от 16 (включено) до 18 (исключено), и Добро пожаловать в противном случае:

 возраст = 17
результат = 'Иди домой.' если возраст < 16, иначе «Не уверен...», если 16 <= возраст < 18, иначе «Добро пожаловать»
исход
 

Вы увидите Не уверен... напечатано на консоли, с age установлен на 17. То, что раньше занимало шесть строк кода, теперь занимает только одну. Аккуратное улучшение, и код по-прежнему легко читать и поддерживать.

Что еще можно сделать с однострочными операторами if? Ну, много. Далее мы рассмотрим однострочные условные операторы для операций со списками.

Пример: однострочные условия для операций со списками

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

Как написать IF и FOR в одну строку

Вам нужно будет внести два изменения в тернарный оператор:

Заключите всю строку кода в квадратные скобки [] Добавьте код итерации списка (для элемента в массиве) после финала else Вот как выглядит общий синтаксис:

 [a if условие else b для элемента в массиве]
 

Это не так сложно, но давайте докажем суть дела на примере. Следующий фрагмент кода выводит + , если текущий номер диапазона больше 5 и 9.0011 - иначе. Числа варьируются от 1 до 10 (включительно):

 ['+', если i > 5, иначе '-' для i в диапазоне (1, 11)]
 

Изображение 1 — If и For в одной строке в Python (изображение автора)

Давайте теперь рассмотрим дополнительный пример из реальной жизни.

Пример: Ученик сдал экзамен?

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

 студентов = [
    {'имя': 'Боб', 'счет': 42},
    {'имя': 'Келли', 'оценка': 58},
    {'имя': 'Остин', 'оценка': 99},
    {'имя': 'Кайл', 'счет': 31}
]
 

Мы хотим вывести, что студент сдал экзамен, если он набрал 50 баллов и выше. Если оценка была ниже 50 баллов, мы хотим вывести, что студент провалил экзамен.

В традиционном синтаксисе Python мы вручную перебираем каждого ученика в списке и проверяем, превышает ли его оценка 50:

 results = []
для студента в студентах:
    если студент['оценка'] > 50:
        results. append(f"{студент['имя']} сдал экзамен!")
    еще:
        results.append(f"{студент['имя']} не сдал экзамен!")
        
печать (результаты)
 

Изображение 2. Итерация списка с традиционным синтаксисом Python (изображение автора)

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

 результатов = [f"{студент['имя']} сдал экзамен!" if student['score'] > 50 else f"{student['name']} не сдал экзамен!" для студента в студентах]
печать (результаты)
 

Изображение 3 — Однострочное условное выражение и цикл с Python (изображение автора)

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

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

Будьте осторожны с однострочными условиями

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

Приведенный ниже фрагмент кода проверяет условие для каждой возможной оценки (1–5) с окончательным условием else, фиксирующим неверный ввод. Для написания условий требуется 12 строк кода, но весь фрагмент чрезвычайно удобочитаем:

 оценка = 1
если класс == 1:
    print('Оценка = 1')
Элиф класс == 2:
    print('Оценка = 2')
Элиф класс == 3:
    print('Оценка = 3')
Элиф класс == 4:
    print('Оценка = 4')
Элиф класс == 5:
    print('Оценка = 5')
еще:
    print('Невозможная оценка!')
 

Как и ожидалось, вы увидите, что Grade = 1 выводится на консоль, но это не то, что нас интересует. Мы хотим перевести приведенный выше фрагмент в однострочный оператор if-else с тернарным оператором.

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

 оценка = 1
результат = «Оценка = 1», если оценка == 1, иначе «Оценка = 2», если оценка == 2, иначе «Оценка = 3», если оценка == 3, иначе «Оценка = 4», если оценка == 4, иначе «Оценка = 5». 'если оценка == 5 иначе 'Невозможная оценка'
печать (результат)
 

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

Запомните: Тернарный оператор с более чем двумя условиями — это просто кошмар для написания и отладки.

Заключение

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

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

Более понятный способ написания длинных условных выражений — использование структурного сопоставления с образцом — новая функция, представленная в Python 3.10. Он привносит любимый оператор switch в Python для дополнительной удобочитаемости и скорости разработки.

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

Условные выражения в Python | note.nkmk.me

В Python есть условные выражения (иногда называемые «тернарными операторами»). Вы можете написать операцию типа if в одну строку с условными выражениями.

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

В этой статье описывается следующее содержимое.

• Основы условных выражений
• if ... elif ... else ... условными выражениями
• Понимание списков и условные выражения
• Лямбда-выражения и условные выражения

Инструкцию if см. в следующей статье.

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

Основы условных выражений

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

 X если условие еще Y
 

Сначала оценивается условие . Если условие равно True , вычисляется X и возвращается его значение, а если условие равно False , оценивается Y и возвращается его значение.

Если вы хотите переключить значение по условию, просто опишите каждое значение как оно есть.

 а = 1
результат = 'четный', если % 2 == 0 иначе 'нечетный'
печать (результат)
# странный
а = 2
результат = 'четный', если % 2 == 0 иначе 'нечетный'
печать (результат)
# даже
 

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

Если вы хотите переключить операцию по условиям, опишите каждое выражение.

 а = 1
результат = a * 2, если % 2 == 0 иначе a * 3
печать (результат)
№ 3
а = 2
результат = a * 2, если % 2 == 0 иначе a * 3
печать (результат)
№ 4
 

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

Выражение, которое не возвращает значение (выражение, возвращающее None ), также допустимо. Любое выражение оценивается и выполняется в зависимости от условия.

 а = 1
print('четный') if % 2 == 0 else print('нечетный')
# странный
 

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

Приведенный выше пример эквивалентен следующему коду, написанному в операторе if .

 а = 1
если % 2 == 0:
    распечатать ('даже')
еще:
    печать ('нечетный')
# странный
 

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

Вы также можете объединить несколько условных выражений с и и или .

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

 а = -2
результат = 'отрицательный и четный', если < 0 и % 2 == 0, иначе 'положительный или нечетный'
печать (результат)
# отрицательное и четное
а = -1
результат = 'отрицательный и четный', если < 0 и % 2 == 0, иначе 'положительный или нечетный'
печать (результат)
# положительный или нечетный
 

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

Комбинируя условные выражения, вы можете написать операцию, подобную if ... elif ... else . .. в одну строку.

 X, если условие1, иначе Y, если условие2, иначе Z
 

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

 а = 2
результат = «отрицательный», если a < 0, иначе «положительный», если a > 0, иначе «ноль»
печать (результат)
# положительный
а = 0
результат = «отрицательный», если a < 0, иначе «положительный», если a > 0, иначе «ноль»
печать (результат)
# нуль
а = -2
результат = «отрицательный», если a < 0, иначе «положительный», если a > 0, иначе «ноль»
печать (результат)
# минус
 

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

Возможны следующие две интерпретации, но они обрабатываются как первая (1).

 1. X, если условие1 иначе (Y, если условие2 иначе Z)
2. (X, если условие1, иначе Y) если условие2, иначе Z
 

В приведенном ниже примере кода первое выражение считается вторым выражением, а не третьим.

 а = -2
результат = «отрицательный», если a < 0, иначе «положительный», если a > 0, иначе «ноль»
печать (результат)
# минус
результат = «отрицательный», если a < 0, иначе («положительный», если a > 0, иначе «ноль»)
печать (результат)
# минус
результат = («отрицательный», если a < 0, иначе «положительный»), если a > 0, иначе «ноль»
печать (результат)
# нуль
 

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

Генерация списков и условные выражения

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

 l = ['четный', если i % 2 == 0 иначе i для i в диапазоне (10)]
печать (л)
# ['четный', 1, 'четный', 3, 'четный', 5, 'четный', 7, 'четный', 9]
 

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

 l = [i * 10 if i % 2 == 0 else i для i в диапазоне (10)]
печать (л)
# [0, 1, 20, 3, 40, 5, 60, 7, 80, 9]
 

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

Дополнительные сведения о включении списков см.