Да, это было добавлено в версии 2.5. Синтаксис выражения:

a if condition else b

Сначала оценивается condition, затем оценивается и возвращается ровно одно из a или b на основе Логическое значение condition. Если condition оценивается как True, тогда a оценивается и возвращается, но b игнорируется, или иначе, когда b оценивается и возвращается, но a игнорируется.

Это допускает короткое замыкание, потому что, когда condition истинно, оценивается только a, а b не оценивается вообще, но когда condition ложно, оценивается только b, а a не оценивается вообще.

Например:

>>> 'true' if True else 'false'
'true'
>>> 'true' if False else 'false'
'false'

Обратите внимание, что условные выражения - это выражение, а не инструкция. Это означает, что вы не можете использовать операторы присваивания, pass или другие операторы в условном выражении:

>>> pass if False else x = 3
  File "<stdin>", line 1
    pass if False else x = 3
          ^
SyntaxError: invalid syntax

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

x = a if True else b

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

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

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

• Порядок аргументов отличается от порядка аргументов классического тернарного оператора condition ? a : b из многих других языков (таких как C, C ++, Go, Perl, Ruby, Java, Javascript и т. Д.), Что может привести к ошибкам, когда люди, незнакомые с Python удивительное поведение использовать его (они могут изменить порядок аргументов).
• Некоторые находят его громоздким, поскольку он идет вразрез с обычным течением мысли (сначала нужно думать о состоянии, а затем о последствиях).
• Стилистические причины. (Хотя 'inline if' может быть действительно полезным и сделать ваш сценарий более лаконичным, он действительно усложняет ваш код)

Если у вас возникли проблемы с запоминанием порядка, помните, что при чтении вслух вы (почти) говорите то, что имеете в виду. Например, x = 4 if b > 8 else 9 читается вслух как x will be 4 if b is greater than 8 otherwise 9.

Официальная документация:

• Условные выражения
• Есть ли эквивалент тернарного оператора C"?: "?

Вы можете индексировать кортеж:

(falseValue, trueValue)[test]

test должен возвращать True или False.
Возможно, безопаснее всегда реализовывать его как:

(falseValue, trueValue)[test == True]

или вы можете использовать встроенный bool() для обеспечить значение Boolean:

(falseValue, trueValue)[bool(<expression>)]

Для версий до 2.5 есть хитрость:

[expression] and [on_true] or [on_false]

Он может дать неверные результаты, если on_true имеет ложное логическое значение. ¹
Хотя он имеет преимущество оценки выражений слева направо, что, на мой взгляд, яснее.

_{1. Есть ли эквивалент C "?:" Тернарный оператор?}

Из документации:

Условные выражения (иногда называемые «тернарным оператором») имеют самый низкий приоритет среди всех операций Python.

Выражение x if C else y сначала оценивает условие, C (не x); если C истинно, вычисляется x и возвращается его значение; в противном случае вычисляется y и возвращается его значение.

Дополнительные сведения см. В PEP 308. об условных выражениях.

Новое с версии 2.5.

Оператор условного выражения в Python был добавлен в 2006 году как часть предложения по усовершенствованию Python 308 < / а>. Его форма отличается от обычного оператора ?: и это:

<expression1> if <condition> else <expression2>

if <condition>: <expression1> else: <expression2>

result = x if a > b else y

result = (lambda:y, lambda:x)[a > b]()

где операнды вычисляются лениво.

Другой способ - индексировать кортеж (что не согласуется с условным оператором большинства других языков):

result = (y, x)[a > b]

или явно построенный словарь:

result = {True: x, False: y}[a > b]

Другой (менее надежный), но более простой способ - использовать операторы and и or:

result = (a > b) and x or y

однако это не сработает, если x будет False.

Возможный обходной путь - создать списки или кортежи x и y, как показано ниже:

result = ((a > b) and [x] or [y])[0]

or:

result = ((a > b) and (x,) or (y,))[0]

Если вы работаете со словарями, вместо тернарного условного выражения вы можете воспользоваться _ 17_, например:

shell = os.environ.get('SHELL', "/bin/sh")

^{Источник: ?: в Python в Википедии}

К сожалению,

(falseValue, trueValue)[test]

решение не имеет поведения при коротком замыкании; таким образом, оба falseValue и trueValue оцениваются независимо от условия. Это могло быть неоптимальным или даже ошибочным (т.е. как trueValue, так и falseValue могли быть методами и иметь побочные эффекты).

