Python有三元条件运算符吗？

Question

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

Answer 1

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

a如果条件其他b

弗斯特条件被评估，然后正好是其中之一一或b根据布尔值的值条件.如果条件计算结果为真的，然后一被计算并返回，但b被忽略，否则b被计算并返回，但一被忽略。

这允许短路，因为当条件仅为true一被评估和b根本不进行评估，但当条件仅为falseb被评估，并且一根本没有进行评估。

例如：

>>>如果为true，则为“true”，否则为“false”“true”>>>如果为False，则为“true”，否则为“False”“false”

注意，条件句是一个表达，不是陈述。这意味着您不能使用声明例如通过，或分配给=（或“增强”赋值，如+=)，在条件内表达:

>>>如果False，则通过文件“<stdin>”，第1行如果False，则通过^语法错误：无效语法>>>#Python将其解析为`x=（1 if False else y）=2`>>>#“（1 if False else x）”部分实际上有效，但>>>#它不能在`=`的左侧。>>>如果为假，则x=1，否则y=2文件“<stdin>”，第1行语法错误：无法分配给条件表达式>>>#如果我们改为用括号括起来。。。>>>如果为False，则为（x=1），否则为（y=2）文件“<stdin>”，第1行如果为False，则为（x=1），否则为（y=2）^语法错误：无效语法

（在3.8及以上版本中:=“walrus”运算符允许简单赋值作为表达式，然后与此语法兼容。但请不要这样写代码；很快就会变得很难理解。）

类似地，因为它是一个表达式其他的部分是强制性的:

#无效语法：如果#条件不满足。我们是否可以验证这一点并不重要#提前。a如果为True

但是，您可以使用条件表达式来指定变量，如下所示：

x=如果为True，则为a，否则为b

例如，返回一个值：

#当然，我们应该只使用标准库“max”；#这只是为了演示。定义my_max（a，b）：如果a>b，则返回a，否则返回b

将条件表达式视为两个值之间的切换。我们可以在“一个值或另一个值”的情况下使用它做同样的事结果，而不管条件是否满足。我们使用表达式计算值，然后对其进行处理做点不同的事根据情况，然后使用正常如果 陈述而不是。

---

请记住，一些Pythonista出于以下几个原因而对其不屑一顾：

• 参数的顺序与经典的不同条件？甲：乙来自许多其他语言（例如C类,C类++,去吧,Perl语言,红宝石,Java语言,JavaScript脚本等），当不熟悉Python“令人惊讶”的行为的人使用它时，可能会导致错误（他们可能会颠倒参数顺序）。
• 有些人认为它“笨拙”，因为它与正常的思维流（先考虑条件，然后考虑效果）背道而驰。
• 风格原因。（尽管“内联”如果'可以是真正地非常有用，并且使脚本更简洁，这确实会使代码复杂化）

如果你记不清顺序，那么记住大声朗读时，你（几乎）说出了你的意思。例如，如果b>8，则x=4，否则9被大声朗读为如果b大于8，则x为4，否则为9.

官方文件：

• 条件表达式
• C的“？：”是否等效三元运算符？

Answer 2

您可以索引到元组：

（false值，trueValue）[测试]

测试需要返回真的或False（错误）.
最好始终将其实现为：

（falseValue，trueValue）[测试=真]

或者您可以使用内置布尔（）以确保布尔值值：

（falseValue，trueValue）[bool（<表达式>）]

Answer 3

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

[expression]和[on_true]或[on_false]

当真的具有错误的布尔值。¹

虽然它确实有从左到右评估表达式的好处，但在我看来这一点更为明确。

_{1C的“？：”是否等效三元运算符？}

Answer 4

<表达式1> 如果 <条件> 其他的 <表达式2>

a=1b=2如果a>b其他-1，则为1#输出为-11如果a>b else-1如果a<b else 0#输出为-1

Answer 5

发件人文档:

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

表达式x如果C其他y首先评估条件，C类(不是x); 如果C类是真的，x个计算并返回其值；否则，年计算并返回其值。

请参阅第308页有关条件表达式的更多详细信息。

自2.5版以来的新增功能。

Answer 6

Python中的条件表达式的运算符是在2006年添加的Python增强建议308.其形式不同于普通?:操作符，如下所示：

<表达式1>如果<条件>其他<表达式2>

相当于：

如果<条件>：<表达式1>其他：<表达式2>

