பைத்தானில் if அறிக்கைகளுடன் நிபந்தனை கிளைகளை எழுதுவது எப்படி

பைத்தானில் 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” தொகுதிகள் தவிர்க்கப்படலாம்.

ஒப்பீட்டு ஆபரேட்டர்கள் போன்றவற்றுடன் நிபந்தனைகளைக் குறிப்பிடவும்.

ஒப்பீட்டு ஆபரேட்டர் போன்ற பூல் வகையை (உண்மை, தவறு) வழங்கும் செயல்பாட்டின் மூலம் நிபந்தனையைக் குறிப்பிடவும்.

பைதான் ஒப்பீட்டு ஆபரேட்டர்கள் பின்வருமாறு

• 6.10. Comparisons — 6. Expressions — Python 3.10.4 Documentation

இயக்குபவர்	விளைவாக
x < y	x y ஐ விட குறைவாக இருந்தால் உண்மை
x <= y	x என்பது y ஐ விட குறைவாகவோ அல்லது சமமாகவோ இருந்தால் உண்மை
x > y	y ஐ விட x அதிகமாக இருந்தால் உண்மை
x >= y	x y ஐ விட அதிகமாகவோ அல்லது சமமாகவோ இருந்தால் உண்மை
x == y	x மற்றும் y மதிப்புகள் சமமாக இருந்தால் உண்மை

x != yx மற்றும் y மதிப்புகள் சமமாக இல்லாவிட்டால் உண்மைx is yx மற்றும் y ஒரே பொருளாக இருந்தால் உண்மைx is not yx மற்றும் y ஒரே பொருளாக இல்லாவிட்டால் உண்மைx in yy இல் x இருந்தால் உண்மைx not in yy இல் x இல்லை என்றால் உண்மை

உதாரணமாக. வசதிக்காக, இது 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!
• !=

மேலே உள்ளவை மதிப்புகளின் ஒப்பீடு; பொருள் அடையாளங்களை ஒப்பிட்டுப் பார்க்க, பின்வருவனவற்றைப் பயன்படுத்தவும்

• is
• is 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 அறிக்கையின் நிபந்தனை வெளிப்பாடு ஒரு எண், பட்டியல் அல்லது பூல் வகையல்லாத பிற பொருளாக இருக்கலாம் (உண்மை, தவறு).

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() ஐப் பயன்படுத்தவும்.

தருக்க ஆபரேட்டர்களுடன் பல நிபந்தனைகள் அல்லது மறுப்புகளைக் குறிப்பிடவும் (மற்றும், அல்லது, இல்லை)

தருக்க ஆபரேட்டர்கள் (மற்றும், அல்லது, இல்லை) தருக்க இணைப்பு, தருக்க விலகல் மற்றும் பல நிபந்தனைகளின் மறுப்பு ஆகியவற்றைக் கையாள பயன்படுத்தப்படலாம்.

• Boolean Operations — and, or, not — Built-in Types — Python 3.10.4 Documentation

இயக்குபவர்	(முடிவு (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” ஆகியவை True அல்லது False என்பதை வழங்காது, ஆனால் x அல்லது y. if அறிக்கைகளில் நிபந்தனை வெளிப்பாடுகளில் அவை பயன்படுத்தப்படும் வரை, அவற்றைப் பற்றி கவலைப்படத் தேவையில்லை, ஏனெனில் அவை உண்மை அல்லது தவறு என மதிப்பிடுகின்றன. விவரங்களுக்கு பின்வரும் கட்டுரையைப் பார்க்கவும்.

• தொடர்புடையது:பைத்தானின் தருக்க ஆபரேட்டர்கள் “மற்றும், அல்லது, இல்லை” (தர்க்கரீதியான இணைப்பு, தருக்க விலகல், மறுப்பு)

இது ஒரு முறை மற்றும் அல்லது அதற்கு மேற்பட்ட முறை பயன்படுத்த முடியும்.

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

ஒரு வரியை எத்தனை முறை வேண்டுமானாலும் உடைக்க, பின்சாய்வுகளைப் பயன்படுத்தலாம். அதேபோல், அடைப்புக்குறிக்குள் எத்தனை முறை வேண்டுமானாலும் ஒரு கோட்டை உடைக்கலாம். உள்தள்ளல் வரம்பு இல்லை.

இது if அறிக்கைகளில் மட்டுமின்றி, பைதான் குறியீட்டில் எங்கும் பயன்படுத்தக்கூடிய ஒரு நுட்பமாகும் என்பதை நினைவில் கொள்ளவும்.

• தொடர்புடையது:பைத்தானில் பல வரிகளில் நீண்ட சரங்களை எழுதுதல்