பைத்தானில் நிபந்தனை என்றால் அறிக்கை. தொடரியல், வேறு/எலிஃப் தொகுதிகள், எடுத்துக்காட்டுகள்

நிரலாக்க கற்றல் செயல்பாட்டில், நிஜ வாழ்க்கையில் பயன்படுத்த மிகவும் எளிதானது அல்லாத நிரல்களை உருவாக்குவது பெரும்பாலும் அவசியம். எல்லாவற்றிற்கும் மேலாக, அவ்வப்போது நீங்கள் சில நிபந்தனைகளின் கீழ் மட்டுமே வழிமுறைகளைப் பின்பற்ற வேண்டும். நிரலில் இதைச் செயல்படுத்த, எல்லா மொழிகளிலும் கட்டுப்பாட்டு அறிக்கைகள் உள்ளன. அவர்களின் உதவியுடன், குறியீடு செயல்படுத்தலின் ஓட்டத்தை நீங்கள் கட்டுப்படுத்தலாம், சுழல்களை உருவாக்கலாம் அல்லது ஒரு குறிப்பிட்ட நிபந்தனை உண்மையாக இருக்கும்போது மட்டுமே சில செயல்களைச் செய்யலாம்.

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

கட்டுப்பாட்டு அறிக்கைகளின் வகைகள்

பொதுவாக, ஒரு நிரலின் ஓட்டத்தை கட்டுப்படுத்தும் ஒரே அறிக்கை என்றால் இல்லை. அதே போல் அவரே ஒரு பெரிய ஆபரேட்டர்களின் ஒரு அங்கமாக இருக்க முடியும்.

அதன் செயல்பாட்டின் செயல்முறையை கட்டுப்படுத்தும் சுழல்கள் மற்றும் அறிக்கைகள் உள்ளன. இன்று நாம் நிபந்தனை ஆபரேட்டர் மற்றும் அது பங்கேற்கக்கூடிய சங்கிலிகள் பற்றி மட்டுமே பேசுவோம்.

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

1. ஒரு குறிப்பிட்ட மதிப்புக்கு மாறியின் சமத்துவம்.
2. ஒரு குறிப்பிட்ட செயலைச் செய்தல்.
3. பயன்பாட்டின் நிலை (சரிந்ததா இல்லையா).

ஸ்பெக்ட்ரம் மிகவும் பெரியதாக இருக்கலாம். நிபந்தனை அறிக்கைகள் பல வகைகளில் வருகின்றன:

1. ஒரு கிளையுடன். அதாவது, ஒரு காசோலை செய்யப்படுகிறது, இதன் விளைவாக சில செயல்கள் செய்யப்படுகின்றன.
2. இரண்டு அல்லது அதற்கு மேற்பட்ட கிளைகளுடன். அளவுகோல் 1 உண்மையாக இருந்தால், அளவுகோல் 2 ஐச் சரிபார்க்கவும். அது உண்மையாக இருந்தால், 3 ஐச் சரிபார்க்கவும். எனவே, தேவையான பல சோதனைகளைச் செய்யவும்.
3. பல நிபந்தனைகளுடன். இங்கே எல்லாம் எளிது. மொழிபெயர்ப்பாளர் பல நிபந்தனைகளை அல்லது அவற்றில் ஒன்றைச் சரிபார்க்கிறார்.

அறிக்கை என்றால்

if அறிக்கையின் அமைப்பு எல்லா மொழிகளிலும் ஒரே மாதிரியாக உள்ளது. இருப்பினும், பைத்தானில், அதன் தொடரியல் மற்ற எல்லாவற்றிலிருந்தும் சற்றே வித்தியாசமானது:

நிபந்தனை என்றால்:

    <входящее выражение 1>

    <входящее выражение 2>

<не входящее выражение>

முதலில், ஆபரேட்டரே அறிவிக்கப்படுகிறார், அதன் பிறகு அது வேலை செய்யத் தொடங்கும் நிபந்தனை எழுதப்பட்டுள்ளது. நிபந்தனை உண்மையாகவோ அல்லது பொய்யாகவோ இருக்கலாம்.

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

