提问



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

最佳参考


是的,它是在2.5版本中添加的。

语法是:[106]


a if condition else b


首先评估condition,然后根据condition的布尔值返回ab

如果condition的计算结果为 True a,则返回b[107]


例如:


>>> '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对此感到不满,原因有以下几点:



  • 参数的顺序与许多其他语言(例如C,Ruby,Java等)不同,当不熟悉Python令人惊讶的行为的人使用它时可能会导致错误(他们可能会反转顺序)。

  • 有些人觉得它笨拙,因为它违背了正常的思想流程(先考虑条件然后考虑影响)。

  • 文体原因。



如果你在记住命令时遇到困难,那么请记住,如果你大声读出它,你(几乎)说出你的意思。例如,x = 4 if b > 8 else 9被大声朗读为x will be 4 if b is greater than 8 otherwise 9


官方文件:



  • 条件表达式

  • 是否有相当于C的?:三元运算符?


其它参考1


你可以索引一个元组:[108] [109]


(falseValue, trueValue)[test]


test需要返回 True 或 False 。

总是将它实现为以下可能更安全:


(falseValue, trueValue)[test == True]


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


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

其它参考2


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


[expression] and [on_true] or [on_false]


on_true会给出错误的结果
 具有错误的布尔值。 1

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


<子> 1。是否有相当于C的?:三元运算符? [112]

其它参考3


expression1 如果 condition else expression2


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

其它参考4


来自文件:[113]



  条件表达式(有时称为三元运算符)具有所有Python操作的最低优先级。

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

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



自2.5版以来的新版本。

其它参考5


作为Python增强提案308的一部分,2006年添加了Python中条件表达式的运算符。它的形式与常见的?:运算符不同,它是:[115]


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


操作数被懒惰评估的地方。[116]


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


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


或明确构造的字典:


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


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


result = (a > b) and x or y


然而,如果x False,这将无法奏效。


一个可能的解决方法是使xy列表或元组如下所示:


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


要么:


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


如果您正在使用词典,而不是使用三元条件,您可以利用get(key, default),例如:[117]


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


来源:?:在维基百科的Python中 [118]

其它参考6


@向上:


不幸的是,


(falseValue, trueValue)[test]


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


对此的一个解决方案是


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


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


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

其它参考7


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


[on_true] if [cond] else [on_false]


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


cond and on_true or on_false


虽然,存在一个潜在的问题,如果cond评估为Trueon_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版本兼容。

其它参考8


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



在这里,我试图在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


现在你可以看到蟒蛇语言的美丽。它具有高度可读性和可维护性。

其它参考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


理解,它非常容易理解。


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

其它参考11



  

Python是否有三元条件运算符?




是。从语法文件:[119]


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


感兴趣的部分是:


or_test ['if' or_test 'else' test]


因此,三元条件操作的形式如下:


expression1 if expression2 else expression3


expression3将被懒惰地评估(即,仅在布尔上下文中expression2为假时才进行求值)。而且由于递归定义,你可以无限地链接它们(虽然它可能被认为是糟糕的风格。)


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


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

其它参考12


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

其它参考13


你可以这样做 :-


[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


当exp1不是假时,第二个表达式exp2不会被评估,因为True and exp1将为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] ;


其它参考14


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

其它参考15


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


语法:




  [[on_true]] if [[expression]] 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

其它参考16


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


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


,成为:


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


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

其它参考17


是的,您可以这样使用它:


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



  阅读有关三元条件运算符的更多信息[120]


其它参考18


是。


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

其它参考19


是:


假设你想给变量x赋一些值,如果某些bool是真的,同样如此


如果其他x=10,则X=5


如果[[如果这是真的第一个值评估]],则X=[[某个值]]否则[[其他值评估]]

其它参考20


有一个三元选项,如其他答案中所述,但如果您检查布尔值或无值,您也可以使用或来模拟它:


>>> a = False
>>> b = 5
>>> a or b
5

>>> a = None
>>> a or b
5

其它参考21


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

其它参考22


句法:
三元运营商将被给予:


[on_true] if [expression] else [on_false]


例如


x, y = 25, 50 big = x if x < y else y