පයිතන්ට ත්‍රිමාණ කොන්දේසි සහිත ක්‍රියාකරුවෙකු නොමැති නම්, වෙනත් භාෂා ව්‍යුහයන් භාවිතා කරමින් එකක් අනුකරණය කළ හැකිද?

ඔව්, එය 2.5 අනුවාදයේ එකතු කරන ලදි . ප්‍රකාශන වාක්‍ය ඛණ්ඩය:

a if condition else b

පළමුව conditionඇගයීමට ලක් කරනු ලැබේ, පසුව හරියටම එකක් aහෝ bතක්සේරු කර ආපසු ලබා දෙනුයේ බූලියන් අගය මත පදනම්වය condition. conditionඇගයීමට ලක් කරන්නේ නම් True, පසුව aඇගයීමට ලක් කර ආපසු ලබා දෙනු bලැබේ, නමුත් නොසලකා හරිනු ලැබේ, නැතහොත් bඇගයීමට ලක් කර ආපසු ලබා දෙන විට aනොසලකා හරිනු ලැබේ.

මෙය කෙටි පරිපථයකට ඉඩ සලසයි, මන්ද conditionසත්‍යය විටදී පමණක් aඇගයීමට ලක් කෙරෙන අතර bඑය කිසිසේත් ඇගයීමට ලක් නොකෙරේ, නමුත් conditionඅසත්‍ය වූ විට පමණක් 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 ප්‍රකාශයක් භාවිතා කළ යුතුය .

හේතු කිහිපයක් නිසා සමහර පයිතොනිස්ටා විසින් එය කෝපයට පත් කර ඇති බව මතක තබා ගන්න:

• තර්ක වල අනුපිළිවෙල condition ? a : bවෙනත් බොහෝ භාෂාවලින් (සී, සී ++, ගෝ, පර්ල්, රූබි, ජාවා, ජාවාස්ක්‍රිප්ට් වැනි) සම්භාව්‍ය ත්‍රික ක්‍රියාකරුගේ ක්‍රමයට වඩා වෙනස් වන අතර එමඟින් පයිතන්ගේ නුහුරු පුද්ගලයින් දෝෂ ඇති විය හැක. පුදුම සහගත "හැසිරීම එය භාවිතා කරයි (ඔවුන් තර්ක අනුපිළිවෙල ආපසු හැරවිය හැක).
• සමහරු එය සාමාන්‍ය චින්තනයේ ප්‍රවාහයට පටහැනි බැවින් එය “නොසැලකිලිමත්” ලෙස සලකති (පළමුව තත්වය ගැන සිතීම හා පසුව ඇතිවන බලපෑම්).
• ශෛලීය හේතු. ('පේළිය if' සැබවින්ම ප්‍රයෝජනවත් විය හැකි අතර , ඔබේ ස්ක්‍රිප්ට් වඩාත් සංක්ෂිප්ත කළද , එය ඇත්ත වශයෙන්ම ඔබේ කේතය සංකීර්ණ කරයි)

ඔබට ඇණවුම මතක තබා ගැනීමේ අපහසුතාවයක් තිබේ නම්, ශබ්ද නඟා කියවන විට ඔබ (පාහේ) ඔබ අදහස් කරන දේ පවසන බව මතක තබා ගන්න. උදාහරණයක් ලෙස, x = 4 if b > 8 else 9ශබ්ද නඟා කියවනු ලැබේ x will be 4 if b is greater than 8 otherwise 9.

නිල ලියකියවිලි:

• කොන්දේසි සහිත ප්‍රකාශන
• C හි ”?:” ටර්නරි ක්‍රියාකරුට සමානද?

ඔබට ටුපල් එකකට සුචිගත කළ හැකිය:

(falseValue, trueValue)[test]

testසත්‍ය හෝ අසත්‍යය ආපසු ලබා දිය යුතුය .
සෑම විටම එය ක්‍රියාත්මක කිරීම ආරක්ෂිත විය හැකිය:

(falseValue, trueValue)[test == True]

