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

Question

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

Answer 1

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

a if condition else b

首先对condition进行评估，然后根据a的{{3}}值评估并返回b或condition中的一个。如果condition评估为True，则评估并返回a但忽略b，否则评估并返回b但a被忽略了。

这允许短路，因为当condition为真时，仅评估a并且根本不评估b，但当condition为假时{{1}评估并且根本不评估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

将条件表达式视为在两个值之间切换。当你处于“一个或另一个”的情况时它非常有用，但它没有做太多其他事情。

如果您需要使用语句，则必须使用普通的x = a if True else b 语句而不是条件表达式。

请记住，一些Pythonist对此感到不满，原因如下：

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

如果您在记住订单时遇到问题，请记住在大声朗读时，您（几乎）说出您的意思。例如，if被大声朗读为x = 4 if b > 8 else 9。

官方文件：

Answer 2

您可以索引元组：

(falseValue, trueValue)[test]

test需要返回 True 或 False 。
总是将其实现为：

可能更安全

(falseValue, trueValue)[test == True]

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

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

Answer 3

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

[expression] and [on_true] or [on_false]

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

<子> 1。 Is there an equivalent of C’s ”?:” ternary operator?

Answer 4

<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

Answer 5

来自the documentation：

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

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

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

自2.5版以来的新版本。

Answer 6

2006年添加了Python中条件表达式的运算符，作为Python Enhancement Proposal 308的一部分。它的形式与普通?:运算符不同，它是：

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

其中操作数为lazily evaluated。

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

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

^{来源：?: in Python at Wikipedia}

Answer 7

不幸的是，

(falseValue, trueValue)[test]

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

对此的一个解决方案是

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

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

故事就是这样 - 在3个提到的解决方案之间进行选择是在具有短路功能之间进行权衡，至少使用Зython2.5（恕我直言不再是问题）而不是“trueValue - 评估 - 错误“错误。

Answer 8

对于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而不是{{} 1}}。如果您想要这种行为，方法就可以了，否则请使用：

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]

它与所有Python版本兼容。

Answer 9

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

在这里，我只是尝试在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

Answer 10

您可能经常会找到

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

Answer 11

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

是。来自grammar file：

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

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

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

Answer 13

你可以这样做： -

<强> `[condition] and [expression_1] or [expression_2] ;`

实施例： -

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

这将打印＆＃34; odd＆＃34;如果数字是奇数或＆＃34;偶数＆＃34;如果数字是偶数。

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

注意： - 0，无，False，空列表，emptyString的计算结果为False。除0以外的任何数据都会计算为True。

以下是它的工作原理：

如果条件[条件]变为＆＃34;真＆＃34;然后，将评估expression_1但不评估expression_2。如果我们＆＃34;和＆＃34; 0（零）的结果，结果总是很明显。所以在下面的陈述中，

0 and exp

表达式exp不会被评估，因为＆＃34;和＆＃34; 0将始终评估为零，无需评估表达式。这就是编译器本身在所有语言中的工作方式。

在

1 or exp

表达式exp不会被评估，因为＆＃34;或＆＃34; 1将始终为1.因此，它无法评估表达式exp，因为无论如何结果都是1。（编译器优化方法）。

但是在

的情况下

True and exp1 or exp2

第二个表达式exp2不会被评估，因为当exp1不是假时，True and exp1将为True。

同样在

中

False and exp1 or exp2

表达式exp1不会被评估，因为False相当于写0并执行＆＃34;和＆＃34; 0为0本身但是在exp1之后，＆＃34;或＆＃34;使用它，它将在＆＃34;或＆＃34;之后评估表达式exp2。

注意： - 这种分支使用＆＃34;或＆＃34;和＆＃34;和＆＃34;只有当expression_1的Truth值为False（或0或None或emptylist []或emptystring＆＃39;。）时才能使用，因为如果expression_1变为False，则表达式2将为评估是因为存在＆＃34;或＆＃34;在exp_1和exp_2之间。

