是的,它是在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 x = 3
File "<stdin>", line 1
pass if False else x = 3
^
SyntaxError: invalid syntax

在这种情况下,您必须使用普通if 语句而不是条件表达式.

请记住,由于以下几个原因,一些Pythonist对此不满意:

• 参数的顺序condition ? a : b与许多其他语言(例如C,C++,Go,Perl,Ruby,Java,Javascript等)的经典三元运算符的顺序不同,当人们不熟悉Python时,这可能会导致错误.令人惊讶的"行为使用它(它们可能会颠倒参数顺序).
• 有些人觉得它"笨拙",因为它与正常的思维流程相反(首先考虑条件然后再考虑影响).
• 文体的原因.

如果您在记住订单时遇到问题,请记住,当您大声朗读时,您(几乎)会说出您的意思.例如,if大声朗读为x = 4 if b > 8 else 9.

官方文件:

• 条件表达式
• 是否有相当于C的"？:"三元运算符？

• 编码器的顺序可能看起来很奇怪,但是`f(x)= | x | = x if x> 0 else -x`对于数学家来说听起来很自然.在大多数情况下,您也可以像A一样理解它,除非C然后你应该做B而不是......
• 使用时请注意操作顺序.例如,行'z = 3 + x如果x <y else y`.如果`x = 2`和'y = 1`,你可能会期望得到4,但它实际上会产生1.`z = 3 +(x,如果x> y,否则y)`是正确的用法.
• 关键是如果你想在评估条件之后执行额外的评估*,比如在结果中添加一个值,你需要在两边添加额外的表达式(`z = 3 + x if x <y否则3 + y`),或者将条件分组(`z = 3 +(x if x <y else y)`或`z =(x if x <y else y)+ 3`)
• @MrGeek,我明白你的意思,所以你会基本上被嵌套操作:`"富"如果布尔其他("酒吧",如果布尔其他"FOOBAR")`
• 程序员甚至比数学家更需要精确正确的公式化，因为在数学中总是诉诸于基础概念。一个令人信服的参数是％运算符，模仿数学中使用“ mod”的方式将是一场灾难。所以不，我不接受你的论点。就像坚持帝国单位一样。Groetjes Albert
• @KalZekdor I read that and expected 1... It took me a few seconds to see how you had to read it to make 4 a possibility.

您可以索引到元组:

(falseValue, trueValue)[test]

test需要返回True或False.
总是将它实现为以下可能更安全:

(falseValue, trueValue)[test == True]

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

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

• 请注意,这个总是评估所有内容,而if/else构造只评估获胜表达式.
• `(lambda:print("a"),lambda:print("b"))[test == true]()`
• 应该注意的是,`[]`中的内容可以是任意表达式.另外,为了安全起见,您可以通过编写`[bool(<expression>)]来明确地测试真实性.`bool()`函数自v2.2.1起已经存在.
• 这对于代码高尔夫而言非常有用,而不是实际的代码.虽然我已经习惯了它,但是当我做一些明显的事情(比如在两个字符串常量之间选择)时,我有时会使用它来简洁.
• 我做了一个类似的技巧 - 只做了一次或两次,但做到了 - 通过索引到一个带有'True`和`False`作为键的字典:`{True:trueValue,False:falseValue} [test]`我不知道这是否效率低,但它至少避免了整个"优雅"与"丑陋"的争论.你没有处理布尔值而不是int的歧义.
• It's a "cool" and interesting idea, no doubt. But real-life code should be easy to read and least error-prone. If one of my developers used this I would ask him to change it. Since IMHO this should not be used in production code, I have down voted the answer.
• 这是python中的惯用语吗？似乎令人困惑，但也许是它的惯例
• [与单身人士的比较应始终使用is / is而非==]（https://www.python.org/dev/peps/pep-0008/#programming-recommendations）
• 如果此技巧始终评估两种可能的结果，并避免跳过代码（“ if”跳过），则可能有助于避免基于定时的算法攻击。