හෝ ඔබට බූලියන් අගයක් bool()සහතික කිරීම සඳහා සාදන ලද භාවිතා කළ හැකිය :

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

2.5 ට පෙර අනුවාද සඳහා, උපක්‍රමය තිබේ:

[expression] and [on_true] or [on_false]

on_true ව්‍යාජ බූලියන් අගයක් ඇති විට එය වැරදි ප්‍රති results ල ලබා දිය හැකිය . ¹
ප්‍රකාශන වමේ සිට දකුණට තක්සේරු කිරීමේ වාසිය එයට තිබුණද, එය මගේ මතය අනුව පැහැදිලි ය.

_{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

සිට ලේඛගතකිරීම :

සියලුම පයිතන් මෙහෙයුම් වල අවම ප්‍රමුඛතාවය කොන්දේසි සහිත ප්‍රකාශන (සමහර විට “ත්‍රික ක්‍රියාකරු” ලෙස හැඳින්වේ) ඇත.

ප්‍රකාශනය x if C else yමුලින්ම තත්වය තක්සේරු කරයි, සී ( x නොවේ ); නම් සී සැබෑ වන අතර, x ඇගයීමට ලක් වන අතර එහි වටිනාකම ආපසු ඇත; එසේ නොමැතිනම්, y ඇගයීමට ලක් කර එහි වටිනාකම ආපසු ලබා දෙනු ලැබේ.

කොන්දේසි සහිත ප්‍රකාශන පිළිබඳ වැඩි විස්තර සඳහා PEP 308 බලන්න .

2.5 අනුවාදයේ සිට නව.

පයිතන්හි කොන්දේසි සහිත ප්‍රකාශනයක් සඳහා ක්‍රියාකරුවෙකු 2006 දී පයිතන් වැඩිදියුණු කිරීමේ යෝජනාව 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]()

එහිදී ඔපෙරන්ඩ් කම්මැලි ලෙස ඇගයීමට ලක් කෙරේ .

තවත් ක්‍රමයක් නම්, ටුපල් එකක් සුචිගත කිරීමයි (එය වෙනත් බොහෝ භාෂාවල කොන්දේසි සහිත ක්‍රියාකරුට අනුකූල නොවේ):

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පහත සඳහන් පරිදි ලැයිස්තු හෝ tuples:

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

^{මූලාශ්‍රය: ?: විකිපීඩියාවේ පයිතන් හි}

අවාසනාවකට මෙන්

(falseValue, trueValue)[test]

විසඳුමට කෙටි පරිපථ හැසිරීම් නොමැත; මේ අනුව දෙකම falseValueසහ trueValueතත්වය නොසලකා ඇගයීමට ලක් කෙරේ. මෙම වියලි හෝ සපිරි විය හැකි (එනම් දෙකම trueValueහා falseValueක්රම විය යුතු අතර අතුරු බලපෑම් ඇති විය හැකි).

මේ සඳහා එක් විසඳුමක් වනු ඇත

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

(ජයග්‍රාහකයා දැන ගන්නා තෙක් ක්‍රියාත්මක කිරීම ප්‍රමාද වේ;)), නමුත් එය කැඳවිය හැකි සහ කැඳවිය නොහැකි වස්තූන් අතර නොගැලපීමක් හඳුන්වා දෙයි. ඊට අමතරව, දේපල භාවිතා කිරීමේදී එය නඩුව විසඳන්නේ නැත.

කතාව ඉදිරියට යයි - සඳහන් කළ විසඳුම් 3 ක් අතරින් තෝරා ගැනීම කෙටි පරිපථ අංගයක් තිබීම, අවම වශයෙන් අයිතන් 2.5 (IMHO තවදුරටත් ගැටළුවක් නොවේ) භාවිතා කිරීම සහ " trueValue-අවස්ථා-සිට-අසත්‍ය" දෝෂ වලට ගොදුරු නොවීම අතර හුවමාරුවකි. .

විවිධ ක්‍රමලේඛන භාෂාවල තෘතීය ක්‍රියාකරු

මෙන්න මම ternary operatorක්‍රමලේඛන භාෂා කිහිපයක් අතර වැදගත් වෙනසක් පෙන්වීමට උත්සාහ කරමි .