கவனம்! பிளாக் கட்டளைகள் அனைத்திலும் உள்ள உள்தள்ளல் ஒரே அளவில் இருக்க வேண்டும். தொகுதி எல்லைகள் உள்தள்ளல்களால் தீர்மானிக்கப்படுகின்றன. 

மொழி ஆவணங்களின்படி, உள்தள்ளல் 4 இடைவெளிகள். 

இந்த ஆபரேட்டர் எப்படி வேலை செய்கிறது? மொழிபெயர்ப்பாளர் if வார்த்தையைப் பார்க்கும்போது, ​​அது உடனடியாக பயனரால் குறிப்பிடப்பட்ட அளவுகோல்களுக்கு எதிராக வெளிப்பாட்டை சரிபார்க்கிறது. அப்படியானால், அவர் அறிவுறுத்தல்களைத் தேடி அவற்றைப் பின்பற்றத் தொடங்குகிறார். இல்லையெனில், இந்த தொகுதியிலிருந்து அனைத்து கட்டளைகளும் தவிர்க்கப்படும்.

நிபந்தனைக்குப் பிறகு ஒரு அறிக்கை உள்தள்ளப்படாவிட்டால், அது if block ஆகக் கருதப்படாது. எங்கள் சூழ்நிலையில், இந்த வரி . எனவே, காசோலையின் முடிவைப் பொருட்படுத்தாமல், இந்த வரி செயல்படுத்தப்படும்.

இந்த ஆபரேட்டர் எவ்வாறு செயல்படுகிறது என்பதற்கான எடுத்துக்காட்டுக்கான குறியீடு துணுக்கு இங்கே உள்ளது.

எண் = int (உள்ளீடு ("ஒரு எண்ணை உள்ளிடவும்: "))

எண் > 10 என்றால்:

    அச்சு ("எண் 10 ஐ விட அதிகமாக உள்ளது")

இந்த நிரல் பயனரை ஒரு எண்ணைக் கேட்கிறது மற்றும் அது 10 ஐ விட அதிகமாக உள்ளதா என சரிபார்க்கிறது. அப்படியானால், அது பொருத்தமான தகவலை வழங்குகிறது. எடுத்துக்காட்டாக, பயனர் எண் 5 ஐ உள்ளிட்டால், நிரல் வெறுமனே முடிவடையும், அவ்வளவுதான்.

ஆனால் நீங்கள் 100 என்ற எண்ணைக் குறிப்பிட்டால், அது பத்துக்கும் அதிகமாக இருப்பதை மொழிபெயர்ப்பாளர் புரிந்துகொண்டு அதைப் புகாரளிப்பார்.

கவனம்! எங்கள் விஷயத்தில், நிபந்தனை தவறானதாக இருந்தால், நிரல் நிறுத்தப்படும், ஏனெனில் அறிவுறுத்தலுக்குப் பிறகு எந்த கட்டளையும் வழங்கப்படவில்லை.

மேலே உள்ள குறியீட்டில் ஒரே ஒரு கட்டளை உள்ளது. ஆனால் அவற்றில் இன்னும் பல உள்ளன. உள்தள்ளுவது மட்டுமே தேவை.

இப்போது இந்த கட்டளைகளின் வரிசையை பகுப்பாய்வு செய்வோம்.

எண் = உள்ளீடு ("எண்ணை எழுது: "))

எண் > 10 என்றால்:

    அச்சு ("முதல் வரி")

    அச்சு ("இரண்டாவது வரி")

    அச்சு ("மூன்றாவது வரி")

அச்சு ("உள்ளிட்ட எண்ணைப் பொருட்படுத்தாமல் செயல்படுத்தப்படும் வரி")

அச்சு (“பயன்பாடு முடிவு”)

நீங்கள் 2, 5, 10, 15, 50 மதிப்புகளை உள்ளிட்டால் வெளியீடு என்னவாக இருக்கும் என்று யூகிக்க முயற்சிக்கவும்.

நீங்கள் பார்க்க முடியும் என, பயனர் உள்ளிட்ட எண் பத்துக்கும் அதிகமாக இருந்தால், மூன்று வரிகள் வெளியீடு + ஒன்று "ஒவ்வொரு முறையும் இயக்கவும் ..." மற்றும் ஒரு "முடிவு", மற்றும் பத்துக்கும் குறைவாக இருந்தால், ஒன்று மட்டுமே. ஒரு வித்தியாசமான உரை. உண்மை என்றால் 3,4,5 வரிகள் மட்டுமே செயல்படுத்தப்படும். இருப்பினும், பயனர் எந்த எண்ணைக் குறிப்பிட்டாலும் கடைசி இரண்டு வரிகள் எழுதப்படும்.

