Синтаксис тернарного оператора в Python:

[on_true] if [expression] else [on_false]

Используя этот синтаксис, вот как мы могли бы переписать приведенный выше код, используя тернарный оператор Python:

game_type = 'home'
shirt = 'white' if game_type == 'home' else 'green'

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

Да, есть, но он отличается от языков программирования, подобных C-синтаксису (то есть condition ? value_if_true : value_if_false

В Python это выглядит так: value_if_true if condition else value_if_false

Пример: even_or_odd = "even" if x % 2 == 0 else "odd"

Версия if else-if может быть записана как:

sample_set="train" if "Train" in full_path else ("test" if "Test" in full_path else "validation")

Есть несколько способов. Самый простой — использовать условие внутри метода print.

Вы можете использовать

print("Twenty" if number == 20 else "Not twenty")

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

if number == 20:
    print("Twenty")
else:
    print("Not twenty")

Таким образом можно напечатать более двух операторов. Например:

if number == 20:
    print("Twenty")
elif number < 20:
    print("Lesser")
elif 30 > number > 20:
    print("Between")
else:
    print("Greater")

может быть записано как:

print("Twenty" if number == 20 else "Lesser" if number < 20 else "Between" if 30 > number > 20 else "Greater")

Простым, но полезным приемом может быть использование:

foo = "True" and test or "False"

Питонический способ делать вещи:

"true" if var else "false"

Но всегда существует другой способ выполнения троичного условия:

"true" and var or "false"

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

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

Оператор Walrus в 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 оператор .

Другие ответы правильно говорят о тернарном операторе 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)

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

[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 вообще не будет оцениваться, поскольку "and" с 0 всегда будет оцениваться как ноль, и нет необходимости оценивать выражение. Так работает сам компилятор на всех языках.

В

1 or exp

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

Но в случае

True and exp1 or exp2

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

Аналогично в

False and exp1 or exp2

Выражение exp1 не будет оцениваться, так как False эквивалентно записи 0 и выполнение «and» с 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] ;

Синтаксис 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), но синтаксис для меня понятнее

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, и интерпритация обрабатывает это как False в логических выражениях. Затем interp переходит и оценивает второе выражение, которое не является None и не является пустым списком, поэтому ему присваивается значение.

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

Одна из альтернатив 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().

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

**

он может быть вложен по вашему желанию. удачи

**

Как уже было сказано, да, в 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: Конечно, оценка короткого замыкания не является тернарным оператором, но часто тернарный метод используется в тех случаях, когда короткого замыкания будет достаточно.

<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

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

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

К сожалению,

(falseValue, trueValue)[test]

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

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

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

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

Итак, история гласит - выбор между 3 упомянутыми решениями - это компромисс между наличием функции короткого замыкания, использованием по крайней мере ython 2.5 (IMHO, больше не проблема) и отсутствием склонности к "trueValue -оценкам -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

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

<condition> ? <expression1> : <expression2>

Сначала Python B enevolent D ictator F или <3099634> конечно) отклонил его (как непитонический стиль), поскольку его довольно сложно понять людям, не привыкшим к 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'

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

a if condition else b

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

     condition
  if           else
a                   b 

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

если переменная определена и вы хотите проверить, имеет ли она значение, вы можете просто 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

Тернарный условный оператор просто позволяет тестировать условие в одной строке, заменяя многострочное 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

Оператор условного выражения в Python был добавлен в 2006 году как часть предложения по усовершенствованию Python 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 в Википедии}

Есть ли в 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

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

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

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

становится:

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

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

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

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

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

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

Новое, начиная с версии 2.5.

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

(falseValue, trueValue)[test]

test необходимо вернуть Истина или Ложь .
Может быть безопаснее всегда реализовывать его как:

(falseValue, trueValue)[test == True]

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

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

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

[expression] and [on_true] or [on_false]

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

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

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

Вы можете часто встретить

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 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.