Одним из решений этого было бы

(lambda: falseValue, lambda: trueValue)[test]()

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

Итак, история гласит: выбор между 3 упомянутыми решениями - это компромисс между наличием функции короткого замыкания, использованием как минимум ython 2.5 (IMHO, больше не проблема) и отсутствием склонности к "trueValue-Assessment-to-false" ошибки.

Тернарный оператор на разных языках программирования

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

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

var a = true ? 1 : 0;
# 1
var b = false ? 1 : 0;
# 0

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

a = true ? 1 : 0
# 1
b = false ? 1 : 0
# 0

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

val a = true ? 1 | 0
# 1
val b = false ? 1 | 0
# 0

Тернарный оператор в программировании на R

a <- if (TRUE) 1 else 0
# 1
b <- if (FALSE) 1 else 0
# 0

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

a = 1 if True else 0
# 1
b = 1 if False else 0
# 0

Для Python 2.5 и новее существует особый синтаксис:

[on_true] if [cond] else [on_false]

В старых версиях Pythons тернарный оператор не реализован, но его можно смоделировать.

cond and on_true or on_false

Однако существует потенциальная проблема: если cond оценивается как True, а on_true оценивается как False, то вместо on_true возвращается on_false. Если вы хотите этого поведения, метод в порядке, в противном случае используйте это:

{True: on_true, False: on_false}[cond is True] # is True, not == True

который можно обернуть:

def q(cond, on_true, on_false)
    return {True: on_true, False: on_false}[cond is True]

и использовал так:

q(cond, on_true, on_false)

Он совместим со всеми версиями Python.

Вы часто можете найти

cond and on_true or on_false

но это приводит к проблеме, когда on_true == 0

>>> x = 0
>>> print x == 0 and 0 or 1 
1
>>> x = 1
>>> print x == 0 and 0 or 1 
1

где вы ожидаете от обычного тернарного оператора этого результата

>>> x = 0
>>> print 0 if x == 0 else 1 
0
>>> x = 1
>>> print 0 if x == 0 else 1 
1

Есть ли в Python тернарный условный оператор?

да. Из файла грамматики:

test: or_test ['if' or_test 'else' test] | lambdef

Интересующая часть:

or_test ['if' or_test 'else' test]

Итак, тернарная условная операция имеет вид:

expression1 if expression2 else expression3

expression3 будет вычисляться лениво (то есть оцениваться, только если expression2 ложно в логическом контексте). А из-за рекурсивного определения вы можете связывать их бесконечно долго (хотя это может считаться плохим стилем).

expression1 if expression2 else expression3 if expression4 else expression5 # and so on

Примечание по использованию:

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

[expression1 if expression2 for element in iterable]
#                          ^-- need an else here

что повышает SyntaxError: invalid syntax. Таким образом, приведенное выше является либо неполным фрагментом логики (возможно, пользователь ожидает отсутствия операции в ложном условии), либо может быть предназначено использовать выражение2 в качестве фильтра - отмечает, что следующее является допустимым Python:

[expression1 for element in iterable if expression2]

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

Альтернативный синтаксис для более узкого случая:

Вам может показаться несколько болезненным писать следующее:

expression1 if expression1 else expression2

expression1 необходимо будет дважды оценить с использованием вышеупомянутого использования. Это может ограничить избыточность, если это просто локальная переменная. Однако распространенная и эффективная идиома Pythonic для этого варианта использования - использовать сокращенное поведение or:

expression1 or expression2

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

Имитация тернарного оператора Python.

Например

a, b, x, y = 1, 2, 'a greather than b', 'b greater than a'
result = (lambda:y, lambda:x)[a > b]()

выход:

'b greater than a'

a if condition else b

Просто запомните эту пирамиду, если у вас возникли проблемы с запоминанием:

     condition
  if           else
a                   b 

Одна из альтернатив условного выражения Python

"yes" if boolean else "no"

следующее:

{True:"yes", False:"no"}[boolean]

который имеет следующее красивое расширение:

{True:"yes", False:"no", None:"maybe"}[boolean_or_none]

Остается самая короткая альтернатива:

("no", "yes")[boolean]

но альтернативы нет

yes() if boolean else no()

если вы хотите избежать оценки yes() и no(), потому что в

(no(), yes())[boolean]  # bad

оцениваются как no(), так и yes().

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

Синтаксис:

[on_true] if [выражение] else [on_false]

1- Простой метод использования тернарного оператора:

