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

a if condition else b

首先计算，然后根据布尔值 计算 或 之一并返回 。如果计算结果为 ，则被计算并返回但被忽略，或者 when 被计算并返回但被忽略。conditionabconditionconditionTrueabba

这允许短路，因为只有 when is true 被评估并且根本不被评估，而 when is false only 被评估并且根本不被评估。conditionabconditionba

例如：

>>> '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 及更高版本中，“walrus”运算符允许将值作为表达式进行简单的赋值，然后与此语法兼容。但请不要这样写代码;它很快就会变得非常难以理解。:=

同样，由于它是一个表达式，因此该部分是必需的：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 不赞成它：

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

如果你在记住顺序时遇到困难，那么请记住，当大声朗读时，你（几乎）说出你的意思。例如，被大声朗读为 。x = 4 if b > 8 else 9x will be 4 if b is greater than 8 otherwise 9

官方文档：

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

从文档中：

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

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

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

从2.5版开始新增功能.

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

[expression] and [on_true] or [on_false]

当具有错误的布尔值时，它可能会给出错误的结果。¹on_true

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

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

您可以索引到元组中：

(falseValue, trueValue)[test]

test需要返回 True 或 False。
始终将其实现为以下形式可能更安全：

(falseValue, trueValue)[test == True]

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

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

不幸的是，

(falseValue, trueValue)[test]

解决方案没有短路行为;因此，无论条件如何，两者都会被评估。这可能是次优的，甚至是错误的（即两者兼而有之，可能是方法，有副作用）。falseValuetrueValuetrueValuefalseValue

对此的一种解决方案是

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

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

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

<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

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

[on_true] if [cond] else [on_false]

在较旧的 Python 中，没有实现三元运算符，但可以模拟它。

cond and on_true or on_false

尽管存在一个潜在的问题，即如果返回 （evareed to and evaates to then） 而不是 .如果你想要这种行为，该方法是可以的，否则使用这个：condTrueon_trueFalseon_falseon_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 版本兼容。

您可能经常会发现

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

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

2006 年，作为 Python 增强提案 308 的一部分，添加了 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]

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

result = (a > b) and x or y

但是，如果是的话，这将不起作用。xFalse

一种可能的解决方法是生成 and 列表或元组，如下所示：xy

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}

Python 有三元条件运算符吗？

是的。从语法文件：

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

感兴趣的部分是：

or_test ['if' or_test 'else' test]

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

expression1 if expression2 else expression3

expression3将被延迟计算（即，仅当在布尔上下文中为 false 时才计算）。由于递归定义，你可以无限期地链接它们（尽管它可能被认为是糟糕的风格）。expression2

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

使用注意事项：

请注意，每个后面都必须跟一个 .学习列表推导式和生成器表达式的人可能会发现这是一个很难学习的课程 - 以下方法不起作用，因为 Python 需要第三个表达式来表达：ifelse

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

这引发了一个 . 因此，以上要么是一段不完整的逻辑（也许用户期望在错误条件下出现空操作），要么是可能打算用作过滤器 - 请注意，以下内容是合法的 Python：SyntaxError: invalid syntaxexpression2

[expression1 for element in iterable if expression2]

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

更窄情况的替代语法：

你可能会发现写以下内容有点痛苦：

expression1 if expression1 else expression2

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

expression1 or expression2

这在语义上是等价的。请注意，一些风格指南可能会出于清晰起见而限制这种用法 - 它确实在很少的语法中包含了很多含义。

与其说是答案，不如说是提示（我不需要第一百次重复显而易见的事情），但我有时会在此类结构中将其用作单行快捷方式：

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

成为：

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

一些（许多:)可能会认为它不是 pythonic（甚至是 Ruby 式:)），但我个人认为它更自然——即，你通常如何表达它，而且在大代码块中更具视觉吸引力。

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

在这里，我只是尝试展示几种编程语言之间三元运算符的一些重要差异。

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

您可以这样做：

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

例：

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

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

---

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

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

除 0 以外的任何数据的计算结果均为 True。

其工作原理如下：

如果条件 [condition] 变为“True”，则将计算expression_1，但不会expression_2。

如果我们用 0（零）来“和”某物，则结果将始终为 false。所以在下面的声明中，

0 and exp

表达式 exp 根本不会被计算，因为带有 0 的“and”将始终计算为零，并且无需计算表达式。这就是编译器本身在所有语言中的工作方式。

在

1 or exp

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

但是在

True and exp1 or exp2

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

同样在

False and exp1 or exp2

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

---

注意：-这种使用 “or” 和 “and” 的分支只能在 expression_1 的 Truth 值不为 False（或 0 或 None 或 emptylist [ ] 或 emptystring ' '.） 时使用，因为如果 expression_1 变为 False，则将评估expression_2，因为 exp_1 和 exp_2 之间存在“or”。

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

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

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

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

a if condition else b