下面是一个示例：

结果=x，如果a>b其他y

可使用的另一种语法（与2.5之前的版本兼容）：

结果=（λ：y，λ：x）[a>b]（）

其中操作数是懒散地评估.

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

结果=（y，x）[a>b]

或显式构造的字典：

结果={True:x，False:y}[a>b]

另一种（不太可靠）但更简单的方法是使用和和或操作员：

结果=（a>b）和x或y

然而，如果x个将是False（错误）.

一个可能的解决方法是x个和年列表或元组，如下所示：

结果=（（a>b）和[x]或[y]）[0]

或：

结果=（（a>b）和（x，）或（y，））[0]

如果您使用字典，而不是使用三元条件，则可以利用get（键，默认），例如：

shell=os.environ.get（'shell'，“/bin/sh”）

^{资料来源：?: 维基百科上的Python}

Answer 7

不幸的是

（false值，trueValue）[测试]

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

一个解决方案是

（λ：假值，λ：真值）[测试]（）

（执行延迟到获胜者已知为止；），但这会导致可调用对象和不可调用对象之间的不一致。此外，它不能解决使用属性时的情况。

故事是这样的——在上述三种解决方案之间进行选择是在具有短路功能、至少使用Python 2.5（IMHO，不再是问题）和不容易“trueValue（真实值）-evaluates-to-false”错误。

Answer 8

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

[on_true]如果[cond]其他[on_false]

在旧的Pythons中，三元运算符没有实现，但可以进行模拟。

cond和on_true或on_false

虽然有一个潜在的问题，那就是如果康德计算结果为真的和_真计算结果为False（错误）然后失败（_F）返回而不是真的。如果你想要这种行为，方法是可以的，否则使用：

{True:on_True，False：on_False}[条件为True]#为True，not==True

可通过以下方式包装：

定义q（cond，on_true，on_false）return{True:on_True，False：on_False}[条件为True]

并以此方式使用：

q（cond，on_true，on_false）

它与所有Python版本兼容。

Answer 9

你可能经常会发现

cond和on_true或on_false

但当ontrue==0时，这会导致一个问题

>>>x=0>>>打印x==0和0或11>>>x=1>>>打印x==0和0或11

对于一个正常的三元运算符，您期望得到这样的结果：

>>>x=0>>>如果x==0，则打印0，否则打印10>>>x=1>>>如果x==0，则打印0，否则打印11

Answer 10

Python有三元条件运算符吗？

对。来自语法文件:

test:or_test['if'或_test'else'测试]| lambdef

感兴趣的部分是：

或_测试[“if”或_测试“else”测试]

因此，三元条件运算的形式如下：

表达式1 if表达式2 else表达式3

表达式3将被延迟计算（即，仅当表达式2在布尔上下文中为false）。由于递归定义，您可以无限期地将它们链接起来（尽管这可能被认为是糟糕的风格）

表达式1 if表达式2 else表达式3 if表达式4 else表达式5，依此类推

用法说明：

请注意，每如果后面必须跟一个其他的。学习列表理解和生成器表达式的人可能会发现这是一个很难学习的课程-以下内容行不通，因为Python希望第三个表达式用于else：

[expression1 if expression2 for iterable中的元素]#^--此处需要其他

这引发了一个SyntaxError:无效语法.因此，以上要么是一个不完整的逻辑片段（可能用户期望在错误的条件下出现no-op），要么可能打算使用表达式2作为过滤器-注意以下是合法的Python：

[expression1 for iterable if expression2]中的元素

表达式2用作列表理解的过滤器不三元条件运算符。

适用于更窄情况的替代语法：

您可能会发现写以下内容有些痛苦：

表达式1 if表达式1 else表达式2

表达式1必须使用上述用法进行两次评估。如果它只是一个局部变量，那么它可以限制冗余。然而，在这种情况下，一个常见且有表现力的Python习语是或的快捷方式行为：

表达式1或表达式2

这在语义上是等价的。请注意，一些风格指南可能会以清晰为由限制这种用法——它确实在很少的语法中包含了很多意义。

Answer 11

Python的替代方案之一条件表达式

如果布尔值为“否”，则为“是”

如下所示：

{True：“是”，False：“否”}[布尔值]

它有以下漂亮的扩展：

{True:“是”，False：“否”，None:“可能”}[boolean_or_None]

最短的备选方案仍然存在