ජාවාස්ක්‍රිප්ට් හි තෘතීය ක්‍රියාකරු

var a = true ? 1 : 0;
# 1
var b = false ? 1 : 0;
# 0

රූබි හි තෘතීය ක්‍රියාකරු

a = true ? 1 : 0
# 1
b = false ? 1 : 0
# 0

ස්කාලා හි තෘතීය ක්‍රියාකරු

val a = true ? 1 | 0
# 1
val b = false ? 1 | 0
# 0

ආර් ක්‍රමලේඛනයේ තෘතීය ක්‍රියාකරු

a <- if (TRUE) 1 else 0
# 1
b <- if (FALSE) 1 else 0
# 0

පයිතන් හි තෘතීය ක්‍රියාකරු

a = 1 if True else 0
# 1
b = 1 if False else 0
# 0

පයිතන් 2.5 සහ නව සඳහා විශේෂිත වාක්‍ය ඛණ්ඩයක් ඇත:

[on_true] if [cond] else [on_false]

පැරණි පයිතන් වල ත්‍රික ක්‍රියාකරු ක්‍රියාත්මක නොවන නමුත් එය අනුකරණය කළ හැකිය.

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)

එය සියලුම පයිතන් අනුවාද සමඟ අනුකූල වේ.

ඔබට බොහෝ විට සොයාගත හැකිය

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

මෙම ප්‍රති result ලය සාමාන්‍ය ත්‍රිමාණ ක්‍රියාකරුවෙකු සඳහා ඔබ අපේක්ෂා කරනු ඇත

>>> x = 0
>>> print 0 if x == 0 else 1 
0
>>> x = 1
>>> print 0 if x == 0 else 1 
1

පයිතන්ට ත්‍රිමාණ කොන්දේසි සහිත ක්‍රියාකරුවෙකු සිටීද?

ඔව්. සිට ව්යාකරණ ගොනුව :

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. ලැයිස්තු අවබෝධය සහ උත්පාදක ප්‍රකාශන ඉගෙන ගන්නා පුද්ගලයින්ට මෙය ඉගෙන ගැනීමට අපහසු පාඩමක් විය හැකිය - පයිතන් වෙනත් ප්‍රකාශයක් සඳහා තුන්වන ප්‍රකාශනයක් අපේක්ෂා කරන බැවින් පහත සඳහන් දෑ ක්‍රියා නොකරනු ඇත:

[expression1 if expression2 for element in iterable]
#                          ^-- need an else here

එය මතු කරයි a SyntaxError: invalid syntax. එබැවින් ඉහත දැක්වෙන්නේ එක්කෝ අසම්පූර්ණ තර්කනයකි (සමහර විට පරිශීලකයා ව්‍යාජ තත්ත්වයේ කිසිදු විකල්පයක් අපේක්ෂා නොකරයි) හෝ අදහස් 2 විය හැක්කේ ප්‍රකාශන 2 පෙරණයක් ලෙස භාවිතා කිරීමයි - පහත දැක්වෙන්නේ නීත්‍යානුකූල පයිතන් බව සටහන් කරයි:

[expression1 for element in iterable if expression2]

expression2ලැයිස්තුව අවබෝධය සඳහා පෙරහන් ලෙස ක්රියා කරයි, සහ මෙය නොවේ එය මිශ්ර කොන්දේසි ක්රියාකරු.

වඩාත් පටු නඩුවක් සඳහා විකල්ප වාක්‍ය ඛණ්ඩය:

පහත සඳහන් දේ ලිවීම ඔබට තරමක් වේදනාකාරී විය හැකිය:

expression1 if expression1 else expression2

expression1ඉහත භාවිතය සමඟ දෙවරක් ඇගයීමට ලක් කළ යුතුය. එය හුදෙක් දේශීය විචල්‍යයක් නම් අතිරික්තය සීමා කළ හැකිය. කෙසේ වෙතත්, මෙම භාවිතය සඳහා පොදු සහ ක්‍රියාකාරී පයිතොනික් මෝඩකමක් වන්නේ orකෙටිමං හැසිරීම භාවිතා කිරීමයි :