对于2.5之前的版本,有诀窍:

[expression] and [on_true] or [on_false]

当on_true
具有false布尔值时,它可能会给出错误的结果.¹
虽然它确实有从左到右评估表达式的好处,但在我看来更清楚.

_{1. 是否有相当于C的"？:"三元运算符？}

• 解决方法是使用(test和[true_value]或[false_value])[0],这可以避免这个陷阱.
• @volcano你有我的来源吗？
• 三元运算符通常执行得更快(有时为10-25%).
• @OrangeTux [这是反汇编代码](https://tio.run/##bcoxCoAwEETRPqeY0kCwsPQ2kmR1QZOwWQtPH4OClQO/GV65dMtpao2PkkURuBoTIoEG76AOZGeDPol6SoKCCR5xrxH0yvVfeiwpdJ/lgVzH3kDWFOGk37Ha1m4).使用ThomasH建议的方法会更慢.

expression1 if condition else expression2

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,我同意,但知道在没有括号时会发生什么也是有帮助的.在实际代码中,我也倾向于插入明确的parens.

从文档:

表达式x if C else y首先评估条件C(不是x); 如果C为真,则计算x并返回其值; 否则,评估y并返回其值.

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

自2.5版以来的新版本.

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

操作数被懒惰评估的地方.

另一种方法是索引一个元组(与大多数其他语言的条件运算符不一致):

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}

@up:

不幸的是,

(falseValue, trueValue)[test]

解决方案没有短路行为; 因此,无论条件如何,都会评估falseValue和trueValue.这可能是次优的甚至是错误的(即trueValue和falseValue都可能是方法并且有副作用).

对此的一个解决方案是

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

(执行延迟到获胜者已知;)),但它引入了可调用和不可调用对象之间的不一致.另外,它没有解决使用属性时的情况.

故事如此 - 在3个提到的解决方案之间进行选择是在具有短路功能,至少使用python 2.5(恕我直言不再是问题)之间进行权衡,而不是倾向于"trueValue-evaluates-to-false"错误.

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

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

在这里,我试着展示一些ternary operator编程语言之间的一些重要区别.

var a = true ? 1 : 0;
# 1
var b = false ? 1 : 0;
# 0

a = true ? 1 : 0
# 1
b = false ? 1 : 0
# 0

val a = true ? 1 | 0
# 1
val b = false ? 1 | 0
# 0

a <- if (TRUE) 1 else 0
# 1
b <- if (FALSE) 1 else 0
# 0

a = 1 if True else 0
# 1
b = 1 if False else 0
# 0

