Python有三元条件运算符吗？

Posted 2023-02-24

【中文标题】Python有三元条件运算符吗？

【英文标题】：Does Python have a ternary conditional operator?

【发布时间】：2010-09-28 12:45:34

【问题描述】：

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

【问题讨论】：

在上面评论中引用的 Python 3.0 官方文档中，这被称为“conditional_expressions”，并且定义非常隐晦。该文档甚至不包含“三元”一词，因此除非您确切知道要查找的内容，否则您将很难通过 Google 找到它。 version 2 documentation 更有帮助，它包含指向 "PEP 308" 的链接，其中包含与此问题相关的许多有趣的历史背景。

“三元”（具有三个输入）是这种实现的必然属性，而不是概念的定义属性。例如：SQL 有case [...] when ... then ... [ else ... ] end 具有类似的效果，但根本不是三元的。

ISO/IEC 9899（C 编程语言标准）第 6.5.15 节将其称为“条件运算符”

***在文章“?:”中全面介绍了这一点。

在 nobar 发表评论后的几年里，conditional expression documentation 已更新为说 条件表达式（有时称为“三元运算符”）...

【参考方案1】：

是的，在 2.5 版中是 added。表达式语法为：

a if condition else b

首先评估condition，然后根据condition 的Boolean 值评估并返回a 或b 中的一个。如果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 语句，而不是条件表达式。

---

请记住，一些 Python 爱好者不赞成它有几个原因：

参数的顺序与许多其他语言（如C、C++、Go、Perl、Ruby、Java、javascript等）的经典condition ? a : b三元运算符的顺序不同，这可能会导致错误当不熟悉 Python “令人惊讶”的行为的人使用它时（他们可能会颠倒参数顺序）。 有些人认为它“笨拙”，因为它违背了正常的思维流程（先考虑条件，然后考虑效果）。 风格原因。 （虽然'inline if'可能真的有用，并且让你的脚本更简洁，但它确实使你的代码复杂化）

如果您无法记住顺序，请记住，当您大声朗读时，您（几乎）说出了您的意思。例如，x = 4 if b > 8 else 9 被朗读为 x will be 4 if b is greater than 8 otherwise 9。

官方文档：

Conditional expressions Is there an equivalent of C’s ”?:” ternary operator?

【讨论】：

这个顺序对程序员来说可能看起来很奇怪，但是f(x) = |x| = x if x > 0 else -x 对数学家来说听起来很自然。在大多数情况下，您也可以将其理解为 A，除非当 C 时，您应该改为 B...

使用这个时要注意操作的顺序。例如，z = 3 + x if x < y else y 行。如果x=2 和y=1，你可能期望它产生4，但它实际上会产生1。z = 3 + (x if x > y else y) 是正确的用法。

重点是，如果您想在 条件被评估之后执行额外的评估，比如向结果添加一个值，您要么需要将额外的表达式添加到两边（z = 3 + x if x < y else 3 + y），或组合条件（z = 3 + (x if x < y else y) 或 z = (x if x < y else y) + 3）

@MrGeek，我明白你的意思，所以你基本上会嵌套操作：` "foo" if Bool else ("bar" if Bool else "foobar") `

程序员比数学家更需要精确正确的公式，因为在数学中总是需要求助于基本概念。一个令人信服的论点是 % 运算符，模仿数学中使用“mod”的方式将是一场灾难。所以不，我不接受你的论点。这就像坚持英制单位。 Groetjes Albert

【参考方案2】：

来自the documentation：

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

表达式x if C else y首先计算条件，C（not x）；如果 C 为真，则评估 x 并返回其值；否则，评估 y 并返回其值。

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

自 2.5 版以来的新功能。

【参考方案3】：

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

[expression] and [on_true] or [on_false]

on_true 时会给出错误的结果 具有错误的布尔值。¹ 虽然它确实有从左到右评估表达式的好处，但我认为这更清楚。

1。 Is there an equivalent of C’s ”?:” ternary operator?

【讨论】：

补救方法是使用(test and [true_value] or [false_value])[0]，这样就避免了这个陷阱。

三元运算符的执行速度通常更快（有时提高 10-25%）。

@volcano 你有资源吗？

@OrangeTux Here's the disassembled code。使用 ThomasH 建议的方法会更慢。

【参考方案4】：

你可以索引一个元组：

(falseValue, trueValue)[test]

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

(falseValue, trueValue)[test == True]

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

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

【讨论】：

请注意，这个总是计算一切，而 if/else 结构只计算获胜的表达式。

(lambda: print("a"), lambda: print("b"))[test==true]()

需要注意的是，[]s 中的内容可以是任意表达式。此外，为了安全起见，您可以通过写[bool(<expression>)] 来明确测试真实性。 bool() 函数自 v2.2.1 起就已存在。

