三元運算子英文 Python有三元條件運算符嗎?




三元運算子英文 (19)

是:

假設你想給變量x賦一些值,如果某些bool是真的,同樣如此

如果其他x = 10,則X = 5

如果[如果這是真的第一個值評估],則X = [某個值]否則[其他值評估]

如果Python沒有三元條件運算符,是否可以使用其他語言結構模擬一個?


文檔

條件表達式(有時稱為“三元運算符”)具有所有Python操作的最低優先級。

表達式x if C else y首先計算條件, C不是x ); 如果C為真,則計算x並返回其值; 否則,將評估y並返回其值。

有關條件表達式的更多詳細信息,請參閱PEP 308

自2.5版以來的新版本。


理解,它非常容易理解。

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

三元運算符在不同的編程語言中

在這裡,我只是嘗試在幾種編程語言之間展示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

現在你可以看到蟒蛇語言的美麗。 它具有高度可讀性和可維護性。


對於2.5之前的版本,有訣竅:

[expression] and [on_true] or [on_false]

on_true具有false布爾值時,它可能會給出錯誤的結果。 1
雖然它確實有從左到右評估表達式的好處,但在我看來這更清晰。

1. 是否有相當於C的“?:”三元運算符?


你可以這樣做 :-

[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] ;


三元條件運算符只允許在單行中測試條件替換多行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

@up:

不幸的是,

(falseValue, trueValue)[test]

解決方案沒有短路行為; 因此,無論條件如何,都會評估falseValue和trueValue。 這可能是次優的甚至是錯誤的(即trueValue和falseValue都可能是方法並且有副作用)。

對此的一個解決方案是

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

(執行延遲到獲勝者已知;)),但它引入了可調用和不可調用對象之間的不一致。 此外,它不能解決使用屬性時的情況。

故事就是這樣 - 在3個提到的解決方案之間進行選擇是在具有短路功能,使用至少python 2.5(恕我直言不再是問題)和不容易出現“trueValue-evaluates-to-false”之間的權衡錯誤。


對於Python 2.5及更高版本,有一個特定的語法:

[on_true] if [cond] else [on_false]

在較舊的Pythons中,沒有實現三元運算符,但可以模擬它。

cond and on_true or on_false

但是,存在一個潛在的問題,如果cond計算為True並且on_true計算結果為False則返回on_true而不是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版本兼容。


是。

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

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

是的,您可以這樣使用它:

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

閱讀有關三元條件運算符的更多信息


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

來源: ?:


如果定義了變量並且您想要檢查它是否有值,那麼您只需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

語法:Ternary運算符將給出:

[on_true] if [expression] else [on_false]

例如

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

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

這在語義上是等價的。 請注意,某些樣式指南可能會在明確的基礎上限制此用法 - 它確實在非常少的語法中包含了很多含義。


您可以索引到元組:

(falseValue, trueValue)[test]

test需要返回TrueFalse
總是將它實現為以下可能更安全:

(falseValue, trueValue)[test == True]

或者您可以使用內置的bool()來確保Boolean值:

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

更多的提示而不是答案(不需要在hundreth時間重複顯而易見的事情),但我有時會將它用作此類構造中的oneliner快捷方式:

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

,成為:

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

有些(很多:)可能會皺眉頭(甚至是ruby-ish :),但我個人認為它更自然 - 即你如何正常表達它,以及在大塊代碼中更具視覺吸引力。


是的,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-2.5