Python有三元条件运算符吗?

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

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

1	a if condition else b

首先计算condition，然后根据condition的布尔值精确地计算和返回a或b中的一个。如果condition的计算结果是True，那么a被计算和返回，但是b被忽略，或者当b被计算和返回，但是a被忽略。

这允许短路，因为当condition为真时，只计算a而根本不计算b，而当condition为假时，只计算b而根本不计算a。

例如:

1
2
3
4

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

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

1
2
3
4
5

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

在这种情况下，必须使用普通的if语句而不是条件表达式。

请记住，一些毕达哥拉斯学派的人不赞成这样做有以下几个原因:

参数的顺序与许多其他语言(如C、c++、Go、Perl、Ruby、Java、Javascript等)中的经典condition ? a : b三元运算符的顺序不同，当不熟悉Python的"惊人"行为的人使用它时，可能会导致bug(他们可能会颠倒参数的顺序)。有些人认为它"笨拙"，因为它违背了正常的思维流程(先考虑条件，然后考虑效果)。风格的原因。

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

官方文档:

条件表达式是否存在C的等价物?:"三元操作符?

相关讨论

这个顺序对于程序员来说似乎很奇怪，但是对于数学家来说f(x) = |x| = x if x > 0 else -x听起来很自然。在大多数情况下，你也可以把它理解为做A，但当你做C时，你应该做B……
我总是得到一个无效的语法错误。如果填充了变量，那么它应该返回true，从而执行语句。print("OK") if status else print("NOT OK")在if处失败。
一切都很好，但是调整这个家伙可能很难。比较condition
\t? expression1
\t: expression2。
使用这个时要注意操作顺序。例如，行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)进行分组
@Pred在没有from __future__ import print_function的Python 2中失败，因为print是一个语句，而不是函数。
如果在字符串的构造中使用这个，那么注意'a' + 'b' if x else 'c'会给出'ab'或'c'，而不是'ac'，因此要相应地加上括号。
@Pred尝试print("OK" if status else"NOT OK")
@nullgraph真的吗?我得到的是"dog"，而不是foo("dog")。foo("cat") if False else foo("dog")对我很有用。foo("cat") if False else bar("dog")一样
我喜欢这个语法顺序被一个叫@yota的人描述为很自然的模糊讽刺。
如果有多个条件呢?
@MrGeek，你可以对布尔表达式进行分组。"foo" if (bool或bool &bool或etc)否则"bar"
@Dimesio我的意思是像if (c1) a1 elif (c2) a2 elif…其他(n)。
@MrGeek，我明白你的意思了，所以你基本上是在嵌套操作:' foo ' if Bool else (' bar ' if Bool else ' foobar)"
@yota也许你的意思是:在大多数情况下做A，除非不是B，那么你应该做C(反映结构的顺序和意图)。现在你意识到这是多么不直观。
@Hendy Irawan，我们可以为它构造一种自然的语言措辞，既精确又准确;直观:Do thing X as long as the normal check comes up OK; if it's not coming up OK, then go to the backup plan & do thing Y
@NathanSmith，我很确定这不是直觉。想象一下，在现实世界中，有人说:"向左走……如果你是男性。但除此之外，请向右转。"与之相比:"如果你是男性，那就向左走。否则,走吧。"我认为Python三元组可以是"自然"的惟一场景是针对您提到的确切场景，即检查是"OK检查"，而"else"是抛出异常。但是三元组可以用于很多其他的东西，比如数学检查，甚至是嵌套，然后这个语法就会变得很混乱。
@Hendy Irawan同意python三元运算符在过度使用/使用不当时令人困惑。它可以嵌套来创建模糊的单行程序。但我们似乎一致认为，至少有一种情况下，它是相当自然的，所以似乎可以避免问题，如果我们只在这些特定的情况下，它是自然的。
与Ruby的true if true和true unless true相比，这没有那么令人困惑。在Python中强制使用样式是有点愚蠢的，因为其他语言的做法不同(诚然，对于特定的公司或团队来说，这可能是有意义的，这正是样式指南的用途)。如果Python与c++完全相同，那么使用Python就没有意义了。
a if b if c if d else e else f if x if y else z else b if x else y ...
把它写成:(false_result, truth_result)[condition]不是更好吗?
这很好，但我们是程序员，而不是数学家。面对现实吧，这是个愚蠢的决定。
程序员甚至比数学家更需要精确正确的公式，因为在数学中总是有一个诉诸于基本概念的方法。一个令人信服的参数是%运算符，模仿数学中使用"mod"的方式将是一场灾难。所以我不接受你的观点。这就像依附于帝国单位。Groetjes艾伯特
@Pred您可能想知道，它返回一个值:例如name="Sally" if gender=="female" else:"John"。因此，一些东西被分配给name。print语句在Python 2.x中不返回任何东西;Python 3。它返回None。
@yota很好地解释了. .听起来更好理解…
Python中的ternay操作符是否使用条件转移指令?

你可以索引成一个元组:

1	(falseValue, trueValue)[test]

test需要返回True或False。这样做可能更安全:

1	(falseValue, trueValue)[test == True]

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

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

相关讨论

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

1	[expression] and [on_true] or [on_false]

当on_true具有假布尔值。1虽然它确实有从左到右计算表达式的好处，在我看来，这更清晰。

<子> 1。是否存在C的等价物?:"三元操作符? < /订阅>

相关讨论

if条件else

1
2
3
4
5
6

>>> a = 1
>>> b = 2
>>> 1 if a > b else -1
-1
>>> 1 if a > b else -1 if a < b else 0
-1

相关讨论

从文档:

Conditional expressions (sometimes called a"ternary operator") have the lowest priority of all Python operations.

The expression x if C else y first evaluates the condition, C (not x); if C is true, x is evaluated and its value is returned; otherwise, y is evaluated and its value is returned.

See PEP 308 for more details about conditional expressions.

自2.5版以来的新版本。

作为Python增强建议308的一部分，在2006年添加了一个Python条件表达式的运算符。它的形式不同于普通的?:运算符，它是:

1	<expression1> if <condition> else <expression2>

即等于:

1	if <condition>: <expression1> else: <expression2>

举个例子:

1	result = x if a > b else y

可以使用的另一种语法(与2.5之前的版本兼容):

1	result = (lambda:y, lambda:x)[a > b]()

操作数是惰性计算的。

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

1	result = (y, x)[a > b]

或显式构造字典:

1	result = {True: x, False: y}[a > b]

另一种(不太可靠)但更简单的方法是使用and和or运算符:

1	result = (a > b) and x or y

但是，如果x是False，那么这将不起作用。

一种可能的解决方法是如下所示制作x和y列表或元组:

1	result = ((a > b) and [x] or [y])[0]

或者:

1	result = ((a > b) and (x,) or (y,))[0]

如果你使用字典，而不是使用三元条件句，你可以利用get(key, default)，例如:

1	shell = os.environ.get('SHELL',"/bin/sh")

Source: ?: in Python at Wikipedia

相关讨论

@up:

不幸的是,

1	(falseValue, trueValue)[test]

解决方案不具有短路行为;因此，无论条件如何，都要对假价值和真价值进行评估。这可能是次优的，甚至是错误的(例如，真值和假值都可能是方法并有副作用)。

一个解决办法是

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

(延迟执行，直到知道赢家;))，但它引入了可调用对象和不可调用对象之间的不一致性。此外，当使用属性时，它也不能解决这个问题。