# Program to demonstrate conditional operator
a, b = 10, 20
# Copy value of a in min if a < b else copy b
min = a if a < b else b
print(min)  # Output: 10

2- Прямой метод использования кортежей, словаря и лямбда:

# Python program to demonstrate ternary operator
a, b = 10, 20
# Use tuple for selecting an item
print( (b, a) [a < b] )
# Use Dictionary for selecting an item
print({True: a, False: b} [a < b])
# lamda is more efficient than above two methods
# because in lambda  we are assure that
# only one expression will be evaluated unlike in
# tuple and Dictionary
print((lambda: b, lambda: a)[a < b]()) # in output you should see three 10

3- Тернарный оператор может быть записан как вложенный if-else:

# Python program to demonstrate nested ternary operator
a, b = 10, 20
print ("Both a and b are equal" if a == b else "a is greater than b"
        if a > b else "b is greater than a")

Вышеупомянутый подход можно записать как:

# Python program to demonstrate nested ternary operator
a, b = 10, 20
if a != b:
    if a > b:
        print("a is greater than b")
    else:
        print("b is greater than a")
else:
    print("Both a and b are equal") 
# Output: b is greater than a

ты можешь сделать это :-

[condition] and [expression_1] or [expression_2] ;

Пример:-

print(number%2 and "odd" or "even")

Это выведет нечетное, если число нечетное или даже, если число четное.

Результат: - Если условие истинно, выполняется exp_1, иначе выполняется exp_2.

Примечание. - 0, None, False, emptylist, emptyString оценивается как False. И любые данные, кроме 0, оцениваются как True.

Вот как это работает:

если условие [условие] становится истинным, тогда вычисляется выражение_1, но не выражение_2. Если мы и что-то с 0 (нулем), результат всегда будет быстрым. Итак, в приведенном ниже заявлении

0 and exp

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

In

1 or exp

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

Но в случае

True and exp1 or exp2

Второе выражение exp2 не будет оцениваться, поскольку True and exp1 будет иметь значение True, если exp1 не ложно.

Аналогично в

False and exp1 or exp2

Выражение exp1 не будет оцениваться, поскольку False эквивалентно записи 0, а выполнение с 0 будет само по себе 0, но после использования exp1, поскольку или используется, оно будет оценивать выражение exp2 после или.

Примечание. - Этот вид ветвления с использованием или и и может использоваться только в том случае, если выражение_1 не имеет истинного значения False (или 0, или None, или emptylist [], или emptystring ''.), поскольку если выражение_1 становится ложным, тогда выражение_2 будет оцениваться из-за наличия или между exp_1 и exp_2.

Если вы все же хотите, чтобы это работало для всех случаев, независимо от истинных значений exp_1 и exp_2, сделайте следующее: -

[condition] and ([expression_1] or 1) or [expression_2] ;

Скорее совет, чем ответ (не нужно повторять очевидное сотню раз), но я иногда использую его как однояйцевое сокращение в таких конструкциях:

if conditionX:
    print('yes')
else:
    print('nah')

, становится:

print('yes') if conditionX else print('nah')

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

Как уже было сказано, да, в python есть тернарный оператор:

<expression 1> if <condition> else <expression 2>

Дополнительная информация:

Если <expression 1> является условием, вы можете использовать оценку короткого замыкания:

a = True
b = False

# Instead of this:
x = a if a else b

# You could use Short-cirquit evaluation:
x = a or b

PS: Конечно, оценка короткого замыкания не является тернарным оператором, но часто тернарный используется в тех случаях, когда короткого замыкания будет достаточно.

Ответ Винко Врсаловича достаточно хорош. Остается только одно:

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

Оператор моржа в Python 3.8

После того, как этот оператор моржа был введен в Python 3.8, кое-что изменилось.

(a := 3) if True else (b := 5)

дает a = 3 и b is not defined,

(a := 3) if False else (b := 5)

дает a is not defined и b = 5, и

c = (a := 3) if False else (b := 5)

дает c = 5, a is not defined и b = 5.

Даже если это может показаться некрасивым, присваивания можно выполнять внутри условных выражений после Python 3.8. В любом случае, в этом случае все же лучше использовать обычный if оператор.

Многие языки программирования, производные от C, обычно имеют следующий синтаксис тернарного условного оператора:

<condition> ? <expression1> : <expression2>

