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

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

• ஒரு கண்ணி என்றால் என்ன?
• கட்டுப்பாட்டு ஓட்டம்
• பைதான் கட்டுப்பாட்டு அறிக்கைகள் சிறிது நேரத்தில்
• நிபந்தனை அறிக்கைகளுடன் சுழலும் போது
• எல்லையற்ற போது சுழற்சி
• லூப் போது கூடு

ஒரு கண்ணி என்றால் என்ன?

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

போது (சோதனை வெளிப்பாடு): # அறிக்கைகள் அதே நேரத்தில்

கட்டுப்பாட்டு ஓட்டம்

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

மலைப்பாம்பில் def __init__

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

பைதான் கட்டுப்பாட்டு அறிக்கைகள் சிறிது நேரத்தில்

இடைவேளை அறிக்கை:

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

i = 1 நான்<= 5 : print(i) if i == 4: break i = i+1 

 வெளியீடு: 1 2 3 4

X இன் மதிப்பு 4 ஆனவுடன், மரணதண்டனை மீதமுள்ள மறு செய்கைகளைத் தவிர்க்கும். இது மரணதண்டனை எவ்வாறு பாதிக்கிறது என்பதைப் புரிந்துகொள்வது தொடர்ச்சியான அறிக்கையுடன் மற்றொரு உதாரணத்தை எடுக்க உதவுகிறது.

அறிக்கையைத் தொடரவும்

ஜாவாவில் ஒரு சக்திக்கு ஏதாவது உயர்த்தவும்

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

i = 1 நான்<=5 : if i == 4: i = i+1 continue else: print(i) i = i+1 

 வெளியீடு: 1 2 3 5

தொடர் அறிக்கையை சுழற்சியில் சந்தித்தவுடன், தற்போதைய மறு செய்கை தவிர்க்கப்பட்டது மற்றும் மீதமுள்ள மறு செய்கைகளை லூப் செயல்படுத்துகிறது.

நிபந்தனை அறிக்கைகளுடன் சுழலும் போது

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

num = int (உள்ளீடு ('ஒரு எண்ணை உள்ளிடுக')), எண்> = 0: என்றால் எண் == 0: அச்சு ('பூஜ்ஜியத்திற்கு சமம்') எலிஃப் எண்> 0: அச்சு ('பூஜ்ஜியத்தை விட பெரியது') வேறு: அச்சு ( 'சரியான எண்ணை உள்ளிடுக') இடைவெளி

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

எல்லையற்ற போது சுழற்சி

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

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

i = 4 போது i> 0: அச்சு ('நான் எல்லையற்ற போது சுழற்சியாக இருக்கிறேன்')

இந்த நிரல் எல்லையற்ற மறு செய்கைகளை இயக்கும், நாம் ctrl + c ஐ அழுத்தினால் அல்லது கட்டுப்பாட்டு அறிக்கையை வளையத்தில் வைக்காவிட்டால்.

லூப் போது கூடு

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

இதைப் புரிந்துகொள்ள ஒரு உதாரணத்தைப் பார்ப்போம்:

i = 1 j = 5 நான் 0: அச்சு (i, j) j = j -1 i = i + 1

 வெளியீடு: 1 5 2 4 3 3 4 2 5 1

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

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

i = 'edureka' j = 1 போது j> 0: i இல் x க்கு: அச்சிடு (j, x) j = j + 1 என்றால் x == 'a': உடைக்கவும்

 வெளியீடு: 1 e 2 d 3 u 4 r 5 e 6 k 7 a

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

SQL சேவையக எடுத்துக்காட்டுகளில் அடி மூலக்கூறு

ஏதேனும் கேள்விகள் உள்ளதா? கருத்துகள் பிரிவில் அவற்றைக் குறிப்பிடுங்கள். நாங்கள் விரைவில் உங்களைத் தொடர்புகொள்வோம்.