因此，在上面提到的3个解决方案中进行选择是在具有短路特性(至少使用python 2.5)和不容易出现"真值-值-假"错误之间进行权衡。

相关讨论

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

1	[on_true] if [cond] else [on_false]

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

1	cond and on_true or on_false

但是，有一个潜在的问题，如果cond计算为True，而on_true计算为False，则返回on_false而不是on_true。如果你想要这个行为的方法是OK，否则使用这个:

1	{True: on_true, False: on_false}[cond is True] # is True, not == True

可以用以下方法包装:

1 2	def q(cond, on_true, on_false) return {True: on_true, False: on_false}[cond is True]

用这种方式:

1	q(cond, on_true, on_false)

它兼容所有Python版本。

相关讨论

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

在这里，我只是想展示几个编程语言之间在ternary operator中的一些重要区别。

Ternary Operator in Javascript

1
2
3
4

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

Ternary Operator in Ruby

1
2
3
4

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

Ternary operator in Scala

1
2
3
4

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

Ternary operator in R programming

1
2
3
4

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

Ternary operator in Python

1
2
3
4

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

相关讨论

你可能经常会发现

1	cond and on_true or on_false

但是当on_true == 0时，就会出现问题

1
2
3
4
5
6

>>> x = 0
>>> print x == 0 and 0 or 1
1
>>> x = 1
>>> print x == 0 and 0 or 1
1