我做了一个类似的把戏——只有一两次，但做到了——通过索引到字典中，以True和False为键：True:trueValue, False:falseValue[test]我不'不知道这是否效率更低，但它至少避免了整个“优雅”与“丑陋”的辩论。毫无疑问，您处理的是布尔值而不是 int。

comparisons to singletons should always use is/is not instead of ==

【参考方案5】：

不幸的是，

(falseValue, trueValue)[test]

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

一个解决方案是

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

（延迟执行，直到知道获胜者；）），但它引入了可调用对象和不可调用对象之间的不一致。另外，在使用属性时也没有解决问题。

故事是这样的——在提到的 3 个解决方案之间进行选择是在具有短路功能、至少使用 Зython 2.5（恕我直言不再是问题）和不容易出现“trueValue-evaluates”之间的权衡-to-false”错误。

【讨论】：

虽然 lambdas 元组技巧有效，但它需要的时间大约是三元运算符的 3 倍。如果它可以替换一长串if else if，这可能是一个合理的想法。

【参考方案6】：

<i>&lt;expression 1&gt;</i> <b>if</b> <i>&lt;condition&gt;</i> <b>else</b> <i>&lt;expression 2&gt;</i>

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

【讨论】：

这个强调了三元运算符的主要意图：值选择。它还表明，可以将多个三元组链接到一个表达式中。

@Craig ，我同意，但知道没有括号时会发生什么也很有帮助。在实际代码中，我也倾向于插入显式括号。

使用：return 3 if t > 10 else t/2

【参考方案7】：

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

【讨论】：

行为不一样 - q("blob", on_true, on_false) 返回 on_false，而 on_true if cond else on_false 返回 on_true。在这些情况下，一种解决方法是用cond is not None 替换cond，尽管这不是一个完美的解决方案。

为什么不用bool(cond) 而不是cond is True？前者检查cond 的真实性，后者检​​查True 对象的指针是否相等。正如@AndrewCecil 强调的那样，"blob" 是真实的，但它是 is not True。

哇，这看起来真的很hacky！ :) 从技术上讲，你甚至可以写[on_false, on_True][cond is True]，这样表达式就会变短。

【参考方案8】：

你可能经常发现

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

【参考方案9】：

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

【讨论】：

为什么不干脆result = (y, x)[a < b] 为什么要用lambda函数？

@GrijeshChauhan 因为在“编译”表达式上，例如。 G。涉及函数调用等，这将在两种情况下执行。这可能不是我们想要的。

lambda 函数的使用对于这个问题来说太过分了

@GrijeshChauhan 简而言之，这实现了所谓的“短路评估”。一般来说，P ? x : y 或x if P else y 可以写成(lambda:y, lambda:x)[P]()——但我怀疑它有更好的性能，因此它的必要性。

【参考方案10】：

作为Python Enhancement Proposal 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]()

其中操作数是lazily evaluated。

另一种方法是索引一个元组（这与大多数其他语言的条件运算符不一致）：

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")

^{来源：?: in Python at Wikipedia}

【讨论】：

result = 1: x, 0: y[a > b] 是另一种可能的变体（True 和 False 实际上是整数，其值为 1 和 0）

【参考方案11】：

Python 有三元条件运算符吗？

是的。来自grammar file：

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 期望 else 有第三个表达式：

[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 必须使用上述用法进行两次评估。如果它只是一个局部变量，它可以限制冗余。但是，此用例的一个常见且高效的 Pythonic 习惯用法是使用 or 的快捷方式行为：

expression1 or expression2

在语义上是等价的。请注意，一些样式指南可能会出于清晰的原因限制这种用法 - 它确实在非常少的语法中包含了很多含义。

【讨论】：

expression1 or expression2 与 javascript 中的 expression1 || expression2 相似且具有相同的缺点/优点

谢谢，@selurvedu - 在你弄明白之前可能会让人感到困惑。我学会了艰难的方式，所以你的方式可能没有那么难。 ;) 在没有 else 的情况下使用 if，在生成器表达式或列表理解的末尾将过滤可迭代对象。前面是三元条件运算，需要else。干杯！！

@AaronHall 虽然您对所有实例的元句法expressionN 的使用是一致的，但将条件测试表达式与两个结果表达式区分开来的命名可能更容易理解；例如，result1 if condition else result2。这在嵌套（也称为链接）时尤其明显：result1 if condition1 else result2 if condition2 else result3。看看这样读起来有多好？

@tchrist 感谢您的审阅 - 如果您查看修订历史，这篇文章目前有两个修订。我的大多数其他答案，尤其是最重要的答案，都被一次又一次地重新审视。这个答案从来没有引起我的注意，因为社区 wiki 状态没有让我对内容给予任何评价，所以我从来没有看到任何投票。由于我现在真的没有时间对此进行编辑，所以青蛙知道将来什么时候会再次引起我的注意。我可以看到您已经编辑了最佳答案，因此请随时从该帖子中借用/引用我的材料（如果适当的话，请引用我！）