如果您仍想让所有案例都适用，无论exp_1和exp_2的真值是什么，请执行以下操作： -

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

Answer 14

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

Answer 15

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

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

，变为：

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

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

Answer 16

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

<块引用>

请注意，条件是一个表达式，而不是一个语句。这意味着您不能在条件表达式

中使用赋值语句或pass或其他语句

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 语句。

Answer 17

a if condition else b

如果您想不起来，请记住这个金字塔：

     condition
  if           else
a                   b

Answer 18

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

Answer 19

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

<condition> ? <expression1> : <expression2>

起初，Python B 富人 D 煽动者 F 或 L ife（我是指Guido van Rossum拒绝了它（因为它是非Pythonic风格），因为对于不习惯C语言的人们来说很难理解。此外，冒号 : 在Python中已经有很多用途。在批准 PEP 308 之后，Python终于收到了自己的快捷方式条件表达式（我们现在使用的是）：

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

希望这会有所帮助。

Answer 20

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

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

其他信息：

如果满足<expression 1>的条件，则可以使用Short-cirquit evaluation：

a = True
b = False

# Instead of this:
x = a if a else b

# You could use Short-cirquit evaluation:
x = a or b

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

Answer 21

以下是Python conditional expression的替代方法之一：

{True:"yes", False:"no"}[boolean]

具有以下不错的扩展名：

{True:"yes", False:"no", None:"maybe"}[boolean_or_none]

最短的替代遗物：

("no", "yes")[boolean]

但是如果您想避免在以下情况下同时评估yes()和no()，则别无选择：

yes() if [condition] else no()

Answer 22

其他答案正确地讨论了Python三元运算符。我想通过提及一个经常使用三元运算符但有更好的成语的场景来进行补充。这是使用默认值的情况。

假设未设置默认值，我们想使用option_value：

run_algorithm(option_value if option_value is not None else 10)

或者，如果从未将option_value设置为虚假值（0，""等），

run_algorithm(option_value if option_value else 10)

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

run_algorithm(option_value or 10)

Answer 23

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

Answer 24

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

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

Answer 25

三元运算符是用Python编写条件语句的一种方式。顾名思义，此Python运算符由三个操作数组成。

语法：三元运算符中的三个操作数包括：

condition：一个布尔表达式，其值为true或false。

true_val：如果表达式的计算结果为true，则将分配一个值。

false_val：如果表达式的计算结果为false，则将分配一个值。

    var = true_val if condition else false_val

=（赋值）运算符左侧的变量var将被分配：

如果booleanExpression的值为true，则为

value1。

如果booleanExpression的计算结果为false，则为

value2。

示例：

    # USING TERNARY OPERATOR
    to_check = 6
    msg = "Even" if to_check%2 == 0 else "Odd"
    print(msg) 

    # USING USUAL IF-ELSE
    msg = ""
    if(to_check%2 == 0):
    msg = "Even"
    else:
    msg = "Odd"
    print(msg)

Answer 26

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

Answer 27

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

Answer 28

is_spacial=True if gender = "Female" else (True if age >= 65 else False)

**

它可以根据需要嵌套。祝你好运

**

Python有三元条件运算符吗？

28 个答案:

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

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

使用说明：

更窄范围的替代语法：

<强> `[condition] and [expression_1] or [expression_2] ;`

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

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

以下是它的工作原理：

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

语法：

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

2-使用元组，字典和lambda的直接方法：

3-三元运算符可以写为嵌套if-else：

Python 3.8 中的海象运算符

Python有三元条件运算符吗？

28 个答案:

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

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

使用说明：

更窄范围的替代语法：

<强> [condition] and [expression_1] or [expression_2] ;

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

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

以下是它的工作原理：

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

语法：

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

2-使用元组，字典和lambda的直接方法：

3-三元运算符可以写为嵌套if-else：

Python 3.8 中的海象运算符

<强> `[condition] and [expression_1] or [expression_2] ;`

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

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