நீங்கள் கன்சோலில் நேரடியாக அறிக்கைகளைப் பயன்படுத்தினால், முடிவு வேறுபட்டதாக இருக்கும். சரிபார்ப்பு அளவுகோலைக் குறிப்பிட்ட பிறகு, Enter ஐ அழுத்தினால், மொழிபெயர்ப்பாளர் உடனடியாக பல வரி பயன்முறையை இயக்குகிறார்.

பின்வரும் கட்டளைகளின் வரிசையை நாம் எழுதியுள்ளோம் என்று வைத்துக்கொள்வோம்.

>>>

>>> n = 100

>>> என்றால் n > 10:

...

அதன் பிறகு, >>> நீள்வட்டத்தால் மாற்றப்பட்டிருப்பதைக் காண்போம். இதன் பொருள் மல்டிலைன் உள்ளீட்டு பயன்முறை இயக்கப்பட்டுள்ளது. எளிமையான வார்த்தைகளில், நீங்கள் Enter ஐ அழுத்தினால், நீங்கள் அறிவுறுத்தலின் இரண்டாம் கட்ட உள்ளீட்டிற்கு மாற்றப்படுவீர்கள். 

இந்த தொகுதியிலிருந்து வெளியேற, நீங்கள் தொகுதிக்கு மேலும் ஒரு கட்டுமானத்தைச் சேர்க்க வேண்டும் if.

>>>

>>> n = 100

>>> என்றால் n > 10:

… அச்சு (“என்வி 10”)

...

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

வெளிப்பாடு ஆபரேட்டர் இல்லையென்றால்

இந்த ஆபரேட்டர் ஒரு இணைப்பைச் செயல்படுத்த உங்களை அனுமதிக்கிறது: வெளிப்பாடு ஒரு குறிப்பிட்ட விதியுடன் பொருந்தினால், இந்த செயல்களைச் செய்யவும், இல்லையெனில், பிறவற்றைச் செய்யவும். அதாவது, நிரலின் ஓட்டத்தை இரண்டு சாலைகளாகப் பிரிக்க இது உங்களை அனுமதிக்கிறது. தொடரியல் உள்ளுணர்வு:

நிபந்தனை என்றால்:

    # என்றால் தடை

    அறிக்கை 1

    அறிக்கை 2

    மற்றும் பல

வேறு:

    # வேறு தொகுதி

    அறிக்கை 3

    அறிக்கை 4

    மற்றும் பல:

இந்த ஆபரேட்டர் எவ்வாறு செயல்படுகிறது என்பதை விளக்குவோம். முதலில், நிலையான அறிக்கை நூலில் செயல்படுத்தப்படுகிறது யோவ், பொருந்துகிறதா என்று சரிபார்க்கிறது நிலை "சரியா தவறா". மேலும் நடவடிக்கைகள் காசோலையின் முடிவுகளைப் பொறுத்தது. உண்மை எனில், நிபந்தனையைப் பின்பற்றும் வழிமுறைகளின் வரிசையில் உள்ள அறிவுறுத்தல் நேரடியாக செயல்படுத்தப்படும். யோவ், அது பொய் என்றால், பின்னர் வேறு. 

இந்த வழியில் நீங்கள் பிழைகளை கையாள முடியும். எடுத்துக்காட்டாக, பயனர் ஒரு ஆரம் உள்ளிட வேண்டும். வெளிப்படையாக, இது கூட்டல் குறி கொண்ட எண்ணாக மட்டுமே இருக்க முடியும் அல்லது அது பூஜ்ய மதிப்பாகும். இது 0 க்கும் குறைவாக இருந்தால், நேர்மறை எண்ணை உள்ளிடுமாறு ஒரு செய்தியை நீங்கள் வழங்க வேண்டும். 

இந்த பணியை செயல்படுத்தும் குறியீடு இங்கே உள்ளது. ஆனால் இங்கே ஒரு தவறு உள்ளது. எது என்று யூகிக்க முயற்சிக்கவும். 

