Ответ 1

Да, это было добавлено в версии 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 вместо условного выражения.

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

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

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

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

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

Ответ 2

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

(falseValue, trueValue)[test]

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

(falseValue, trueValue)[test == True]

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

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

Ответ 3

Для версий до 2.5 существует трюк:

[expression] and [on_true] or [on_false]

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

<суб > 1. Есть ли эквивалент Cs "?:" трехмерный оператор?

Ответ 4

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

a = 1
b = 2

1 if a > b else -1 
# Output is -1

1 if a > b else -1 if a < b else 0
# Output is -1

Ответ 5

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

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

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

Подробнее о условных выражениях см. PEP 308.

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

Ответ 6

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

<expression1> if <condition> else <expression2>

что эквивалентно:

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

Вот пример:

result = x if a > b else y

Другой синтаксис, который можно использовать (совместимый с версиями до 2.5):

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]

или

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

Если вы работаете со словарями, вместо использования тернарного условного выражения вы можете воспользоваться get(key, default), например:

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

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

Ответ 7

К сожалению,

(falseValue, trueValue)[test]

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

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

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

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

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

Ответ 8

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

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

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

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

Троичный оператор в рубине

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

Тернарный оператор в Скале

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

Ответ 9

Для 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.

Ответ 10

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

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

Ответ 11

Абсолютно, и это невероятно легко понять.

general syntax : first_expression if bool_expression_is_true else second_expression

Example: x= 3 if 3 > 2 else 4 
# assigns 3 to x if the boolean expression evaluates to true or 4 if it is false

Ответ 12

У 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

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

[expression1 for element in iterable if expression2]

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

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

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

expression1 if expression1 else expression2

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

expression1 or expression2

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

Ответ 13

Имитация троичного оператора 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'

Ответ 14

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

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

Пример: -

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

Это будет печатать "нечетные", если число нечетное или "четное", если число четное.

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

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

Здесь как это работает:

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

0 and exp

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

В

1 or exp

выражение exp не будет вообще оцениваться, так как "или" с 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 становится False, то выражение_2 будет оцениваться из-за наличия "или" между exp_1 и exp_2.

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

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

Ответ 15

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

Синтаксис:

[on_true], если [выражение] 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

Ответ 16

Больше подсказки, чем ответа (не нужно повторять очевидное для времени hundreth), но иногда я использую его как ярлык oneliner в таких конструкциях:

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

становится:

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

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

Ответ 17

a if condition else b

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

     condition
  if           else
a                   b 

Ответ 18

In [1]: a = 1 if False else 0

In [2]: a
Out[2]: 0

In [3]: b = 1 if True else 0

In [4]: b
Out[4]: 1

Ответ 19

Да, вы можете использовать его так:

is_fat = True
state = "fat" if is_fat else "not fat"

Подробнее о тернальном условном операторе

Ответ 20

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

<condition> ? <expression1> : <expression2>

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

<expression1> if <condition> else <expression2>

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

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

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'

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

Ответ 21

Да.

>>> b = (True if 5 > 4 else False)
>>> print b
True

Ответ 22

ДА, у 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")

Ответ 23

Синтаксис: оператор Ternary будет представлен как:

[on_true] if [expression] else [on_false]

например

x, y = 25, 50
big = x if x < y else y
print(big)

Ответ 24

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

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

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

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

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

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

но альтернативы нет, если вы хотите избежать оценки yes() и no() в следующем:

yes() if [condition] else no()

Ответ 25

Да:

Допустим, вы хотите дать переменной x некоторое значение, если некоторое значение bool верно и аналогично

x = 5 if something else x = 10

x = [some value] if [if this is true first value evaluates] else [other value evaluates]

Ответ 26

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

>>> a = False
>>> b = 5
>>> a or b
5

>>> a = None
>>> a or b
5

Ответ 27

Оператор "условный". Тернар просто означает, что требуется три операнда. Мы не называем + "бинарный" + оператор. Нет причин продолжать делать это с условным условием. Является ли это быстрее или более компактным, чем если-иначе, не имеет значения. Важно то, что это выражение, позволяющее встраивать его в другие выражения. При правильном использовании, это уменьшает избыточность и возможности для трудно различимых различий.

Ответ 28

Ниже приводится общее определение троичного состояния -

выражение1 если выражение2 еще выражение3

Ниже приведен пример использования вышеуказанного формата троичного условия -

a = 1, если True, иначе 0

Вывод вышеуказанного утверждения будет 1

b = 1, если False, иначе 0

Выход вышеупомянутого утверждения будет 0

1 если a> b else -1, если a <b else 0

Результатом вышеупомянутого утверждения будет -1

Ответ 29

Прежде чем задать такой вопрос, вы должны знать, что такое EBNF.

Ответ 30

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

a if condition else b

Где 'a' является первым (по умолчанию) результатом, т.е. когда условие истинно, а 'b' является вторым результатом, т.е. когда условие ложно.

x=10
result='even number' if x%2==0 else 'odd number'
print(result)

Вывод вышеуказанного кода будет: "четное число"