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




условный оператор си (19)

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


Моделирование троичного оператора 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

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

a if condition else b

Первое condition оценивается, то либо a либо b возвращается на основе Boolean значения condition
Если condition принимает значение True, возвращается, возвращается b .

Например:

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

В таком случае вы должны использовать нормальную инструкцию if вместо условного.

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

  • Порядок аргументов отличается от многих других языков (таких как C, Ruby, Java и т. Д.), Что может привести к ошибкам, когда люди, незнакомые с «неожиданным» поведением Python, используют его (они могут отменить порядок).
  • Некоторые считают это «громоздким», так как оно противоречит нормальному потоку мысли (сначала думая о состоянии, а затем о последствиях).
  • Стилистические причины.

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

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


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

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

expression1 if условие else expression2

>>> a = 1
>>> b = 2
>>> 1 if a > b else -1 
-1
>>> 1 if a > b else -1 if a < b else 0
-1

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

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

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

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. его читабельность и удобство обслуживания.


Да.

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

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

[expression] and [on_true] or [on_false]

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

1. Существует ли эквивалент тройного оператора C??:?


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

(falseValue, trueValue)[test]

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

(falseValue, trueValue)[test == True]

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

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

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

[on_true] if [expression] else [on_false]

например

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


@up:

К сожалению,

(falseValue, trueValue)[test]

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

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

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

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

И так происходит история: выбор между тремя упомянутыми решениями - это компромисс между функцией короткого замыкания, использующей по крайней мере python 2.5 (IMHO больше не проблема) и не подверженный «trueValue-evaluation-to-false», ошибки.


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

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

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

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

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

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


Оператор условного выражения в 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]

Другой (менее надежный), но более простой способ - использовать и / 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 есть тернарный условный оператор?

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

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

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

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

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

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

[expression1 for element in iterable if expression2]

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

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

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

expression1 if expression1 else expression2

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

expression1 or expression2

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


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

Да:

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

X = 5, если что-то другое x = 10

X = [некоторое значение], если [если это истинно, первое значение оценивает] else [другое значение оценивает]


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

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

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

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

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





python-2.5