Python是否具有三元条件运算符？

如果Python没有三元条件运算符，是否可以使用其他语言构造来模拟一个？

---

#1楼

对于Python 2.5及更高版本，有一种特定的语法：

[on_true] if [cond] else [on_false]

在较旧的Python中，未实现三元运算符，但可以对其进行仿真。

cond and on_true or on_false

不过，有一个潜在的问题，如果cond计算结果为True ，并on_true评估为False则on_false返回，而不是on_true 。 如果您想要这种行为，该方法可以，否则请使用以下方法：

{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版本兼容。

---

#2楼

您可能经常会发现

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

---

#3楼

不幸的是，

(falseValue, trueValue)[test]

解决方案没有短路行为； 因此，无论条件如何，都会对falseValue和trueValue进行评估。 这可能是次优的，甚至是错误的（即trueValue和falseValue都可能是方法，并且有副作用）。

一种解决方案是

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

（执行会延迟到知道获胜者为止；），但是会在可调用对象和不可调用对象之间引入不一致。 此外，使用属性时无法解决问题。

故事就这样-在提到的3种解决方案之间进行选择是要在具有短路功能，至少使用Зython2.5（恕我直言不再是问题）和不易于“ trueValue -to-false”之间进行trueValue错误。

---

#4楼

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

---

#5楼

if else

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

---

#6楼

作为Python增强建议308的一部分，2006年添加了Python中条件表达式的运算符。 它的形式不同于常见的?:运算符，它的形式是：

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

Python是否具有三元条件运算符？

是。 从语法文件 ：

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

感兴趣的部分是：

or_test ['if' or_test 'else' test]

因此，三元条件运算的形式为：

expression1 if expression2 else expression3

expression3将被惰性求值（即，仅当expression2在布尔上下文中为false时才求值）。 而且由于递归定义，您可以无限地链接它们（尽管它可能被认为是不好的样式。）

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

使用注意事项：

请注意，每个if后面都必须带有else 。 人们在学习列表理解和生成器表达式时可能会发现这是一个很难学习的课-以下内容将不起作用，因为Python期望将其他表达式用作第三个表达式：

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

引发SyntaxError: invalid syntax 。 因此，以上内容要么是一个不完整的逻辑（也许用户期望在错误条件下不进行操作），要么是打算将expression2用作过滤器-请注意，以下内容是合法的Python：

[expression1 for element in iterable if expression2]

expression2用作列表理解的过滤器，而不是三元条件运算符。

较窄情况的替代语法：

您可能会发现编写以下内容有些痛苦：

expression1 if expression1 else expression2

根据上述用法，必须对expression1进行两次评估。 如果它只是局部变量，则可以限制冗余。 但是，此用例的一个常见且高性能的Python习惯用法是使用or的快捷方式行为：

expression1 or expression2

这在语义上是等效的。 请注意，某些样式指南可能出于清楚的原因而限制了此用法-它确实将很多含义包含在很少的语法中。

---

#8楼

提示多于答案（不需要在第一百遍重复显而易见的内容），但是我有时在这样的结构中将其用作单行捷径：

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

，变为：

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

有些（很多：）可能不喜欢它是非Python风格的（甚至是红宝石色的：），但我个人认为它更自然-即您通常的表达方式，并且在大块代码中更具视觉吸引力。

---

#9楼

不同编程语言的三元运算符

在这里，我只是试图说明几种编程语言之间在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

---

#10楼

是的，它是在2.5版中添加的 。 表达式语法为：

a if condition else b

首先对condition求值，然后根据condition的布尔值对a或b的任意a求值并返回。 如果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 语句而不是条件表达式 。

---

请记住，由于某些原因，某些Pythonista对此并不满意：

• 论据的顺序与经典condition ? a : b的顺序不同condition ? a : b condition ? a : b来自许多其他语言（例如C，C ++，Go，Perl，Ruby，Java，Javascript等）的三元运算符，当人们不熟悉Python的“令人惊讶”行为时可能会导致错误（它们可能会逆转）参数顺序）。
• 有些人认为它“笨拙”，因为它与正常的思维流程相反（先思考条件，然后思考效果）。
• 风格上的原因。 （尽管'inline if '可能确实有用，并且可以使脚本更简洁，但确实会使代码复杂化）

如果您在记住顺序时遇到麻烦，请记住当大声朗读时，您（几乎）说出了您的意思。 例如， x = 4 if b > 8 else 9 ，则x = 4 if b > 8 else 9大声读取x = 4 if b > 8 else 9因为x will be 4 if b is greater than 8 otherwise 9 。

官方文件：

• 条件表达式
• 是否有C的等价于“？：”三元运算符？

---

#11楼

从文档中 ：

条件表达式（有时称为“三元运算符”）在所有Python操作中具有最低的优先级。

x if C else y首先计算条件C （ 不是x ）， x if C else y表达式x if C else y ; 如果C为true，则对x求值并返回其值； 否则，将评估y并返回其值。

有关条件表达式的更多详细信息，请参见PEP 308 。

从2.5版开始新增。

---

#12楼

对于2.5之前的版本，有个窍门：

[expression] and [on_true] or [on_false]

当on_true具有错误的布尔值时，它可能会给出错误的结果。 ^1个
尽管这样做确实具有从左到右评估表达式的好处，但在我看来这很清楚。

_{1. 是否有C的等价的“？：”三元运算符？}

---

#13楼

你可以这样做 ：-

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

例：-

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

如果数字为奇数，则将打印“ odd”；如果数字为偶数，则将打印“偶数”。

---

结果：-如果条件为true，则执行exp_1，否则执行exp_2。

注意： -0，None，False，emptylist，emptyString计算为False。 除0以外的任何数据都将评估为True。

运作方式如下：

如果条件[condition]变为“ True”，则将评估expression_1而不是expression_2。 如果我们以0（零）“和”某物，结果将总是令人讨厌。因此，在下面的语句中，

0 and exp

完全不会对表达式exp求值，因为带有0的“ and”将始终求值为零，因此无需求值。 这就是编译器本身在所有语言中的工作方式。

在

1 or exp

表达式exp根本不会被求值，因为带有“ 1”的“或”将始终为1。因此，无论如何，只要结果为1，就不会费心计算表达式exp。 （编译器优化方法）。

但是在

True and exp1 or exp2

第二个表达式exp2将不被评估，因为当exp1不为false时， True and exp1将为True。

同样在

False and exp1 or exp2

由于False等于写入0并用0进行“和”本身将为0，因此不会对表达式exp1进行求值，但是在exp1之后，由于使用了“或”，它将在表达式“或”之后求值exp2。

---

注意：-仅当expression_1的True值不为False（或0或None或emptylist []或emptystring''。）时，才可以使用这种使用“ or”和“ and”的分支，因为如果expression_1变为False，则由于exp_1和exp_2之间存在“或”，将对表达式_2进行求值。

如果您仍然想使它适用于所有情况，而不论exp_1和exp_2真值是多少，请执行以下操作：

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

---

#14楼

您可以索引到一个元组：

(falseValue, trueValue)[test]

test需要返回True或False 。
始终将其实现为：

(falseValue, trueValue)[test == True]

或者您可以使用内置的bool()来确保布尔值：

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

---

#15楼

三元条件运算符仅允许在单行中测试条件，从而代替多行if-else，从而使代码紧凑。

句法 ：

如果[表达式]，则为[on_true]，否则为[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-使用元组，字典和lambda的直接方法：

# 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楼

如果定义了变量，并且您想检查它是否具有值，则可以是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

---

#17楼

是的，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")

---

#18楼

a if condition else b

如果您难以记住，只需记住这座金字塔：

     condition
  if           else
a                   b 

---

#19楼

从C派生的许多编程语言通常具有以下三进制条件运算符的语法：

<condition> ? <expression1> : <expression2>

起初， Python 乙 enevolent d ictator˚F或L IFE（我的意思是吉多·范罗苏姆，当然）拒绝了（非Python化风格），因为它是挺难理解不习惯的人C语言。 另外，冒号:在Python已经有很多用途。 在PEP 308获得批准后， Python终于收到了自己的快捷方式条件表达式（我们现在使用的是）：

<expression1> if <condition> else <expression2>

因此，首先它评估条件。 如果返回True ，则将对expression1求值以给出结果，否则将对expression2求值。 由于懒惰的评估机制–仅执行一个表达式。

以下是一些示例（条件将从左到右评估）：

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'

希望这可以帮助。

---

#20楼

Python 条件表达式的替代方法之一如下：

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

具有以下很好的扩展：

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

最短的替代项仍然是：

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

但是如果您想避免对yes()和no()进行以下评估，则no() ：

yes() if [condition] else no()

---

#21楼

链接多个运算符的一种巧妙方法：

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

---

#22楼

是

X if condition else Y

如果条件为真，则评估X，否则评估Y

---

#23楼

正如已经回答的那样，是的，在python中有一个三元运算符：

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

附加信息：

如果<expression 1>是条件，则可以使用Short-cirquit评估 ：

a = True
b = False

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

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

PS：当然，短路短路评估不是三元运算符，但是在短路就足够的情况下，经常使用三元运算符。

---

#24楼

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

**

它可以根据需要嵌套。 祝你好运

**