• 这[博客发现python的三元运算符与大多数其他语言不必要地不同](https://archive.is/yqwSh).
• 听起来似乎很固执；但是从本质上说的是，一个从未见过三元运算符的人很可能会理解Python语法，而除非首先被告知含义，否则很少有人会理解更常见的语法。
• Ruby也可以使用`a = true？1:0`
• Algol68：a=.if。。真的。。然后。1.其他。0 .fi。这也可以表示为 a=(.true.|1|0) 像往常一样，Algol68 是对其继任者的改进。

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

[on_true] if [cond] else [on_false]

在较旧的Pythons中,没有实现三元运算符,但可以模拟它.

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

• 为什么不`bool(cond)`而不是'cond'是真的？前者检查`cond`的真实性,后者检​​查指针与'True`对象的相等性.正如@AndrewCecil强调的那样,``blob'`是真的,但它不是真的.
• 行为不一样 - `q("blob",on_true,on_false)`返回`on_false`,而`on_true如果cond else on_false`返回`on_true`.解决方法是在这些情况下用`cond is not None'替换`cond`,尽管这不是一个完美的解决方案.

你可能经常会发现

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
>>> x = 1
>>> print 0 if x == 0 else 1
1

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

这在语义上是等价的.请注意,某些样式指南可能会在明确的基础上限制此用法 - 它确实在很少的语法中包含了很多含义.

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

"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() and 的评估no()，因为在

(no(), yes())[boolean]  # bad

既no()和yes()评估。

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

• @GrijeshChauhan因为在"compliated"表达式上,例如涉及函数调用等,这将在两种情况下执行.这可能不是想要的.

你可以这样做 :-

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

以下是它的工作原理:

如果条件[条件]变为"真",那么将评估expression_1但不计算表达式_2.如果我们"和"带0(零)的东西,结果总是很明显.所以在下面的陈述中,

0 and exp

表达式exp将不会被评估,因为"和"0将始终求值为零,并且不需要计算表达式.这是编译器本身在所有语言中的工作方式.

在

1 or exp

表达式exp将不会被评估,因为"或"1总是为1.所以它不会费心去评估表达式exp,因为结果将是1.(编译器优化方法).

但是如果是的话

True and exp1 or exp2

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

同样地

False and exp1 or exp2

表达式exp1将不会被计算,因为False相当于写0并且0表示"和"本身是0但是在使用"或"之后的exp1之后,它将在"或"之后计算表达式exp2.

注意: -这种使用"或"和"和"的分支只能在expression_1的Truth值不为False(或0或None或emptylist []或emptystring''时使用.)因为expression_1变为如果为false,则将评估expression_2,因为exp_1和exp_2之间存在"或".

如果您仍然想让它适用于所有情况,无论exp_1和exp_2的真值是什么,请执行以下操作: -

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

三元条件运算符只允许在单行中测试条件替换多行if-else使代码紧凑.

句法 :

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

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

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

附加信息：

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

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

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

更多的提示而不是答案(不需要在hundreth时间重复显而易见的事情),但我有时会将其用作此类构造中的oneliner快捷方式:

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

,成为:

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

有些(很多:)可能会把它当作unpythonic(甚至是ruby-ish :),但我个人认为它更自然 - 即你如何正常表达它,以及在大块代码中更具视觉吸引力.

• 我更喜欢`print('yes',如果conditionX别'nah')`你的答案.:-)

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

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

a if condition else b

如果您在记忆中遇到问题,请记住这个金字塔:

     condition
if           else
a                   b

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

其他答案正确地谈论了 Python 三元运算符。我想通过提及一个经常使用三元运算符但有更好的习惯用法的场景来补充。这是使用默认值的场景。

假设我们想使用option_value默认值（如果未设置）：

run_algorithm(option_value if option_value is not None else 10)

或者，如果option_value从未设置为falsy值（0，""等），简单地

run_algorithm(option_value if option_value else 10)

但是，在这种情况下，更好的解决方案是简单地编写

run_algorithm(option_value or 10)

• As for it looking weird, I wonder if it looked weird to you because you noticed the imprecision (that it was not really equivalent). To me it sounds natural because it reminds me saying in English: "Use this or that (if the first option is unavailable)". But of course that is subjective. It is useful to know it does not look natural to everybody.
• A valuable complement, but I disagree: `option_value or 10` is *not* better than `option_value if option_value is not None else 10`. It is shorter, indeed, but looks weird to me and may lead to bugs. What happens if `option_value = 0`, for instance? The first snippet will run `run_algorithm(0)` because `option_value` is not `None`. The second and third snippets, however, will run `run_algorithm(10)` because `0` is a falsy. The two snippets are not equivalent, and hence one is not better than the other. And explicit is better than implicit.
• Much better! And thanks for the explanation regarding the "or"-idiom. It looks weird to me because I tend to think of `or` as a function mapping two arguments to a boolean, so I expect it to return either `True` or `False` (this happens in many other programming languages). But "use this or that" is a nice mnemonic and will definitely help me (and hopefully others) to remember this pattern.

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 是一种语法丰富的语言，它有许多惯用技巧，但对于笨手笨脚的人来说，这些技巧并不是立即显而易见的。但是，您对底层系统的机制了解和了解得越多，您就越欣赏它。

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

<condition> ? <expression1> : <expression2>

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

希望这可以帮助。