expression1 or expression2

එය අර්ථ නිරූපණයට සමාන වේ. සමහර ශෛලීය මාර්ගෝපදේශකයින් මෙම භාවිතය පැහැදිලි බව මත සීමා කළ හැකි බව සලකන්න - එය බොහෝ අර්ථයන් ඉතා සුළු වාක්‍ය ඛණ්ඩයකට ඇසුරුම් කරයි.

පයිතන් තෘතීය ක්‍රියාකරු අනුකරණය කිරීම.

උදාහරණයක් වශයෙන්

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'

ත්‍රිමාණ කොන්දේසි සහිත ක්‍රියාකරු හුදෙක් කේතය සංයුක්ත කරමින් බහු රේඛාව වෙනුවට තනි පේළියක කොන්දේසියක් පරීක්ෂා කිරීමට ඉඩ දෙයි.

වාක්‍ය ඛණ්ඩය:

[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- ටුපල්, ශබ්ද කෝෂය සහ ලැම්බඩා භාවිතා කිරීමේ සෘජු ක්‍රමය:

# 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- තෘතීය ක්‍රියාකරු කැදැල්ල ලෙස ලිවිය හැකි නම්:

# 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

ඔබට මේක කරන්න පුළුවන් :-

[condition] and [expression_1] or [expression_2] ;

උදාහරණයක්:-

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

අංකය අමුතු නම් මෙය "අමුතු" හෝ අංකය ඉරට්ටේ නම් "ඉරට්ටේ" ලෙස මුද්‍රණය වේ.

ප්‍රති result ලය : - කොන්දේසිය සත්‍ය නම් exp_1 ක්‍රියාත්මක වේ නම් exp_2 ක්‍රියාත්මක වේ.

සටහන: - 0, කිසිවක් නැත, අසත්‍ය, හිස් ලැයිස්තු, හිස් ස්ට්‍රිං වැරදි ලෙස තක්සේරු කරයි. 0 හැර වෙනත් ඕනෑම දත්ත සත්‍ය ලෙස තක්සේරු කරයි.

එය ක්‍රියාත්මක වන ආකාරය මෙන්න:

තත්වය [තත්වය] “සත්‍ය” බවට පත් වුවහොත්, ප්‍රකාශන_1 ඇගයීමට ලක් කෙරෙන නමුත් ප්‍රකාශන_2 නොවේ. අපි 0 (බිංදුව) සමඟ යමක් "සහ" කළහොත්, ප්‍රති result ලය සැමවිටම ව්‍යාකූල වනු ඇත .ඉතින් පහත ප්‍රකාශයේ,

0 and exp

0 සමඟ "සහ" සැමවිටම ශුන්‍යයට තක්සේරු කරන බැවින් ප්‍රකාශනය එක්ස්ප්රස් කිසිසේත් ඇගයීමට ලක් නොකරන අතර ප්රකාශනය ඇගයීමට අවශ්ය නොවේ. සියලු භාෂාවලින් සම්පාදකයා ක්‍රියා කරන ආකාරය මෙයයි.

තුළ

1 or exp

1 සමඟ "හෝ" සැමවිටම 1 වන බැවින් එක්ස්ප්‍රස් එක්ස්ප්‍රස් එක කිසිසේත් ඇගයීමට ලක් නොකෙරේ. (සම්පාදක ප්‍රශස්තිකරණ ක්‍රම).

නමුත් එසේ නම්

True and exp1 or exp2

දෙවන ප්‍රකාශනය exp2 තක්සේරු නොකෙරේ, මන්ද True and exp1exp1 අසත්‍ය නොවන විට එය සත්‍ය වේ.

ඒ හා සමානව

False and exp1 or exp2

Exp1 ප්‍රකාශනය තක්සේරු නොකෙරේ, අසත්‍යය 0 ලිවීමට සමාන වන අතර "සහ" 0 කිරීම 0 ම වේ. නමුත් exp1 පසු "හෝ" භාවිතා කිරීමෙන් පසුව එය exp2 ප්‍රකාශනය ඇගයීමට ලක් කරනු ඇත.

සටහන: - "හෝ" සහ "සහ" යන අතු බෙදීම් භාවිතා කළ හැක්කේ ප්‍රකාශනය_1 ට සත්‍යයේ සත්‍ය අගයක් නොමැති විට පමණි (හෝ 0 හෝ කිසිවක් නැත, හෝ හිස් වාදකය [] හෝ හිස් නූල් ''.) අසත්‍යය, එවිට 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')

සමහර (බොහෝ :) එය අශෝභන ලෙස (රුබී-ඊෂ් :) යැයි සිතිය හැක, නමුත් මම පෞද්ගලිකව එය වඩාත් ස්වාභාවික යැයි සිතමි - එනම් ඔබ සාමාන්‍යයෙන් එය ප්‍රකාශ කරන්නේ කෙසේද යන්නත්, විශාල කේත සමූහයක් තුළ දෘශ්‍යමය වශයෙන් වැඩි කැමැත්තක් දක්වයි.

a if condition else b

ඔබට මතක තබා ගැනීමට අපහසු නම් මෙම පිරමීඩය කටපාඩම් කරන්න:

     condition
  if           else
a                   b 

පයිතන්ගේ කොන්දේසි සහිත ප්‍රකාශනයට විකල්පයක්

"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()ඇගයීමට ලක් කෙරේ.

බොහෝ ව්‍යුත්පන්න භාෂාවලින් Cසාමාන්‍යයෙන් ත්‍රිමාණ කොන්දේසි සහිත ක්‍රියාකරුගේ සින්ටැක්ස් ඇත:

<condition> ? <expression1> : <expression2>

මුලදී, Python B enevolent D ictator F හෝ L ife (මම අදහස් කළේ ගයිඩෝ වැන් රොසුම්, ඇත්ත වශයෙන්ම) එය ප්‍රතික්ෂේප කර ඇත (පයිතොනික් නොවන විලාසිතාවක් ලෙස), Cභාෂාවට හුරු නැති අයට තේරුම් ගැනීම තරමක් අපහසු බැවින් . එසේම, මහා බඩවැලේ ලකුණට :දැනටමත් බොහෝ භාවිතයන් ඇත Python. PEP 308 අනුමත කිරීමෙන් පසුව , Pythonඅවසානයේදී එහි කෙටිමං කොන්දේසි සහිත ප්‍රකාශනයක් ලැබුණි (අප දැන් භාවිතා කරන්නේ):

<expression1> if <condition> else <expression2>

ඉතින්, පළමුව එය තත්වය ඇගයීමට ලක් කරයි. එය නැවත පැමිණේ නම් True, ප්‍රති result ලය ලබා දීම සඳහා ප්‍රකාශන 1 ඇගයීමට ලක් කෙරේ , එසේ නොමැතිනම් ප්‍රකාශන 2 ඇගයීමට ලක් කෙරේ. කම්මැලි ඇගයීම් යාන්ත්‍ර විද්‍යාව හේතුවෙන් - ක්‍රියාත්මක වන්නේ එක් ප්‍රකාශනයක් පමණි.

මෙන්න උදාහරණ කිහිපයක් (කොන්දේසි වමේ සිට දකුණට ඇගයීමට ලක් කෙරේ):

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'

මෙය උපකාරී වේ යැයි සිතමි.

දැනටමත් පිළිතුරු දී ඇති පරිදි, ඔව්, පයිතන්හි ත්‍රිමාණ ක්‍රියාකරු සිටී:

<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: ඇත්ත වශයෙන්ම, කෙටි පරිපථ ඇගයීමක් ත්‍රික ක්‍රියාකරු නොවන නමුත් බොහෝ විට ත්‍රිකෝණය භාවිතා කරනුයේ කෙටි පරිපථය ප්‍රමාණවත් වන අවස්ථාවන්හිදී ය.

ඔව්, පයිතන්ට ත්‍රික ක්‍රියාකරු ඇත, මෙන්න එය පෙන්වීමට වාක්‍ය ඛණ්ඩය සහ උදාහරණ කේතය :)

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