ஆரம் = int(உள்ளீடு ("ஆரம் உள்ளிடவும்:"))

ஆரம் >= 0 என்றால்:

    அச்சு (“சுற்றளவு = “, 2 * 3.14 * ஆரம்)

    அச்சு ("பகுதி = ", 3.14 * ஆரம் ** 2)

    வேறு:

        அச்சு (“தயவுசெய்து நேர்மறை எண்ணை உள்ளிடவும்”)

உள்தள்ளல் பொருந்தாத பிழை. மற்றும் வேறு என்றால் அவை இல்லாமல் அல்லது அதே எண்ணிக்கையில் (அவை கூடு கட்டப்பட்டதா இல்லையா என்பதைப் பொறுத்து) அமைந்திருக்க வேண்டும்.

மற்றொரு பயன்பாட்டு வழக்கை (ஆபரேட்டர் சீரமைப்புடன் எல்லாம் சரியாக இருக்கும்) - கடவுச்சொல்லைச் சரிபார்க்கும் பயன்பாட்டு உறுப்பு.

கடவுச்சொல் = உள்ளீடு ("கடவுச்சொல்லை உள்ளிடவும்: ")

கடவுச்சொல் என்றால் == «sshh»:

    அச்சு ("வரவேற்பு")

வேறு:

    அச்சு (“அணுகல் மறுக்கப்பட்டது”)

கடவுச்சொல் sshh எனில் இந்த அறிவுறுத்தல் நபரை மேலும் தவிர்க்கிறது. எழுத்துகள் மற்றும் எண்களின் வேறு ஏதேனும் கலவை இருந்தால், அது "அணுகல் மறுக்கப்பட்டது" என்ற செய்தியைக் காட்டுகிறது.

அறிக்கை-வெளிப்பாடு if-elif-else

பல நிபந்தனைகள் உண்மையாக இல்லாவிட்டால் மட்டுமே, தொகுதியில் உள்ள அறிக்கை செயல்படுத்தப்படும். வேறு. இந்த வெளிப்பாடு இப்படி செயல்படுகிறது.

நிபந்தனை_1 என்றால்:

    # என்றால் தடை

    அறிக்கை

    அறிக்கை

    மேலும் அறிக்கை

எலிஃப் நிபந்தனை_2:

    # முதல் எலிஃப் தொகுதி

    அறிக்கை

    அறிக்கை

    மேலும் அறிக்கை

எலிஃப் நிபந்தனை_3:

    # இரண்டாவது எலிஃப் தொகுதி

    அறிக்கை

    அறிக்கை

    மேலும் அறிக்கை

...

வேறு

    அறிக்கை

    அறிக்கை

    மேலும் அறிக்கை

கூடுதல் நிபந்தனைகளை நீங்கள் குறிப்பிடலாம்.

உள்ளமைக்கப்பட்ட அறிக்கைகள்

பல நிபந்தனைகளைச் செயல்படுத்த மற்றொரு வழி if block இல் கூடுதல் நிபந்தனை சரிபார்ப்புகளைச் செருகுவதாகும்.

ஆபரேட்டர் if மற்றொரு நிபந்தனை தொகுதிக்குள்

gre_score = int(உள்ளீடு ("உங்கள் தற்போதைய கடன் வரம்பை உள்ளிடவும்"))

per_grad = int(உள்ளீடு ("உங்கள் கடன் மதிப்பீட்டை உள்ளிடவும்:"))

per_grad > 70 என்றால்:

    # வெளி என்றால் தொகுதி

        gre_score > 150 என்றால்:

            # உள் என்றால் தொகுதி

    அச்சு ("வாழ்த்துக்கள், நீங்கள் கடன் பெற்றுள்ளீர்கள்")

வேறு:

    அச்சு (“மன்னிக்கவும், நீங்கள் கடனுக்கு தகுதியற்றவர்”)