（“否”，“是”）[布尔值]

这起作用是因为issubclass（布尔，int）.

不过要小心：

yes（）if boolean else no（）

是不

（no（），yes（））[boolean]#bad:调用no（）和yes（

但是

（否，是）[布尔值]（）

只要不和对将使用完全相同的参数调用。如果不是，就像

yes（“ok”）if boolean else no（）#（1）

或在中

yes（“ok”）if boolean else no（“对不起”）#（2）

那么，类似的替代方案要么不存在（1），要么几乎不可行（2）。（在极少数情况下，根据上下文

msg=（“对不起”，“好”）[布尔值]（否，是）[布尔值]（消息）

可能有道理。）

_{感谢Radek Rojík的评论}

---

附录：

布尔索引的一个特殊情况是需要单个字符。例如。：

符号=“+-”[n<0]

最后，复数秒:

打印（f“总计：{n}项{的'[n==1:]}”）

Answer 12

如前所述，是的，Python中有一个三元运算符：

<表达式1>如果<条件>其他<表达式2>

在许多情况下<表达式1>也用作计算的布尔值<条件>。然后您可以使用短路求值.

a=0b=1#而不是这样：x=a如果a其他b#计算为“a if bool（a）else b”#您可以使用短路评估：x=a或b

短路评估的一大优点是可以链接两个以上的表达式：

x=a或b或c或d或e

使用函数时，其细节会有更大的不同：

#评估功能：定义foo（x）：打印（“未执行”）返回x定义栏（y）：打印（“已执行”）返回y定义blubb（z）：打印（“已执行块”）返回z#三元运算符表达式1等于False打印（如果foo（0）else栏（1），则为foo（零））“”foo和bar执行一次已执行foo执行的酒吧1'''#三元运算符表达式1等于True打印（如果foo（2）else栏（3））“”foo执行了两次！已执行foo已执行foo2'''#短路评估秒等于真打印（foo（0）或bar（1）或blubb（2））未执行“”blubb已执行foo执行的酒吧1'''#第三次短路评估等于True打印（foo（0）、bar（0）或blubb（2））'''foo已执行执行的酒吧已执行blubb2'''#短路评估均等于False打印（foo（0）、bar（0）或blubb（0））“”结果为0（来自blubb（0）），因为没有值等于True已执行foo执行的酒吧已执行blubb0'''

PS：当然，短路评估不是三元运算符，但通常在短路足够的情况下使用三元运算符。它具有更好的可读性，并且可以链接。

Answer 13

模拟Python三元运算符。

例如

a、 b，x，y=1,2，‘a大于b’，‘b大于a’结果=（λ：y，λ：x）[a>b]（）

输出：

“b大于a”

Answer 14

a如果条件其他b

如果你记起来有困难，就记住这个金字塔：

条件如果不是这样a b

Answer 15

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

注意，条件句是一个表达，不是陈述。这意味着您不能使用赋值语句或通过或其他声明在条件内表达

Python 3.8中的Walrus操作符

在海象操作员在Python 3.8中引入，有些地方发生了变化。

（a:=3）如果为真（b:=5）

给予a=3和b未定义,

（a:=3）如果为假（b:=5）

给予a未定义和b=5、和

c=（a:=3）如果为假（b:=5）

给予c=5,a未定义和b=5.

即使这可能很难看，作业可以完成里面Python 3.8之后的条件表达式。无论如何，还是使用普通的如果 陈述而在这种情况下。

Answer 16

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

语法：

[on_true]if[expression]else[on_false]

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

#演示条件运算符的程序a、 b=10、20#如果a<b else Copy b，则以min为单位复制a的值min=a如果a<b其他b打印（分钟）#输出：10

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

#演示三元运算符的Python程序a、 b=10、20#使用元组选择项目打印（（b，a）[a<b]）#使用字典选择项目打印（{True:a，False:b}[a<b]）#lambda比上述两种方法更有效#因为在兰姆达，我们确信#与中不同的是，只计算一个表达式#元组和字典print（（lambda:b，lambda:a）[a<b]（））#在输出中应该看到三个10

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

#演示嵌套三元运算符的Python程序a、 b=10、20打印（“如果a==b其他”a大于b，则a和b都相等”如果a>b，则“b大于a”）

上述方法可以写成：

#演示嵌套三元运算符的Python程序a、 b=10、20如果a！=b：如果a>b:打印（“a大于b”）其他：打印（“b大于a”）其他：打印（“a和b都相等”）#输出：b大于a

Answer 17

您可以这样做：

[条件]和[表达式1]或[表达式2]；

例子：

打印（数字%2和“奇数”或“偶数”）

如果数字是奇数，则打印“奇数”；如果数字是偶数，则显示“偶数”。

---

结果是：如果条件为true，则执行exp_1，否则执行exp_2。

注：0、None、False、emptylist和emptyString的计算结果为False。

并且除0以外的任何数据都将计算为True。

其工作原理如下：

如果条件[条件]变为“True”，那么将计算expression_1，而不是expression_2。

如果我们用0（零）表示“和”某个事物，结果将始终为false。所以在下面的陈述中，

0和exp

表达式经验不会被求值，因为带有0的“and”将始终求值为零，并且不需要对表达式求值。这就是编译器本身在所有语言中的工作方式。

在

1或exp

表达式经验不会被计算，因为带1的“or”总是1。所以不用费心计算表达式exp，因为结果无论如何都是1（编译器优化方法）。

但如果

True和exp1或exp2

第二个表达式exp2将不会求值，因为True和exp1exp1不为假时为True。

类似于

False和exp1或exp2

表达式经验1不会被计算，因为False相当于写入0，用0执行“and”本身就是0，但在使用exp1之后，因为使用了“or”，它将在“or”之后计算表达式exp2。

---

注：-只有当expression_1的Truth值不为False（或0或None或emptylist[]或emptystring“”）时，才能使用使用“or”和“and”的这种分支，因为如果expression_1变为False，那么将计算expression_2，因为exp_1和exp_2之间存在“or”。

如果您仍然想使其适用于所有情况，无论exp_1和exp_2真值是什么，请执行以下操作：

[条件]和（[表达式1]或1）或[表达式2]；

Answer 18

与其说是答案，不如说是提示（我不需要第一百次重复这些显而易见的东西），但我有时会将其用作此类结构中的一行快捷方式：

如果条件X：打印（“是”）其他：打印（'nah'）

，变为：

打印（'yes'）if conditionX else打印（'nah'）

有些人（许多人：）可能会觉得它不太符合语法（甚至是Ruby-ish：），但我个人觉得它更自然——也就是说，你通常是怎么表达的，再加上在大块代码中更具视觉吸引力。

Answer 19

许多编程语言源于C类三元条件运算符通常具有以下语法：

<条件><表达式1>：<表达式2>

首先，Python的仁慈的终身独裁者（我的意思是吉多·范罗苏姆当然）拒绝了它（作为非Python风格），因为对于不习惯C语言的人来说很难理解。还有结肠标志:在Python中已经有很多用途。之后政治公众人物308获得批准后，Python终于收到了自己的快捷条件表达式（我们现在使用的）：

<表达式1>如果<条件>其他<表达式2>

因此，首先对条件进行评估。如果它返回真的,表达式1将进行评估以给出结果，否则表达式2将进行评估。由于惰性评估mechanics–只执行一个表达式。

以下是一些示例（条件将从左到右进行评估）：

压力=10打印（如果压力<20，则为“高”，否则为“严重”）#结果为“高”

三元运算符可以串联：

压力=5打印（如果压力<10则为“正常”，如果压力<20则为“高”，否则为“严重”）#结果为“正常”

以下与前一个相同：

压力=5如果压力＜20：如果压力<10：打印（“正常”）其他：打印（“高”）其他：打印（“关键”）#结果为“正常”

Answer 20

是的，Python有一个三元运算符，下面是语法和示例代码以演示相同的操作：）

#[On true]if[expression]else[On false]#如果表达式的计算结果为true，则将传递On true，否则传递On falsea=输入（“输入第一个数字”）b=输入（“输入第二个数字”）如果A>b否则打印（“b更大”），则打印（“A更大”

Answer 21

其他答案正确地谈到了Python三元运算符。我想补充一下一个场景，其中经常使用三元运算符，但有更好的习惯用法。这是使用默认值的场景。

假设我们想使用选项值如果未设置，则使用默认值：

run_algorithm（如果option_value不是None else 10，则为option_value）

或者，如果选项值从未设置为错误值(0,""等），简单地说

run_algorithm（option_value if option_value else 10）

然而，在这种情况下，更好的解决方案是简单地写

run_algorithm（option_value或10）

Answer 22

Python中三元运算符的语法为：

[on_true]if[expression]else[on_false]

使用该语法，下面是我们如何使用Python的三元运算符重写上述代码：

game_type='主页'如果game_type=='home'其他为'green'，则衬衫='white'

它仍然很清晰，但要短得多。请注意，表达式可以是任何类型的表达式，包括返回值为True或False的函数调用。

Answer 23

Python具有三元形式的赋值；然而，可能还有一种人们应该注意的更短形式。

通常需要根据条件为变量赋值。

>>>li1=无>>>li2=[1,2,3]>>>>>>如果li1：…a=li1…其他：…a=li2...>>>一个[1, 2, 3]

^这是完成此类作业的长形式。

下面是三元形式。但这不是最简洁的方式——请参阅最后一个示例。

>>>a=li1如果li1其他li2>>>>>>一个[1, 2, 3]>>>

使用Python，您可以简单地使用或用于替代作业。

>>>a=li1或li2>>>>>>一个[1, 2, 3]>>>

上述工作自锂1是无解释器在逻辑表达式中将其视为False。然后解释器继续并计算第二个表达式，该表达式不是无而且它不是一个空列表，所以它被分配给一.

这也适用于空列表。例如，如果要分配一无论清单上有什么项目。

>>>li1=[]>>>li2=[1，2，3]>>>>>>a=li1或li2>>>>>>一个[1, 2, 3]>>>

了解了这一点，您可以在遇到此类任务时简化它们。这也适用于字符串和其他迭代器。你可以分配一不为空的字符串。

>>>s1=“”>>>s2=“你好世界”>>>>>>a=s1或s2>>>>>>一个“你好，世界”>>>

我一直喜欢C三元语法，但Python更进一步了！

我理解有些人可能会说这不是一个好的风格选择，因为它依赖于并非所有开发人员都能立即看到的机制。我个人不同意这种观点。Python是一种语法丰富的语言，它有许多惯用技巧，但对涉猎者来说，这些技巧并不明显。但你对底层系统的机制了解得越多，你就越欣赏它。

Answer 24

Python式做事方式：

如果var else为“false”，则为“true”

但也总是存在一种不同的方法来处理三元条件：

“true”和var或“false”

Answer 25

有多种方式。最简单的方法是使用“print”方法中的条件。

你可以使用

打印（如果数字==20，则为“二十”，否则为“不二十”）

这相当于：

如果数字==20：打印（“二十”）其他：打印（“非二十”）

这样，还可以打印两个以上的语句。例如：

如果数字==20：打印（“二十”）elif编号<20：打印（“较小”）elif 30>编号>20：打印（“中间”）其他：打印（“更大”）

可以写为：

打印（如果数字==20，则为“二十”；如果数字<20，则表示“较小”；如果30，则表示为“介于”；如果20，则表明为“较大”）

Answer 26

这个如果其他-如果版本可以写为：

sample_set=“train”if在full_path else中“train”（“test”if“test”in full_path else“validation”）

Answer 27

是的，它有，但它不同于C语法类编程语言（条件？value_if_true：值_if_false

在Python中，它是这样的：如果条件为true，则为value_if_false

例子：even_or_odd=“偶数”，如果x%2==0，则为“奇数”

Answer 28

链接多个操作员的简洁方法：

f=λx，y：如果x>y，则为“较大”；如果y>x，则为”较小“数组=[（0,0），（0,1），（1,0）对于数组中的：x、 y=a[0]，a[1]打印（f（x，y））#输出为：#相等，#更少，#更大，#相等

Answer 29

我找到了默认的Python语法val=如果条件为b，则为a很麻烦，所以有时我会这样做：

iif=λ（cond，a，b）：a如果cond否则b#所以我可以这样使用它：val=iif（秒，a，b）

当然，它的缺点是总是评估双方(一和b)，但语法对我来说更清楚了。

Answer 30

我将来自设备的数据作为字符串，并将其保留为重建字符串。条件表达式需要受（）限制。这允许有多个条件在一行中构建字符串。如果不是的话，似乎在“else”之后什么都会被计算在内。

d0=“-679 58 1029”d1=d0.拆分（“”）strg=（d1[0][：-2]if len（d1[0]）>=3 else“0”）+“”+d1[0][-2:]+“”+（d1[1][：-2-]if lang（d1\1]）>=3 else“”0“）+“打印（strg）