Python有三元条件运算符吗？-Java 学习之路

4780

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

24 回答

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

回复于 2024-04-18T10:15:45+08:00

51
@up：

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

对此的一个解决方案是
```
(lambda: falseValue, lambda: trueValue)[test]()
```
（执行延迟到获胜者已知;）），但它引入了可调用和不可调用对象之间的不一致 . 此外，它不能解决使用属性时的情况 .

故事就是这样 - 在3个提到的解决方案之间进行选择是在具有短路功能，使用至少python 2.5（恕我直言不再是问题）和不容易出现“trueValue-evaluates-to-false”之间的权衡错误 .
回复于 2024-04-18T10:15:45+08:00
34
你可以这样做：-

[condition]和[expression_1]或[expression_2];

例：-

print（数字％2和“奇数”或“偶数”）

如果数字是奇数，则打印“奇数”或如果数字是偶数则打印“偶数” .

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

Note :- 0，无，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将不会被计算，因为当exp1不为false时 True and exp1 将为True .

同样在
```
False and exp1 or exp2
```
表达式exp1将不会被计算，因为False等于写0并且0表示“和”本身为0但是在exp1之后使用“或”，它将在“或”之后计算表达式exp2 .

Note:- 这种使用"or"和"and"的分支只能在expression_1不't have a Truth value of False (or 0 or None or emptylist [ ] or emptystring ''时使用 . ）因为如果expression_1变为False，则由于exp_1和exp_2之间存在"or"，将评估expression_2 .

In case you still want to make it work for all the cases regardless of what exp_1 and exp_2 truth values are, do this :-

[condition]和（[expression_1]或1）或[expression_2];
回复于 2024-04-18T10:15:45+08:00

你可能经常会发现

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

回复于 2024-04-18T10:15:45+08:00

是 .

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

回复于 2024-04-18T10:15:45+08:00

170

来自the documentation：

条件表达式（有时称为“三元运算符”）具有所有Python操作的最低优先级 . 表达式x如果C else y首先计算条件，C（不是x）;如果C为真，则计算x并返回其值;否则，将评估y并返回其值 . 有关条件表达式的更多详细信息，请参阅PEP 308 .

自2.5版以来的新版本 .

回复于 2024-04-18T10:15:45+08:00
86

是：

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

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

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

回复于 2024-04-18T10:15:45+08:00

理解，它非常容易理解 .

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

回复于 2024-04-18T10:15:45+08:00

25
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 为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
```
这在语义上是等价的 . 请注意，某些样式指南可能会在明确的基础上限制此用法 - 它确实在非常少的语法中包含了很多含义 .
回复于 2024-04-18T10:15:45+08:00

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

回复于 2024-04-18T10:15:45+08:00

10
是的，您可以这样使用它：
```
is_fat = True
state = "fat" if is_fat else "not fat"
```
阅读有关三元条件运算符的更多信息
回复于 2024-04-18T10:15:45+08:00
47
三元运算符使用不同的编程语言

在这里，我只是尝试在几种编程语言之间显示 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
```
现在你可以看到蟒蛇语言的美丽 . 它具有高度可读性和可维护性 .
回复于 2024-04-18T10:15:45+08:00

5682

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

回复于 2024-04-18T10:15:45+08:00

113

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

回复于 2024-04-18T10:15:45+08:00

265

语法：Ternary运算符将给出：

[on_true] if [expression] else [on_false]

例如

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

回复于 2024-04-18T10:15:45+08:00

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

回复于 2024-04-18T10:15:45+08:00

14
是的，它在版本2.5中是added .
语法是：
```
a if condition else b
```
首先评估 condition ，然后根据 condition 的Boolean值返回 a 或 b
如果 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的"surprising"行为的人使用它时可能会导致错误（它们可能会颠倒顺序） .
- 有些人发现它"unwieldy"，因为它与正常的思想流程相反（首先考虑条件然后考虑影响） .
- 文体原因 .
如果您在记住订单时遇到问题，请记住，如果您大声朗读它，您（几乎）会说出您的意思 . 例如， x = 4 if b > 8 else 9 被大声朗读为 x will be 4 if b is greater than 8 otherwise 9 .

官方文件：
- Conditional expressions
- Is there an equivalent of C’s ”?:” ternary operator?
回复于 2024-04-18T10:15:45+08:00
634
更多的提示而不是答案（不需要在hundreth时间重复显而易见的事情），但我有时会将它用作此类构造中的oneliner快捷方式：
```
if conditionX:
    print('yes')
else:
    print('nah')
```
，成为：
```
print('yes') if conditionX else print('nah')
```
有些（很多:)可能会对它作为unpythonic（甚至是ruby-ish :)皱眉，但我个人认为它更自然 - 即你如何正常表达它，以及在大块代码中更具视觉吸引力 .
回复于 2024-04-18T10:15:45+08:00
13
```
a if condition else b
```
如果您无法记住，请记住这个金字塔：
```
condition
  if           else
a                   b
```
回复于 2024-04-18T10:15:45+08:00
0
作为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]()
```
其中操作数是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")
```
来源：？：在维基百科的Python中
回复于 2024-04-18T10:15:45+08:00
1
对于2.5之前的版本，有诀窍：
```
[expression] and [on_true] or [on_false]
```
当 on_true 具有错误的布尔值时，它可能会给出错误的结果
虽然它确实有从左到右评估表达式的好处，但在我看来更清楚 .

1.是否有相当于C的“？：”三元运算符？
回复于 2024-04-18T10:15:45+08:00
3
对于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版本兼容 .
回复于 2024-04-18T10:15:45+08:00
4
您可以索引到元组：
```
(falseValue, trueValue)[test]
```
test 需要返回True或False .
总是将它实现为以下可能更安全：
```
(falseValue, trueValue)[test == True]
```
或者您可以使用内置的bool()来确保Boolean值：
```
(falseValue, trueValue)[bool(<expression>)]
```
回复于 2024-04-18T10:15:45+08:00

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

回复于 2024-04-18T10:15:45+08:00

Python有三元条件运算符吗？

24 回答

[condition]和[expression_1]或[expression_2];

print（数字％2和“奇数”或“偶数”）

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

以下是它的工作原理：

[condition]和（[expression_1]或1）或[expression_2];

使用说明：

更窄的案例的替代语法：

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

语法：

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

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

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

相关问题