இந்த நிரல் ஒரு கடன் மதிப்பீட்டைச் சரிபார்க்கிறது. 70 க்கும் குறைவாக இருந்தால், பயனர் கடன் பெற தகுதியற்றவர் என்று நிரல் தெரிவிக்கிறது. அது அதிகமாக இருந்தால், தற்போதைய கிரெடிட் வரம்பு 150ஐ விட அதிகமாக உள்ளதா என்பதைப் பார்க்க இரண்டாவது சோதனை செய்யப்படுகிறது. ஆம் எனில், கடன் வழங்கப்பட்டதாக ஒரு செய்தி காட்டப்படும்.

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

இப்போது அந்த நிரலை சற்று மறுவேலை செய்வோம்.

gre_score = int(உள்ளீடு ("தற்போதைய வரம்பை உள்ளிடவும்: "))

per_grad = int(உள்ளீடு ("கிரெடிட் ஸ்கோரை உள்ளிடவும்: "))

per_grad > 70 என்றால்:

    gre_score > 150 என்றால்:

        அச்சு ("வாழ்த்துக்கள், நீங்கள் கடன் பெற்றுள்ளீர்கள்")

    வேறு:

        அச்சு ("உங்கள் கடன் வரம்பு குறைவாக உள்ளது")

வேறு:

    அச்சு ("மன்னிக்கவும், நீங்கள் கடன் பெற தகுதியற்றவர்")

குறியீடு மிகவும் ஒத்ததாக உள்ளது, ஆனால் உள்ளமை if அதிலிருந்து வரும் நிபந்தனை தவறானதாக இருந்தால், ஒரு வழிமுறையையும் வழங்குகிறது. அதாவது, அட்டையின் வரம்பு போதுமானதாக இல்லை, ஆனால் கடன் வரலாறு நன்றாக உள்ளது, "உங்களிடம் குறைந்த கடன் மதிப்பீடு உள்ளது" என்ற செய்தி காட்டப்படும்.

if-else ஒரு நிபந்தனைக்குள் அறிக்கை வேறு

தேர்வு மதிப்பெண்களின் அடிப்படையில் ஒரு மாணவரின் தரத்தை நிர்ணயிக்கும் மற்றொரு திட்டத்தை உருவாக்குவோம்.

மதிப்பெண் = உள்ளீடு ("உங்கள் மதிப்பெண்ணை உள்ளிடவும்: "))

மதிப்பெண் >= 90:

    அச்சு ("அருமையானது! உங்கள் தரம் A")

வேறு:

    மதிப்பெண் >= 80:

அச்சு ("அருமையானது! உங்கள் தரம் B")

    வேறு:

மதிப்பெண் >= 70:

    அச்சு ("நல்லது! உங்கள் தரம் C")

வேறு:

    மதிப்பெண் >= 60:

அச்சிடுங்கள்

    வேறு:

அச்சு ("நீங்கள் தேர்வில் தோல்வியடைந்தீர்கள்")

ஸ்கோர் 90ஐ விட அதிகமாக உள்ளதா அல்லது அதற்கு சமமாக உள்ளதா என்பதை விண்ணப்பம் முதலில் சரிபார்க்கிறது. ஆம் எனில், அது A கிரேடை வழங்கும். இந்த நிபந்தனை தவறானது என்றால், அடுத்தடுத்த சோதனைகள் செய்யப்படுகின்றன. முதல் பார்வையில் அல்காரிதம் கிட்டத்தட்ட ஒரே மாதிரியாக இருப்பதைக் காண்கிறோம். எனவே உள்ளே சோதனை செய்வதற்கு பதிலாக வேறு கலவையைப் பயன்படுத்துவது நல்லது என்றால்-எலிஃப்-வேறு.

எனவே ஆபரேட்டர் if மிக முக்கியமான செயல்பாட்டைச் செய்கிறது - சில குறியீடு துண்டுகள் தேவைப்பட்டால் மட்டுமே செயல்படுத்தப்படுவதை இது உறுதி செய்கிறது. இது இல்லாமல் நிரலாக்கத்தை கற்பனை செய்வது சாத்தியமில்லை, ஏனென்றால் எளிமையான வழிமுறைகளுக்கு கூட "நீங்கள் இடதுபுறம் சென்றால், நீங்கள் அதைக் கண்டுபிடிப்பீர்கள், நீங்கள் வலதுபுறம் சென்றால், இதையும் அதையும் செய்ய வேண்டும்" போன்ற ஃபோர்க்குகள் தேவைப்படுகின்றன.