Python有三元条件运算符吗？

Question

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

Answer 1

一个简单但有用的技巧是使用：

foo = "True" and test or "False"

Answer 2

Python 的做事方式：

"true" if var else "false"

但也总是存在一种不同的方式来做三元条件：

"true" and var or "false"

Answer 3

正如已经回答的，是的，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：当然，短路评估不是三元运算符，但通常在短路就足够的情况下使用三元。它具有更好的可读性，并且可以链接。

Answer 4

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 语句。

Answer 5

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

Answer 6

是的，在 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?

Answer 7

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

Answer 8

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 来说并不明显。但是你对底层系统的机制了解得越多，你就越欣赏它。

Answer 9

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

Answer 10

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

**

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

**

Answer 11

<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

Answer 12

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

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

Answer 13

不幸的是，

(falseValue, trueValue)[test]

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

一个解决方案是

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

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

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

Answer 14

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

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

Answer 15

许多源自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'

希望这会有所帮助。

Answer 16

a if condition else b

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

     condition
  if           else
a                   b 

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

Answer 18

如果变量被定义并且你想检查它是否有值你可以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

Answer 19

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

Answer 20

你可以这样做：-

[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] ;

Answer 21

作为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}

Answer 22

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

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

Answer 23

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

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

，变成：

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

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

Answer 24

来自the documentation：

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

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

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

自 2.5 版以来的新功能。

Answer 25

你可以索引一个元组：

(falseValue, trueValue)[test]

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

(falseValue, trueValue)[test == True]

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

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

Answer 26

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

[expression] and [on_true] or [on_false]

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

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

Answer 27

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

Answer 28

你可能经常发现

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

Answer 29

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