【参考方案12】：

更多的是一个提示而不是一个答案（不需要重复第一百次显而易见的事情），但我有时将它用作此类构造中的单线捷径：

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

，变成：

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

有些（很多 :) 可能会认为它不符合 Python 风格（甚至是 ruby​​-ish :)，但我个人觉得它更自然 - 即你如何正常表达它，加上在大块的视觉上更具吸引力代码。

【讨论】：

我更喜欢print( 'yes' if conditionX else 'nah' )而不是你的回答。 :-)

也就是说，如果你想在这两种情况下都使用print()——我不得不承认，它看起来更像是pythonic :) 但是如果表达式/函数不一样怎么办——比如@987654325 @ - 仅在真实的conditionX 中获取print()

补充 Frederick99 的评论，避免print('yes') if conditionX else print('nah') 的另一个原因是它在 Python2 中给出了 SyntaxError。

它给出语法错误的唯一原因是因为在 Python 2 中 print 是一个语句 - print "yes"，而在 Python 3 中它是一个函数 - print("yes")。这可以通过将其用作语句来解决，或者更好 - from future import print_function。

【参考方案13】：

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

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

【讨论】：

这个blogger found python's ternary operator to be unnecessarily different than most other languages.

这听起来很固执；但它本质上说的是 Python 语法很可能被从未见过三元运算符的人理解，而很少有人会理解更常见的语法，除非他们首先被告知它的含义。

Algol68：a=.if。 。真的。 。然后。 1. 其他。 0.fi。这也可以表示为 a=(.true.|1|0) 像往常一样，Algol68 是对其继任者的改进。

@VarunGarg 但是你当然可以用 Python 说 print(a or 'alt text')。

print(a or "alt text")?

【参考方案14】：

你可以这样做：-

[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。

它的工作原理如下：

如果条件 [condition] 变为 "True" then ， expression_1 将被计算但不是 expression_2 。 如果我们用 0（零）“和”某些东西，结果将永远是错误的。所以在下面的语句中，

0 and exp

表达式 exp 根本不会被计算，因为 "and" 与 0 将总是计算为零，并且不需要计算表达式。这就是编译器本身在所有语言中的工作方式。

在

1 or exp

表达式 exp 根本不会被计算，因为带有 1 的“或”总是为 1。所以它不会费心计算表达式 exp，因为结果无论如何都会是 1。 （编译器优化方法）。

但万一

True and exp1 or exp2

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

类似

False and exp1 or exp2

表达式 exp1 不会被计算，因为 False 相当于写 0 并且用 0 做“and”本身就是 0，但是在 exp1 之后，因为使用了“or”，它会在“or”之后计算表达式 exp2。

---

注意：- 这种使用“or”和“and”的分支只能在 expression_1 的真值不为 False（或 0 或 None 或空列表 [ ]或空字符串 ' '.) 因为如果 expression_1 变为 False ，则由于 exp_1 和 exp_2 之间存在“或”，因此将对 expression_2 求值。

如果您仍然想让它适用于所有情况，而不管 exp_1 和 exp_2 真值是什么，请执行以下操作：-

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

【讨论】：

如果您想在x = [condition] and ([expression_1] or 1) or [expression_2] 的上下文中使用它，并且expression_1 的计算结果为false，x 将是1，而不是expression_1。使用接受的答案。

【参考方案15】：

三元条件运算符只允许在单行中测试条件，替换多行 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- 使用元组、字典和 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

【讨论】：

请注意，三元运算符比嵌套的 if 更小（在内存中）和更快。此外，您的嵌套 if-else 实际上并不是对三元运算符的重写，并且会为 a 和 b 的选择值产生不同的输出（特别是如果一个类型实现了一个奇怪的 __ne__ 方法）。

【参考方案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

【讨论】：

虽然对类似问题很有用，但这不是三元条件。它可以替换x if x else y，但不能替换x if z else y。

【参考方案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")

【讨论】：

我添加了一个单行语句示例来检查哪个数字大，以便进一步详细说明

print 确实不是一个好的选择，因为这会在 Python2 中产生 SyntaxError。

@Thierry Lathuille 这里我使用了 print() 函数而不是 print 语句，print 函数适用于 Python 3 而 print 语句适用于 Python 2

这个问题已经在 SO 上问过了，用 Python 2 试试就知道了。 'print('hello') 在 Python 2.7 中是一种完全有效的语法，但它的解析方式会使您的上述代码抛出 SyntaxError。

【参考方案18】：

a if condition else b

如果您记不住，请记住这个金字塔：

     condition
  if           else
a                   b 

【参考方案19】：

