如果Python没有三元条件运算符,是否可以使用其他语言构造来模拟一个?
是的,它是在2.5版中添加的。表达式语法为:
a if condition else b
第一condition
被评估,则恰好中的任一个a
或b
进行评估并返回基于所述布尔值condition
。如果condition
为True
,a
则被评估并返回但b
被忽略,否则b
被评估为返回但a
被忽略。
这允许发生短路,因为condition
仅当a
评估为true时才进行评估,而b
根本不评估,而当condition
为false评估时,仅b
评估时a
则完全不评估。
例如:
>>> '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
将条件表达式视为在两个值之间切换。当您处于“一个价值或另一个价值”的情况下,它非常有用,但是却无能为力。
如果需要使用语句,则必须使用普通if
语句而不是条件表达式。
请记住,一些Pythonista对此并不满意,原因有几个:
- 参数的顺序与
condition ? a : b
其他许多语言(例如C,C ++,Go,Perl,Ruby,Java,Javascript等)中的经典三元运算符的顺序不同,当人们不熟悉Python的“令人惊讶的”行为使用它(它们可能会颠倒参数顺序)。 - 有些人认为它“笨拙”,因为它与正常的思维流程相反(先思考条件,然后思考效果)。
- 风格上的原因。(尽管“内联
if
”可能确实有用,并且可以使脚本更简洁,但确实会使代码复杂化)
如果您在记住顺序时遇到麻烦,请记住当大声朗读时,您(几乎)说出了您的意思。例如,x = 4 if b > 8 else 9
将朗读为x will be 4 if b is greater than 8 otherwise 9
。
官方文件:
您可以索引到一个元组:
(falseValue, trueValue)[test]
test
需要返回True或False。
始终将其实现为:
(falseValue, trueValue)[test == True]
(falseValue, trueValue)[bool(<expression>)]
对于2.5之前的版本,有个窍门:
[expression] and [on_true] or [on_false]
on_true
布尔值错误时,可能会给出错误的结果。1
尽管这样做确实具有从左到右评估表达式的好处,但我认为这很清楚。
<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
从文档中:
条件表达式(有时称为“三元运算符”)在所有Python操作中的优先级最低。
该表达式
x if C else y
首先计算条件C(not x);如果C为true,则对x求值并返回其值;否则,将评估y并返回其值。有关条件表达式的更多详细信息,请参见PEP 308。
从2.5版开始新增。
作为Python增强建议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]
另一个(不太可靠)但更简单的方法是使用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
不幸的是,
(falseValue, trueValue)[test]
解决方案没有短路行为;因此falseValue
,trueValue
无论条件如何,都对和进行评估。这可能不是最理想的,甚至可能是错误的(即两者兼有,trueValue
并且falseValue
可能是方法并且有副作用)。
一种解决方案是
(lambda: falseValue, lambda: trueValue)[test]()
(执行会延迟到知道获胜者之前;),但是会在可调用对象和不可调用对象之间引入不一致。另外,使用属性时不能解决问题。
故事就这样-在提到的3个解决方案之间进行选择是在具有短路功能,至少使用Зython2.5(恕我直言,不再是问题)和不易于出现“ trueValue
-evaluates-to-false”错误的折衷之间。
不同编程语言的三元运算符
在这里,我只是试图展示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
对于Python 2.5及更高版本,有一种特定的语法:
[on_true] if [cond] else [on_false]
在较旧的Python中,未实现三元运算符,但可以对其进行仿真。
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版本兼容。
您可能经常会发现
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
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期望将其他表达式用作第三个表达式:
[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
对于上述用法,将必须进行两次评估。如果它只是局部变量,则可以限制冗余。但是,此用例的常见且高性能的Python习惯用法是使用or
的快捷方式行为:
expression1 or expression2
在语义上是等效的。请注意,某些样式指南可能出于清楚的目的而限制了此用法-它确实将非常少的语法包含了很多含义。
模拟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'
三元条件运算符仅允许在单行中测试条件,从而代替多行if-else,从而使代码紧凑。
句法 :
如果[表达式],则为[on_true],否则为[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
a if condition else b
如果您难以记住,只需记住这座金字塔:
condition
if else
a b
你可以这样做 :-
[condition] and [expression_1] or [expression_2] ;
例:-
print(number%2 and "odd" or "even")
如果数字为奇数,则将打印“ odd”,如果数字为偶数,则将打印“偶数”。
结果:- 如果条件为true,则执行exp_1,否则执行exp_2。
注意: -0,None,False,emptylist,emptyString计算为False。除0以外的任何数据都将评估为True。
运作方式如下:
如果条件[condition]变为“ True”,则将评估expression_1而不是expression_2。如果我们以0(零)“和”某物,结果将总是令人讨厌。因此,在下面的语句中,
0 and exp
完全不会对表达式exp求值,因为带有0的“ and”将始终求值为零,因此无需求值。这就是编译器本身在所有语言中的工作方式。
在
1 or exp
表达式exp根本不会被求值,因为带有“ 1”的“或”将始终为1。因此,无论如何结果都将为1,因此不必费心计算表达式exp。(编译器优化方法)。
但是在
True and exp1 or exp2
第二个表达式exp2将不被评估,因为True and exp1
当exp1不为false时将为True。
同样在
False and exp1 or exp2
由于False等于写入0,并且用0进行“和”本身将为0,因此不会对表达式exp1进行求值,但是在exp1之后,由于使用了“或”,它将在表达式“或”之后求值exp2。
注意:-仅当expression_1的True值不为False(或0或None或emptylist []或emptystring''。)时,才可以使用这种使用“ or”和“ and”的分支,因为如果expression_1变为False,则由于exp_1和exp_2之间存在“或”,将对表达式_2进行求值。
如果您仍然希望在所有情况下都可以使用它,而不管exp_1和exp_2真值是多少,请执行以下操作:
[condition] and ([expression_1] or 1) or [expression_2] ;
提示多于答案(不需要在第一百遍重复显而易见的内容),但是我有时在这样的结构中将其用作单行捷径:
if conditionX:
print('yes')
else:
print('nah')
,变为:
print('yes') if conditionX else print('nah')
有些(很多:)可能不喜欢它是非Python风格的(甚至是红宝石色的:),但我个人认为它更自然-即您通常的表达方式,并且在较大的代码块中更具视觉吸引力。
Python条件表达式的替代方法之一
"yes" if boolean else "no"
是以下内容:
{True:"yes", False:"no"}[boolean]
具有以下很好的扩展:
{True:"yes", False:"no", None:"maybe"}[boolean_or_none]
最短的选择仍然是:
("no", "yes")[boolean]
但是别无选择
yes() if boolean else no()
如果要避免对yes()
和 求值no()
,因为
(no(), yes())[boolean] # bad
既no()
和yes()
评估。
正如已经回答的那样,是的,在python中有一个三元运算符:
<expression 1> if <condition> else <expression 2>
附加信息:
如果<expression 1>
是这种情况,则可以使用“短罪犯”评估:
a = True
b = False
# Instead of this:
x = a if a else b
# You could use Short-cirquit evaluation:
x = a or b
PS:当然,短路现象不是三元运算符,但是在短路就足够的情况下,通常使用三元运算符。
从中衍生的许多编程语言C
通常具有以下三元条件运算符的语法:
<condition> ? <expression1> : <expression2>
起初,
Python
乙enevolent d ictator ˚F或大号IFE(我的意思是吉多·范罗苏姆,当然)拒绝了(非Python化风格),因为它是挺难理解不习惯的人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'
希望这可以帮助。
是的,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")
其他答案正确地讨论了Python三元运算符。我想通过提及一个经常使用三元运算符但有更好的成语的场景来进行补充。这是使用默认值的情况。
假设我们要使用option_value
未设置的默认值:
run_algorithm(option_value if option_value is not None else 10)
或简单地
run_algorithm(option_value if option_value else 10)
但是,一个更好的解决方案是简单地编写
run_algorithm(option_value or 10)
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
is开始起作用,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是一种语法丰富的语言,具有许多惯用技巧,而这些惯用技巧对Dabler而言并不立即显而易见。但是,您越了解和理解底层系统的机制,您就越会欣赏它。
我发现默认的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),但它的语法对我来说更清晰
如果定义了变量,并且您想检查它是否具有值,则可以 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
链接多个运算符的巧妙方法:
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
is_spacial=True if gender = "Female" else (True if age >= 65 else False)
**
它可以根据需要嵌套。祝你好运
**
文章标签:conditional-operator , operators , python , ternary-operator
版权声明:本文为原创文章,版权归 admin 所有,欢迎分享本文,转载请保留出处!
评论已关闭!