python - 三元运算符java - 三目运算符




Python有三元条件运算符吗? (16)

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


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

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


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

在这里,我只是尝试在几种编程语言之间展示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

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


expression1 if 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

三元条件运算符只允许在单行中测试条件替换多行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

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

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

result = (a > b) and x or y

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

可能的解决方法是生成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")

来源: ?:


你可以这样做 :-

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

例:-

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

如果数字是奇数,则打印“奇数”或如果数字是偶数则打印“偶数”。

结果: -如果condition为true,则执行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,而当exp1不为false时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] ;


如果定义了变量并且您想要检查它是否有值,那么您只需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

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

[expression] and [on_true] or [on_false]

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

1. 是否有相当于C的“?:”三元运算符?


您可以索引到元组:

(falseValue, trueValue)[test]

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

(falseValue, trueValue)[test == True]

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

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

是。

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

是的,它是在2.5版本中added
语法是:

a if condition else b

评估第一个condition ,然后根据conditionBoolean值返回ab
如果condition计算结果为True a则返回,否则返回b

例如:

>>> '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 9x = 4 if b > 8 else 9大声朗读x = 4 if b > 8 else 9因为x will be 4 if b is greater than 8 otherwise 9

官方文件:


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

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

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


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

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

,成为:

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

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


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

语法:Ternary运算符将给出:

[on_true] if [expression] else [on_false]

例如

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

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




python-2.5