Python හි if ප්‍රකාශ සමඟ කොන්දේසි සහිත ශාඛා කිරීම පැහැදිලි කරන්න.
- if ප්‍රකාශවල මූලික කරුණු (if, elif, else)
- සංසන්දනාත්මක ක්රියාකරුවන්, ආදිය සමඟ කොන්දේසි සඳහන් කරන්න.
- අංකය, ලැයිස්තුව, ආදිය අනුව කොන්දේසි සඳහන් කරන්න.
- තාර්කික ක්රියාකරුවන් සමඟ බහු කොන්දේසි හෝ නිෂේධන සඳහන් කරන්න (සහ, හෝ, නැත)
- නව රේඛා සහ බහු පේළිවල කොන්දේසි සහිත ප්‍රකාශන
එක් පේළියක කොන්දේසි සහිත ශාඛාවක් විස්තර කරන ත්රිත්ව ක්රියාකරු ද ඇත. පහත ලිපිය බලන්න.
if ප්‍රකාශවල මූලික කරුණු (if, elif, else)
if ප්‍රකාශයේ මූලික ස්වරූපය පහත පරිදි වේ
if Conditional expression 1:
`Processing to be performed if Expression 1 is True.`
elif Conditional expression 2:
`Processing to be performed when expression 1 is false and expression 2 is true.`
elif Expression 3:
`Process when expression 1 and 2 are false and expression 3 is true.`
...
else:
`Processing when all conditionals are false.`
“elif” C සහ අනෙකුත් භාෂා වල “else if” ට අනුරූප වන අතර ඕනෑම “elifs” ගණනක් තිබිය හැක.
අසත්‍ය අවශ්‍ය නොවන විට එකම කොන්දේසි සහිත ප්‍රකාශනයක් හෝ සැකසීමක් තිබේ නම්, “elif” සහ “else” බ්ලොක් මඟ හැරිය හැක.
සංසන්දනාත්මක ක්රියාකරුවන්, ආදිය සමඟ කොන්දේසි සඳහන් කරන්න.
සැසඳීමේ ක්‍රියාකරුවෙකු වැනි bool වර්ගයක් (සත්‍ය, අසත්‍ය) ආපසු ලබා දෙන මෙහෙයුමක් සමඟ කොන්දේසිය සඳහන් කරන්න.
Python comparison operators පහත පරිදි වේ
| ක්රියාකරු | ප්රතිඵලය |
|---|---|
x < y | x y ට වඩා අඩු නම් සත්‍ය වේ |
x <= y | x y ට අඩු හෝ සමාන නම් සත්‍ය වේ |
x > y | x y ට වඩා විශාල නම් සත්‍ය වේ |
x >= y | x y ට වඩා විශාල හෝ සමාන නම් සත්‍ය වේ |
x == y | x සහ y අගයන් සමාන නම් සත්‍ය වේ |
x != yx is yx is not yx in yx not in yඋදාහරණයක්. පහසුව සඳහා, එය def ප්රකාශය සමඟ ශ්රිතයක් ලෙස අර්ථ දැක්වේ.
def if_test(num):
if num > 100:
print('100 < num')
elif num > 50:
print('50 < num <= 100')
elif num > 0:
print('0 < num <= 50')
elif num == 0:
print('num == 0')
else:
print('num < 0')
if_test(1000)
# 100 < num
if_test(70)
# 50 < num <= 100
if_test(0)
# num == 0
if_test(-100)
# num < 0
පයිතන් වලට අනන්‍ය වූ ආකාරයට පහත දෑ ලිවිය හැක. විස්තර සඳහා පහත ලිපිය බලන්න.a < x < b
def if_test2(num):
if 50 < num < 100:
print('50 < num < 100')
else:
print('num <= 50 or num >= 100')
if_test2(70)
# 50 < num < 100
if_test2(0)
# num <= 50 or num >= 100
#ERROR!!=
ඉහත දැක්වෙන්නේ අගයන් සංසන්දනය කිරීමකි; වස්තු අනන්‍යතා සංසන්දනය කිරීමට, පහත සඳහන් දේ භාවිතා කරන්න
isis not
උදාහරණයක් ලෙස, පූර්ණ සංඛ්‍යාවක් සහ පාවෙන ලක්ෂ්‍ය සංඛ්‍යාවක් සංසන්දනය කිරීමේදී, “==” අගයන් සමාන නම් සත්‍ය ලෙස ලබා දෙයි, නමුත් “is” ඒවා විවිධ වස්තු නිසා අසත්‍ය වේ.
i = 10
print(type(i))
# <class 'int'>
f = 10.0
print(type(f))
# <class 'float'>
print(i == f)
# True
print(i is f)
# False
ලැයිස්තුවක හෝ තන්තුවක නිශ්චිත මූලද්‍රව්‍යයක් (අක්ෂර) තිබේද යන්න කොන්දේසිය කිරීමටද හැකිය.
in:ඇතුළත් වේnot in:ඇතුළු නොවේ
def if_test_in(s):
if 'a' in s:
print('a is in string')
else:
print('a is NOT in string')
if_test_in('apple')
# a is in string
if_test_in('melon')
# a is NOT in string
අංකය, ලැයිස්තුව, ආදිය අනුව කොන්දේසි සඳහන් කරන්න.
if ප්‍රකාශයක කොන්දේසි සහිත ප්‍රකාශනය bool වර්ගයේ (සත්‍ය, අසත්‍ය) නොවන අංකයක්, ලැයිස්තුවක් හෝ වෙනත් වස්තුවක් විය හැක.
if 10:
print('True')
# True
if [0, 1, 2]:
print('True')
# True
Python if ප්‍රකාශයක කොන්දේසි සහිත ප්‍රකාශනයේ, පහත වස්තූන් අසත්‍ය ලෙස සැලකේ.
- නියතයන් අසත්‍ය ලෙස අර්ථ දක්වා ඇත:
None,false- සංඛ්‍යාත්මක වර්ගයෙහි ශුන්‍යය:
0,0,0j,Decimal(0),Fraction(0, 1)- හිස් අනුපිළිවෙල හෝ එකතුව:
',(),[],{},set(),range(0)Truth Value Testing — Built-in Types — Python 3.10.4 Documentation
ශුන්‍ය, හිස් නූල්, ලැයිස්තු ආදිය නියෝජනය කරන සංඛ්‍යා අසත්‍ය ලෙස සැලකේ; අනෙක් සියල්ල සත්‍ය ලෙස සැලකේ.
වස්තුව විනිශ්චය කරන ආකාරය bool() මගින් පරීක්ෂා කළ හැක.
print(bool(10))
# True
print(bool(0.0))
# False
print(bool([]))
# False
print(bool('False'))
# True
උදාහරණයක් ලෙස ලැයිස්තුව හිස් වූ විට ක්‍රියාවලිය සරලව ලිවීමට මෙය භාවිතා කළ හැක.
def if_test_list(l):
if l:
print('list is NOT empty')
else:
print('list is empty')
if_test_list([0, 1, 2])
# list is NOT empty
if_test_list([])
# list is empty
ඉහත උදාහරණයේ පෙන්වා ඇති පරිදි, තන්තුවෙහි හිස් නොවන ඕනෑම තන්තුවක් සත්‍ය වන බැවින්, ‘False’ තන්තුවද සත්‍ය වනු ඇති බව සලකන්න.’ ‘True’ හෝ ‘False’ වැනි නිශ්චිත තන්තුවක් 1,0 වෙත පරිවර්තනය කිරීමට, distutils.util මොඩියුලයේ strtobool() භාවිතා කරන්න.
තාර්කික ක්රියාකරුවන් සමඟ බහු කොන්දේසි හෝ නිෂේධන සඳහන් කරන්න (සහ, හෝ, නැත)
තාර්කික ක්රියාකරුවන් (සහ, හෝ, නැත) තාර්කික සංයෝජන, තාර්කික විසංයෝජනය සහ බහු කොන්දේසි නිෂේධනය කිරීම සඳහා භාවිතා කළ හැක.
| ක්රියාකරු | (ප්රතිඵලය (if ප්‍රකාශයක කොන්දේසි සහිත ප්‍රකාශනයේ) |
|---|---|
x and y | x සහ y දෙකම සත්‍ය නම් සත්‍ය වේ |
x or y | x හෝ y සත්‍ය නම් සත්‍ය වේ |
not x | x නම් අසත්‍යය, x අසත්‍ය නම් සත්‍යය |
def if_test_and_not(num):
if num >= 0 and not num % 2 == 0:
print('num is positive odd')
else:
print('num is NOT positive odd')
if_test_and_not(5)
# num is positive odd
if_test_and_not(10)
# num is NOT positive odd
if_test_and_not(-10)
# num is NOT positive odd
ඇත්ත වශයෙන්ම, “x සහ y” සහ “x හෝ y” සත්‍ය හෝ අසත්‍ය ලබා නොදේ, නමුත් x හෝ y. if ප්‍රකාශවල කොන්දේසි සහිත ප්‍රකාශනවල ඒවා භාවිතා වන තාක්, ඒවා සත්‍ය හෝ අසත්‍ය ලෙස ඇගයීමට ලක් කරන බැවින්, ඒවා ගැන කරදර විය යුතු නැත. විස්තර සඳහා පහත ලිපිය බලන්න.
- සම්බන්ධිත:Python හි තාර්කික ක්රියාකරුවන් “සහ, හෝ, නොවේ” (තාර්කික සංයෝගය, තාර්කික විසංයෝජනය, නිෂේධනය)
එය එක් වරකට වඩා භාවිතා කළ හැකි අතර සහ හෝ ඊට වඩා වැඩි වේ.
def if_test_and_not_or(num):
if num >= 0 and not num % 2 == 0 or num == -10:
print('num is positive odd or -10')
else:
print('num is NOT positive odd or -10')
if_test_and_not_or(5)
# num is positive odd or -10
if_test_and_not_or(10)
# num is NOT positive odd or -10
if_test_and_not_or(-10)
# num is positive odd or -10
නව රේඛා සහ බහු පේළිවල කොන්දේසි සහිත ප්‍රකාශන
“සහ” හෝ “හෝ” සමඟ සම්බන්ධ කිරීමෙන් බහු කොන්දේසිගත ප්‍රකාශන භාවිතා කරන විට සහ එක් එක් පේළිය දිගු වන විට, සමහර විට කොන්දේසි සහිත ප්‍රකාශනය බිඳ දමා එය පේළි කිහිපයක ලිවීම අවශ්‍ය වේ.
පසුපෙළක් භාවිතා කිරීමෙන් හෝ සම්පූර්ණ රේඛාව වරහන් තුළට දැමීමෙන් රේඛා බිඳීමක් සිදු කළ හැක.
def if_test_and_backslash(num):
if num >= 0 \
and not num % 2 == 0:
print('num is positive odd')
else:
print('num is NOT positive odd')
if_test_and_backslash(5)
# num is positive odd
def if_test_and_brackets(num):
if (num >= 0
and not num % 2 == 0):
print('num is positive odd')
else:
print('num is NOT positive odd')
if_test_and_brackets(5)
# num is positive odd
ඔබට කැමති වාර ගණනක් රේඛාවක් කැඩීමට backslash භාවිතා කළ හැක. එලෙසම, ඔබට වරහන් තුළ ඕනෑම වාර ගණනක් රේඛාවක් බිඳ දැමිය හැක. ඉන්ඩෙන්ටේෂන් සීමාවක් නොමැත.
මෙය if ප්‍රකාශවල පමණක් නොව පයිතන් කේතයේ ඕනෑම තැනක භාවිතා කළ හැකි තාක්‍ෂණයක් බව සලකන්න.
- සම්බන්ධිත:Python හි බහු පේළි මත දිගු නූල් ලිවීම