පැවරුම් සඳහා පයිතන්ට ත්‍රිමාණ ආකාරයක් ඇත; කෙසේ වෙතත් මිනිසුන් දැන සිටිය යුතු කෙටි ආකාරයක් පවා තිබිය හැකිය.

කොන්දේසියක් මත පදනම්ව විචල්‍ය එක් අගයකට හෝ වෙනත් අගයකට පැවරීම අවශ්‍ය වේ.

>>> li1 = None
>>> li2 = [1, 2, 3]
>>> 
>>> if li1:
...     a = li1
... else:
...     a = li2
...     
>>> a
[1, 2, 3]

Ass එවැනි පැවරුම් සිදු කිරීම සඳහා වන දිගු ස්වරූපය මෙයයි.

පහත දැක්වෙන්නේ තෘතීය ස්වරූපයයි. නමුත් මෙය වඩාත් සංක්ෂිප්ත ක්‍රමයක් නොවේ - අවසාන උදාහරණය බලන්න.

>>> a = li1 if li1 else li2
>>> 
>>> a
[1, 2, 3]
>>> 

පයිතන් සමඟ, ඔබට orවිකල්ප පැවරුම් සඳහා සරලව භාවිතා කළ හැකිය .

>>> a = li1 or li2
>>> 
>>> a
[1, 2, 3]
>>> 