对于一个普通的三元运算符，这个结果在哪里

1
2
3
4
5
6

>>> x = 0
>>> print 0 if x == 0 else 1
0
>>> x = 1
>>> print 0 if x == 0 else 1
1

当然，这非常容易理解。

1
2
3
4

general syntax : first_expression if bool_expression_is_true else second_expression

Example: x= 3 if 3 > 2 else 4
# assigns 3 to x if the boolean expression evaluates to true or 4 if it is false

相关讨论

Does Python have a ternary conditional operator?

是的。从语法文件中:

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

兴趣部分为:

1	or_test ['if' or_test 'else' test]

因此，三元条件运算的形式是:

1	expression1 if expression2 else expression3

expression3将被延迟求值(也就是说，只有当expression2在布尔上下文中为false时才求值)。而且由于递归定义，您可以无限地将它们链接起来(尽管可能会被认为是糟糕的样式)。

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

使用说明:

注意，每个if后面必须跟一个else。学习列表理解和生成器表达式的人可能会发现这是一节很难学的课——下面的方法不起作用，因为Python希望else使用第三个表达式:

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

这就产生了一个SyntaxError: invalid syntax。因此，上面的代码要么是一个不完整的逻辑片段(可能用户希望在false条件下使用no-op)，要么是打算使用expression2作为过滤器——注意，下面是legal Python:

1	[expression1 for element in iterable if expression2]

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

用于更窄的大小写:

你可能会觉得写下面这些有点痛苦:

1	expression1 if expression1 else expression2

expression1必须使用上述用法进行两次计算。如果它只是一个局部变量，那么它可以限制冗余。然而，在这个用例中，一个常见且高性能的python习语是使用or的捷径行为:

1	expression1 or expression2

这在语义上是等价的。注意，一些样式指南可能会出于清晰的原因限制这种用法——它确实将大量的意思压缩到很少的语法中。

相关讨论

模拟python三元运算符。

例如

1 2	a, b, x, y = 1, 2, 'a greather than b', 'b greater than a' result = (lambda:y, lambda:x)[a > b]()

输出:

1	'b greater than a'

相关讨论

三元条件运算符只允许在一行中测试一个条件，而不是多行if-else，这使得代码更紧凑。

语法:

[on_true] if [expression] else [on_false]

1-使用三元运算符的简单方法:

1
2
3
4
5

# 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:的方法

1
2
3
4
5
6
7
8
9
10
11

# 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:

1
2
3
4

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

上述方法可以写成:

1
2
3
4
5
6
7
8
9
10

# 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

相关讨论

你可以这样做:-

