Python 有三元条件运算符吗？-IT科技

摘要：问题描述：Python 中是否有三元条件运算符？解决方案 1：是的，它是在 2.5 版本中添加的。表达式语法是：a if condition else b 首先condition计算，然后根据的布尔值计算并返回a或中的一个。如果计算结果为，则计算并返回但被忽略，否则当计算并返回但被忽略时。b`cond...

问题描述：

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

解决方案 1：

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

a if condition else b

首先condition计算，然后根据的布尔值计算并返回a或中的一个。如果计算结果为，则计算并返回但被忽略，否则当计算并返回但被忽略时。b`conditionconditionTrueabba`

这允许短路，因为当condition为真时仅a进行评估而b根本不进行评估，但是当condition为假时仅b进行评估而a根本不进行评估。

例如：

>>> 'true' if True else 'false'
'true'
>>> 'true' if False else 'false'
'false'

请注意，条件语句是表达式，而不是语句。这意味着您不能在条件表达式中使用诸如之类的语句pass或带有的赋值=（或诸如之类的“增强”赋值）：+=

>>> pass if False else pass
  File "<stdin>", line 1
    pass if False else pass
         ^
SyntaxError: invalid syntax

>>> # Python parses this as `x = (1 if False else y) = 2`
>>> # The `(1 if False else x)` part is actually valid, but
>>> # it can't be on the left-hand side of `=`.
>>> x = 1 if False else y = 2
  File "<stdin>", line 1
SyntaxError: cannot assign to conditional expression

>>> # If we parenthesize it instead...
>>> (x = 1) if False else (y = 2)
  File "<stdin>", line 1
    (x = 1) if False else (y = 2)
       ^
SyntaxError: invalid syntax

（在 3.8 及更高版本中，:=“海象”运算符允许简单地将值分配为表达式，然后与此语法兼容。但请不要编写这样的代码；它很快就会变得很难理解。）

类似地，因为它是一个表达式，所以该else部分是强制性的：

# Invalid syntax: we didn't specify what the value should be if the 
# condition isn't met. It doesn't matter if we can verify that
# ahead of time.
a if True

但是，您可以使用条件表达式来分配变量，如下所示：

x = a if True else b

或者例如返回一个值：

# Of course we should just use the standard library `max`;
# this is just for demonstration purposes.
def my_max(a, b):
    return a if a > b else b

可以将条件表达式视为在两个值之间切换。我们可以在“一个值或另一个值”的情况下使用它，无论条件是否满足，我们都会对结果执行相同的操作。我们使用表达式来计算值，然后对其执行某些操作。如果您需要根据条件执行不同的操作，则可以使用普通if 语句。

请记住，它不被一些 Pythonistas 所接受，原因如下：

参数的顺序与condition ? a : b许多其他语言（例如C、C++、Go、Perl、Ruby、Java、JavaScript等）的经典三元运算符的顺序不同，这可能会导致在不熟悉 Python“令人惊讶的”行为的人使用它时出现错误（他们可能会反转参数顺序）。
有些人认为它“难以操作”，因为它违背了正常的思维流程（先考虑条件，再考虑效果）。
风格原因。（尽管“内联if”确实很有用，并使您的脚本更简洁，但它确实使您的代码复杂化）

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

官方文档：

条件表达式
是否存在与 C 语言中的“?:”三元运算符等效的词？

解决方案 2：

您可以对元组进行索引：

(falseValue, trueValue)[test]

test需要返回True或False。

这样实现可能更安全：

(falseValue, trueValue)[test == True]

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

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

解决方案 3：

对于 2.5 之前的版本，有一个技巧：

[expression] and [on_true] or [on_false]

on_true当布尔值为假时，可能会给出错误的结果。1

虽然它确实具有从左到右评估表达式的好处，但在我看来这更清晰。

1.有没有与 C 语言中的“?:”三元运算符等效的运算符？

解决方案 4：

<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

解决方案 5：

来自文档：

条件表达式（有时称为“三元运算符”）在所有 Python 运算中优先级最低。
表达式x if C else y首先评估条件C（非 x）；如果C为真，则评估x并返回其值；否则，评估y并返回其值。
有关条件表达式的更多详细信息，请参阅PEP 308 。

自 2.5 版以来新增。

解决方案 6：

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]

另一种（不太可靠）但更简单的方法是使用andandor运算符：

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：

不幸的是，

(falseValue, trueValue)[test]

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

解决这个问题的一个方法是

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

（执行延迟，直到知道获胜者 ;)），但它引入了可调用对象和不可调用对象之间的不一致。此外，它无法解决使用属性的情况。

trueValue故事就是这样的 - 在上述三种解决方案之间进行选择是在具有短路功能、至少使用 Python 2.5（IMHO，不再是问题）和不易出现“ -evaluates-to-false”错误之间的权衡。

解决方案 8：

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

解决方案 9：

你可能经常会发现

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

解决方案 10：

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

使用说明：

请注意，every 后面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

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

解决方案 11：

Python条件表达式的替代方案之一

"yes" if boolean else "no"

如下：

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

它有以下很好的扩展：

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

最短的替代方案仍然存在

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

其有效是因为issubclass(bool, int)。

但要小心：

yes() if boolean else no()

不是

(no(), yes())[boolean]  # bad: BOTH no() and yes() are called

但

(no, yes)[boolean]()

只要和的调用参数完全相同，这种方法就很好no。yes如果它们不是，比如

yes("ok") if boolean else no()  # (1)

或

yes("ok") if boolean else no("sorry")  # (2)

那么类似的替代方案要么不存在（1），要么几乎不可行（2）。（在极少数情况下，根据上下文，可能会出现类似

msg = ("sorry", "ok")[boolean]
(no, yes)[boolean](msg)

这是有道理的。

感谢 Radek Rojík 的评论

附录：

布尔索引的一个特殊情况是当你需要单个字符时。例如：

sign = '+-'[n < 0]

最后，复数形式s：

print(f"total: {n} item{'s'[n==1:]}")

解决方案 12：

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

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

在许多情况下<expression 1>也用作布尔求值<condition>。然后您可以使用短路求值。

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-circuit 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-circuit evaluation second equals to True
print(foo(0) or bar(1) or blubb(2))
''' blubb is not executed
foo executed
bar executed
1
'''

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

# Short-circuit 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：当然，短路求值不是三元运算符，但在短路就足够的情况下，通常会使用三元运算符。它具有更好的可读性并且可以链式调用。

解决方案 13：

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

解决方案 14：

a if condition else b

如果你记不住的话，只要记住这个金字塔就可以了：

     condition
  if           else
a                   b

解决方案 15：

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。

虽然这可能不太好看，但在 Python 3.8 之后，可以在条件表达式内进行赋值。无论如何，在这种情况下，最好还是使用普通语句。if

解决方案 16：

三元条件运算符仅允许在一行中测试一个条件，取代多行 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])
# lambda 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

解决方案 17：

您可以这样做：

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

例子：

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

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

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

注意： 0、None、False、emptylist 和 emptyString 的计算结果为 False。

任何非 0 的数据都计算为 True。

工作原理如下：

如果条件 [condition] 变为“True”，则将评估 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 不会被求值，因为True and exp1当 exp1 不为假时，exp2 就会为 True。

同样地

False and exp1 or exp2

表达式exp1不会被求值，因为 False 相当于写入 0，并且对 0 进行“与”运算的结果本身将是 0，但是在 exp1 之后，由于使用了“或”，因此它将在“或”之后求值表达式 exp2。

注意：-这种使用“或”和“和”的分支仅可在表达式_1 的真值不为 False（或 0 或 None 或空列表 [ ] 或空字符串 ' '）时使用。因为如果表达式_1 变为 False，则由于表达式_1 和表达式_2 之间存在“或”，因此将对表达式_2 进行求值。

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

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

解决方案 18：

它更多的是一个提示而不是一个答案（我不需要第一百次重复这个显而易见的事情），但有时我会在这样的构造中使用它作为一行快捷方式：

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

，变为：

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

一些人（很多人：）可能会认为它不符合 Python 风格（甚至是 Ruby 风格：），但我个人认为它更自然 - 例如，如何像通常那样表达它，而且在大块代码中更具视觉吸引力。

解决方案 19：

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

<condition> ? <expression1> : <expression2>

起初，Python 的终身仁慈独裁者（我指的是Guido van Rossum，当然）拒绝了它（认为它不是 Pythonic 风格），因为对于不熟悉 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'

解决方案 20：

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

解决方案 21：

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

解决方案 22：

Python 中三元运算符的语法是：

[on_true] if [expression] else [on_false]

使用该语法，我们将如何使用 Python 的三元运算符重写上面的代码：

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

它仍然非常清晰，但更简短。请注意，表达式可以是任何类型的表达式，包括函数调用，它返回计算结果为 True 或 False 的值。

解决方案 23：

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。然后解释器继续并评估第二个表达式，它不是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 是一种语法丰富的语言，有很多惯用技巧，对于初学者来说并不是立即显而易见的。但你学习和理解底层系统机制越多，你就越能欣赏它。

解决方案 24：

用 Python 的方式做事：

"true" if var else "false"

但是也存在一种不同的方法来执行三元条件：

"true" and var or "false"

解决方案 25：

有多种方法。最简单的方法是使用“print”方法中的条件。

您可以使用

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