ඉහත සිට li1ක්‍රියාත්මක වන Noneඅතර තාර්කික ප්‍රකාශනවල අසත්‍යය ලෙස අන්තර්වාරය සලකයි. එවිට අන්තර් ප්‍රකාශනය දෙවන ප්‍රකාශනය ඉදිරියට ගෙන ගොස් ඇගයීමට ලක් කරයි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'
>>> 

මම නිතරම සී ටර්නරි සින්ටැක්ස් වලට කැමතියි, නමුත් පයිතන් එය තවත් පියවරක් ඉදිරියට තබයි!

සමහරු මෙය හොඳ ශෛලීය තේරීමක් නොවන බව පැවසිය හැකි බැවින් එය සියලු සංවර්ධකයින්ට ක්ෂණිකව නොපෙනෙන යාන්ත්‍ර විද්‍යාව මත රඳා පවතී. මම පෞද්ගලිකව එම මතයට එකඟ නොවෙමි. පයිතන් යනු වාක්‍ය ඛණ්ඩයට ක්ෂණිකව නොපෙනෙන බොහෝ මෝඩ උපක්‍රම සහිත සින්ටැක්ස් පොහොසත් භාෂාවකි. නමුත් යටින් පවතින පද්ධතියේ යාන්ත්‍ර විද්‍යාව ඔබ වැඩි වැඩියෙන් ඉගෙන ගෙන තේරුම් ගන්නා තරමට ඔබ එය අගය කරයි.

වෙනත් පිළිතුරු නිවැරදිව කතා කරන්නේ පයිතන් තෘතීය ක්‍රියාකරු ගැන ය. තෘතීය ක්‍රියාකරු බොහෝ විට භාවිතා කරන නමුත් වඩා හොඳ මෝඩකමක් ඇති අවස්ථාවක් සඳහන් කිරීමෙන් මම අනුපූරක වීමට කැමැත්තෙමි. පෙරනිමි අගයක් භාවිතා කිරීමේ අවස්ථාව මෙයයි.

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)

විචල්‍යය අර්ථ දක්වා ඇත්නම් සහ ඔබට එය කළ හැකි අගයක් තිබේදැයි පරීක්ෂා කිරීමට අවශ්‍ය නම් 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

පෙරනිමි පයිතන් සින්ටැක්ස් අවුල් සහගත බව මට පෙනේ 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) තක්සේරු කිරීමේ අවාසිය එයට ඇත, නමුත් වාක්‍ය ඛණ්ඩය එය මට වඩා පැහැදිලි ය

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

**

එය ඔබේ අවශ්‍යතාවය ලෙස කැදැල්ල කළ හැකිය. සුභ පැතුම්

**