[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外的任何数据都为真。

它是这样工作的:

如果条件[condition]变成"True"，那么将计算expression_1，而不是expression_2。如果我们用"and"表示某个值为0(0)，那么结果总是fasle。

0 and exp

表达式exp根本不需要求值，因为带0的"and"总是求值为零，所以不需要求表达式的值。在所有语言中，编译器都是这样工作的。

在

1 or exp

表达式exp根本不会被求值，因为带有1的"or"总是1。所以不必对表达式exp求值，因为结果总是1。(编译器优化方法)。

但是万一

1	True and exp1 or exp2

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

同样在

1	False and exp1 or exp2

表达式exp1不会被求值，因为False等价于写0，用0做"and"本身就是0，但是在使用了"or"之后，它将在"or"之后求表达式exp2的值。

注意:——这种分支使用"或"和"和"时只能使用expression_1没有假的真值(或0或没有或emptylist[]或emptystring ' ')。因为如果expression_1变得虚假,那么expression_2将评估由于存在"或"exp_1和exp_2之间。

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

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

相关讨论

更多的是一个提示而不是一个答案(不需要重复明显的100次)，但有时我在这样的结构中使用它作为一个单一的快捷方式:

1
2
3
4

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

,变成了:

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

有些(许多:)可能会认为它不符合python(甚至ruby-ish:)，但我个人认为它更自然——即您通常如何表达它，加上在大代码块中的视觉吸引力。

相关讨论

1
2
3
4
5
6
7
8
9

In [1]: a = 1 if False else 0

In [2]: a
Out[2]: 0

In [3]: b = 1 if True else 0

In [4]: b
Out[4]: 1

是的，你可以这样用:

1 2	is_fat = True state ="fat" if is_fat else"not fat"

Read more about ternary conditional operator

1	a if condition else b

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

1
2
3

condition
if else
a b

是的，python有一个三元运算符，下面是语法和示例代码来演示相同的操作符:)

1
2
3
4
5
6
7
8

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

相关讨论

语法:三元运算符为:

1	[on_true] if [expression] else [on_false]

如

1
2
3

x, y = 25, 50
big = x if x < y else y
print(big)

相关讨论

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

1	<condition> ? <expression1> : <expression2>

At first, the Python Benevolent Dictator For Life (I mean Guido van Rossum, of course) rejected it (as non-Pythonic style), since it's quite hard to understand for people not used to C language. Also, the colon sign : already has many uses in Python. After PEP 308 was approved, Python finally received its own shortcut conditional expression (what we use now):

1	<expression1> if <condition> else <expression2>

首先，它对条件求值。如果返回True，将计算expression1以给出结果，否则将计算expression2。由于延迟计算机制—只执行一个表达式。

下面是一些例子(条件将从左到右计算):

1
2
3
4

pressure = 10
print('High' if pressure < 20 else 'Critical')

# Result is 'High'

三元运算符可以串联:

1
2
3
4

pressure = 5
print('Normal' if pressure < 10 else 'High' if pressure < 20 else 'Critical')

# Result is 'Normal'

下一条与前一条相同:

1
2
3
4
5
6
7
8
9
10
11

pressure = 5

if pressure < 20:
if pressure < 10:
print('Normal')
else:
print('High')
else:
print('Critical')

# Result is 'Normal'

希望这个有帮助。

是的。

1
2
3

>>> b = (True if 5 > 4 else False)
>>> print b
True

Python条件表达式的一种替代方法如下:

< pre > <代码>{真的:"是的",错误的:"没有 n

操作符是"有条件的"。三元只是意味着它需要三个操作数。我们不叫+"二进制"+运算符。没有理由用条件句继续这样做。无论它比else更快还是更紧凑，都无关紧要。重要的是它是一个表达式，允许它嵌入到其他表达式中。如果使用得当，它可以减少冗余和难以发现差异的机会。

是的:

假设你想给变量x一个值如果某个bool为真，同理

x = 5 if something else x = 10

x = [some value] if [if this is true first value evaluates] else [other value evaluates]

如果变量被定义了你想要检查它是否有值你可以使用a or b

1
2
3
4
5
6
7
8
9
10

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)

将输出

1
2
3
4
5
6

no Input
no Input
no Input
hello
['Hello']
True

相关讨论