Сначала Python B энергичный D ictator F или L ife (я, конечно, имею в виду Гвидо ван Россума ) отклонил его (как непитонический стиль), поскольку его довольно трудно понять людям, не привыкшим к C языку. Кроме того, знак двоеточия : уже широко используется в Python. После утверждения PEP 308 Python наконец получил собственное сокращенное условное выражение (то, что мы используем сейчас):

<expression1> if <condition> else <expression2>

Итак, сначала он оценивает состояние. Если он возвращает True, для получения результата будет вычислено выражение1, в противном случае будет вычислено выражение2. Из-за механики отложенной оценки будет выполнено только одно выражение.

Вот несколько примеров (условия будут оцениваться слева направо):

pressure = 10
print('High' if pressure < 20 else 'Critical')

# Result is 'High'

Тернарные операторы могут быть соединены последовательно:

pressure = 5
print('Normal' if pressure < 10 else 'High' if pressure < 20 else 'Critical')

# Result is 'Normal'

Следующий такой же, как и предыдущий:

pressure = 5

if pressure < 20:
    if pressure < 10:
        print('Normal')
    else:
        print('High')
else:
    print('Critical')

# Result is 'Normal'

Надеюсь это поможет.

ДА, у python есть тернарный оператор, вот синтаксис и пример кода, чтобы продемонстрировать то же самое :)

#[On true] if [expression] else[On false]
# if the expression evaluates to true then it will pass On true otherwise On false


a= input("Enter the First Number ")
b= input("Enter the Second Number ")

print("A is Bigger") if a>b else print("B is Bigger")

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

Предположим, мы хотим использовать option_value со значением по умолчанию, если оно не установлено:

run_algorithm(option_value if option_value is not None else 10)

или, если option_value никогда не устанавливается в ложное значение (0, "" и т. д.), просто

run_algorithm(option_value if option_value else 10)

Однако в этом случае лучшим решением будет просто написать

run_algorithm(option_value or 10)

Python имеет троичную форму для присвоений; однако может существовать даже более короткая форма, о которой следует знать.

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

>>> li1 = None
>>> li2 = [1, 2, 3]
>>> 
>>> if li1:
...     a = li1
... else:
...     a = li2
...     
>>> a
[1, 2, 3]

^ Это полная форма для выполнения таких заданий.

Ниже представлена ​​троичная форма. Но это не самый лаконичный способ - см. Последний пример.

>>> a = li1 if li1 else li2
>>> 
>>> a
[1, 2, 3]
>>> 

С Python вы можете просто использовать or для альтернативных назначений.

>>> a = li1 or li2
>>> 
>>> a
[1, 2, 3]
>>> 

Вышеупомянутое работает, так как li1 равно None, и interp рассматривает это как False в логических выражениях. Затем interp переходит и оценивает второе выражение, которое не является None и не является пустым списком, поэтому оно присваивается a.

Это также работает с пустыми списками. Например, если вы хотите назначить a любому списку, в котором есть элементы.

>>> li1 = []
>>> li2 = [1, 2, 3]
>>> 
>>> a = li1 or li2
>>> 
>>> a
[1, 2, 3]
>>> 

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

>>> s1 = ''
>>> s2 = 'hello world'
>>> 
>>> a = s1 or s2
>>> 
>>> a
'hello world'
>>> 

Мне всегда нравился тернарный синтаксис C, но Python делает еще один шаг вперед!

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

Удобный способ объединения нескольких операторов в цепочку:

f = lambda x,y: 'greater' if x > y else 'less' if y > x else 'equal'

array = [(0,0),(0,1),(1,0),(1,1)]

for a in array:
  x, y = a[0], a[1]
  print(f(x,y))

# Output is:
#   equal,
#   less,
#   greater,
#   equal

Синтаксис Python по умолчанию val = a if cond else b мне кажется громоздким, поэтому иногда я делаю следующее:

iif = lambda (cond, a, b): a if cond else b
# so I can then use it like:
val = iif(cond, a, b)

Конечно, у него есть обратная сторона: всегда оцениваются обе стороны (a и b), но синтаксис для меня более понятен.

если переменная определена и вы хотите проверить, имеет ли она значение, вы можете просто a or b

def test(myvar=None):
    # shorter than: print myvar if myvar else "no Input"
    print myvar or "no Input"

test()
test([])
test(False)
test('hello')
test(['Hello'])
test(True)

выведет

no Input
no Input
no Input
hello
['Hello']
True

is_spacial=True if gender = "Female" else (True if age >= 65 else False)

**

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

**