如果你记不住，就记住这个金字塔：

     condition
  if           else
a                   b 

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

<condition> ? <expression1> : <expression2>

起初，Python 的仁慈独裁者（当然，我指的是 Guido van Rossum）拒绝了它（作为非 Python 风格），因为对于不习惯 C 语言的人来说，它很难理解。此外，冒号 ： 在 Python 中已经有很多用途。在 PEP 308 获得批准后，Python 终于收到了自己的快捷条件表达式（我们现在使用的）：

<expression1> if <condition> else <expression2>

因此，首先它评估条件。如果返回 ，则将计算 expression1 以给出结果，否则将计算 expression2。由于延迟计算机制 - 只会执行一个表达式。True

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

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'

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]()

只要使用完全相同的参数调用，就可以正常工作。如果不是，就像在noyes

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 的评论}

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

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

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

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

上述方法自 is 起，解释器在逻辑表达式中将其视为 False。然后解释器继续计算第二个表达式，它不是，也不是一个空列表 - 所以它被分配给 a。li1NoneNone

这也适用于空列表。例如，如果要分配包含项目的任何列表。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 是一种语法丰富的语言，具有许多惯用技巧，这些技巧对于涉猎者来说并不明显。但是，你对底层系统的机制了解得越多，你就越欣赏它。

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

其他答案正确地谈到了 Python 三元运算符。我想通过提及经常使用三元运算符的场景来补充，但对于该场景，有一个更好的成语。这是使用默认值的方案。

假设我们想使用默认值，如果它没有设置：option_value

run_algorithm(option_value if option_value is not None else 10)

或者，如果从未设置为虚假值（、等），则只需option_value0""

run_algorithm(option_value if option_value else 10)

然而，在这种情况下，一个更好的解决方案就是简单地编写

run_algorithm(option_value or 10)

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

请注意，条件语句是一个表达式，而不是一个语句。这意味着您不能在条件表达式中使用赋值语句或其他语句pass

Python 3.8 中的 Walrus 运算符

在 Python 3.8 中引入 walrus 运算符后，情况发生了变化。

(a := 3) if True else (b := 5)

给出 和 ，a = 3b is not defined

(a := 3) if False else (b := 5)

给出 和 和a is not definedb = 5

c = (a := 3) if False else (b := 5)

给出 和 。c = 5a is not definedb = 5

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

Pythonic 的做事方式：

"true" if var else "false"

但是，也总是存在一种不同的三元条件方法：

"true" and var or "false"

if else-if 版本可以写成：

sample_set="train" if "Train" in full_path else ("test" if "Test" in full_path else "validation")

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

你可以使用

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

这相当于：

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

这样，也可以打印两个以上的语句。例如：

if number == 20:
    print("Twenty")
elif number < 20:
    print("Lesser")
elif 30 > number > 20:
    print("Between")
else:
    print("Greater")

可以写成：

print("Twenty" if number == 20 else "Lesser" if number < 20 else "Between" if 30 > number > 20 else "Greater")

是的，它有，但它不同于类似 C 语法的编程语言（后者是condition ? value_if_true : value_if_false

在 Python 中，它是这样的：value_if_true if condition else value_if_false

例：even_or_odd = "even" if x % 2 == 0 else "odd"

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

[on_true] if [expression] else [on_false]

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

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

它仍然很清楚，但要短得多。请注意，表达式可以是任何类型的表达式，包括函数调用，该表达式返回计算结果为 True 或 False 的值。

我有来自设备的数据作为字符串，并将其保留为重建字符串。条件表达式需要受 （） 的限制。这允许有多个条件在一行中构建字符串。如果不是，似乎“其他”之后的任何内容都将被考虑在内。

    d0 = "-679 58 1029"
    d1 = d0.split(" ")

    strg = (d1[0][:-2] if len(d1[0])>= 3 else "0") + " " +d1[0][-2:]+ " "+ (d1[1][:-2] if len(d1[1])>= 3 else "0") + " " + d1[1][-2:] + " " +d1[2]
    print(strg)

是的，Python 有一个三元条件运算符，也称为条件表达式或三元运算符。Python 中三元运算符的语法为：

value_if_true if condition else value_if_false

下面是一个示例来说明其用法：

x = 5
result = "Even" if (x % 2 == 0) else "Odd"
print(result)

在此示例中，条件 x % 2 == 0 检查 x 是否能被 2 整除。如果条件为 True，则将值“Even”分配给变量结果。否则，将分配值“Odd”。输出将是：

Odd

在处理中等复杂度的操作时，最好使用括号，以提高可读性：

"Even" if (x % 2 == 0) else "Odd"

而不是：

"Even" if x % 2 == 0 else "Odd"

三元运算符是一种在一行中编写简单条件表达式的简洁方法。在根据条件赋值或构造表达式时，它特别有用。但是，对于更复杂的条件或更长的表达式，如果可能，通常最好使用 if-else 语句以提高可读性。