许多源自C的编程语言通常具有以下三元条件运算符语法：

<condition> ? <expression1> : <expression2>

起初，Python B仁慈的Dictator F或Life（我是说Guido van Rossum，当然）拒绝了它（作为非 Pythonic 风格），因为对于不习惯 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 的conditional expression 的替代方案之一

"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() 都会被评估。

【参考方案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】：

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

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

在许多情况下，<expression 1> 也用作布尔评估的<condition>。然后你可以使用Short-cirquit evaluation。

a = 0
b = 1

# Instead of this:
x = a if a else b
# Evaluates as 'a if bool(a) else b'

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

短路评估的一大优点是可以链接两个以上的表达式：

x = a or b or c or d or e

使用函数时，细节上会有所不同：

# Evaluating functions:
def foo(x):
    print('foo executed')
    return x


def bar(y):
    print('bar executed')
    return y


def blubb(z):
    print('blubb executed')
    return z


# Ternary Operator expression 1 equals to False
print(foo(0) if foo(0) else bar(1))
''' foo and bar are executed once
foo executed
bar executed
1
'''

# Ternary Operator expression 1 equals to True
print(foo(2) if foo(2) else bar(3))
''' foo is executed twice!
foo executed
foo executed
2
'''

# Short-cirquit evaluation second equals to True
print(foo(0) or bar(1) or blubb(2))
''' blubb is not executed
foo executed
bar executed
1
'''

# Short-cirquit evaluation third equals to True
print(foo(0) or bar(0) or blubb(2))
'''
foo executed
bar executed
blubb executed
2
'''

# Short-cirquit evaluation all equal to False
print(foo(0) or bar(0) or blubb(0))
''' Result is 0 (from blubb(0)) because no value equals to True
foo executed
bar executed
blubb executed
0
'''

PS：当然，短路评估不是三元运算符，但通常在短路就足够的情况下使用三元。它具有更好的可读性，并且可以链接。

【参考方案23】：

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

**

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

**

【参考方案24】：

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 是一种语法丰富的语言，具有许多惯用技巧，而这些技巧对于 dabler 来说并不明显。但是你对底层系统的机制了解得越多，你就越欣赏它。

【参考方案25】：

我发现默认的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），但它的语法对我来说更清晰

【讨论】：

这似乎比更简单的val = a if cond else b 语句要工作量的两倍、更多的 RAM 使用量和更多的混淆。

另外，a 和 b 每次都在这里进行评估，这与 a if cond else b 不同

【参考方案26】：

其他答案正确地谈论了 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)

【讨论】：

一个有价值的补充，但我不同意：option_value or 10不优于option_value if option_value is not None else 10。它确实更短，但对我来说看起来很奇怪，可能会导致错误。例如，如果option_value = 0 会发生什么？第一个 sn-p 将运行 run_algorithm(0)，因为 option_value 不是 None。然而，第二个和第三个 sn-ps 将运行 run_algorithm(10)，因为 0 是假的。这两个 sn-ps 不等价，因此一个并不比另一个好。而且显式优于隐式。

@ruancomelli：好点。我修改了答案以反映该更正。

至于它看起来很奇怪，我想知道它对您来说是不是很奇怪，因为您注意到了不精确（它并不真正等效）。对我来说这听起来很自然，因为它提醒我用英语说：“使用这个或那个（如果第一个选项不可用）”。但这当然是主观的。知道它对每个人来说并不自然是很有用的。

好多了！并感谢您对“或”成语的解释。这对我来说看起来很奇怪，因为我倾向于将or 视为将两个参数映射到布尔值的函数，所以我希望它返回True 或False（这在许多其他编程语言中都会发生）。但是“使用这个或那个”是一个很好的助记符，肯定会帮助我（希望其他人）记住这种模式。

【参考方案27】：

Vinko Vrsalovic 的回答已经足够好了。还有一件事：

请注意，条件是表达式，而不是语句。这意味着您不能在条件表达式

中使用赋值语句或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。

即使这可能很难看，assignments 可以在 Python 3.8 之后inside 条件表达式完成。无论如何，在这种情况下，最好还是使用普通的if 语句。

【讨论】：

在第一个例子中：(a := 3) if True else (b := 5) 实际上它是一个多余的第一个海象运算符。这样就可以了：a = 3 if True else (b := 5)

@AndrewAnderson 不，这不是多余的。您应该比较第一个和第二个示例。您可以将它们结合起来并考虑：(a := 3) if x else (b := 5)，您总是得到a 或b，而不是两者。但是，考虑a = 3 if x else (b := 5)，当x == False 时，您将得到a = 5 和b = 5，它们都被分配了。

是的，没错:)。我只考虑 x=True 的情况，当然这是有限的。

因为我们并没有真正写下这段代码if True else，所以第一个例子的原因只是和其他例子比较。