சுழல்கள் எந்த மொழியின் முக்கிய கருவிகளில் ஒன்றாகும். பைத்தானில் இரண்டு அடிப்படை சுழல்கள் உள்ளன, அவற்றில் ஒன்று போது. அதைப் பரிசீலிக்கவும், மேலும் படத்தைப் பற்றிய சிறந்த புரிதலுக்காக, இன்னும் ஒன்று. உண்மையில், இதேபோன்ற ஒன்றை ஒப்பிடுகையில், எந்தவொரு பொருளையும் புரிந்துகொள்வது மிகவும் எளிதானது, இல்லையா?
ஒரு சுழற்சியின் கருத்து
ஒரு குறிப்பிட்ட செயலை பல முறை செய்ய வேண்டியிருக்கும் போது ஒரு வளையம் தேவைப்படுகிறது. இது மிகவும் எளிமையானது, ஏனெனில் உண்மையில் சுழற்சிகளுக்கான பயன்பாடுகளின் வரம்பு மிகவும் விரிவானது. பைத்தானில் இரண்டு முக்கிய வகையான சுழல்கள் உள்ளன: அதற்கு மற்றும் போது. மிகவும் பிரபலமானது.
குறிப்பிட்ட செயல்களுக்கு கூடுதலாக, நீங்கள் ஒரு குறிப்பிட்ட புள்ளி வரை வெவ்வேறு குறியீடு துண்டுகளை லூப் செய்யலாம். இது ஒரு குறிப்பிட்ட எண்ணிக்கையிலான முறை அல்லது ஒரு குறிப்பிட்ட நிபந்தனை உண்மையாக இருக்கும் வரை இருக்கலாம்.
லூப்களின் வகைகளைப் புரிந்துகொள்வதற்கு முன், குறிப்பாக, மறு செய்கை என்றால் என்ன என்பதை நாம் இன்னும் புரிந்து கொள்ள வேண்டும். இது தற்போதைய பயன்பாட்டு இயக்கத்தில் நடப்பு சுழற்சியின் போது ஒரு செயல் அல்லது செயல்களின் வரிசையின் ஒரு மறுநிகழ்வு ஆகும்.
சைக்கிள்
எங்கள் For loop ஒரு கவுண்டர் அல்ல, பல மொழிகளில் உள்ளது. அதன் பணி மதிப்புகளின் ஒரு குறிப்பிட்ட வரிசையை கணக்கிடுவதாகும். இதன் பொருள் என்ன? எங்களிடம் கூறுகளின் பட்டியல் உள்ளது என்று வைத்துக்கொள்வோம். முதலில், லூப் முதல், இரண்டாவது, மூன்றாவது, மற்றும் பலவற்றை எடுக்கும்.
பைத்தானில் உள்ள இந்த லூப்பின் நன்மை என்னவென்றால், லூப்பில் இருந்து எப்போது வெளியேற வேண்டும் என்பதை அறிய உறுப்பு குறியீட்டை நீங்கள் தீர்மானிக்க வேண்டியதில்லை. எல்லாம் தானாக நடக்கும்.
>>> spisok = [10, 40, 20, 30]
>>> spisok இல் உள்ள உறுப்புக்கு:
… அச்சு (உறுப்பு + 2)
...
12
42
22
32
எங்கள் எடுத்துக்காட்டில், நாங்கள் மாறியைப் பயன்படுத்தினோம் உறுப்பு for கட்டளைக்குப் பிறகு. பொதுவாக, பெயர் எதுவும் இருக்கலாம். உதாரணமாக, ஒரு பிரபலமான பதவி i. ஒவ்வொரு மறு செய்கையிலும், இந்த மாறிக்கு பட்டியலிலிருந்து ஒரு குறிப்பிட்ட பொருள் ஒதுக்கப்படும், அதை நாங்கள் பொருத்தமான சொல் என்று அழைத்தோம்.
எங்கள் விஷயத்தில், பட்டியல் 10,40,20,30 எண்களின் வரிசையாகும். ஒவ்வொரு மறு செய்கையிலும், தொடர்புடைய மதிப்பு மாறியில் தோன்றும். உதாரணமாக, லூப் தொடங்கியவுடன், மாறி உறுப்பு மதிப்பு 10 ஒதுக்கப்பட்டுள்ளது. அடுத்த மறு செய்கையில், பத்து எண் 40 ஆகவும், மூன்றாவது முறை அது எண் 20 ஆகவும், இறுதியாக, லூப்பின் கடைசி மறு செய்கையில், அது 30 ஆகவும் மாறும்.
சுழற்சியின் முடிவுக்கான சமிக்ஞை பட்டியலில் உள்ள உறுப்புகளின் முடிவாகும்.
பிற நிரலாக்க மொழிகளில் உள்ளதைப் போல, மதிப்புகளின் உன்னதமான கணக்கீட்டைச் செய்ய உங்களுக்கு லூப் தேவைப்பட்டால், நமக்குத் தேவையான மதிப்பு வரை இயற்கை எண்களின் வரிசையுடன் பட்டியலை உருவாக்க வேண்டும்.
>>> spisok = [1,2,3,4,5]
அல்லது செயல்பாட்டைப் பயன்படுத்தவும் லென்(), பட்டியலின் நீளத்தை தீர்மானிக்க. ஆனால் இந்த விஷயத்தில் ஒரு வளையத்தைப் பயன்படுத்துவது நல்லது போது, ஏனெனில் மாறியைப் பயன்படுத்த வேண்டிய அவசியமில்லை.
பட்டியலில் உள்ள மதிப்புகளின் வரிசையை நீங்கள் மாற்ற வேண்டும் என்றால், லூப் ஐந்து மற்றும் இங்கே மீட்பு வருகிறது. இதைச் செய்ய, ஒவ்வொரு மறு செய்கையிலும், பட்டியலின் ஒவ்வொரு உறுப்புக்கும் பொருத்தமான மதிப்பை ஒதுக்க வேண்டும்.
லூப் போது
சுழற்சி போலல்லாமல் ஐந்து, இது வரிசையின் மதிப்புகள், லூப்பின் மீது வெறுமனே மீண்டும் மீண்டும் செய்கிறது போது அதிக பயன்களை கொண்டுள்ளது. இந்த வகை சுழற்சிகளின் பெயர் "இன்னும்" என மொழிபெயர்க்கப்பட்டுள்ளது. அதாவது, "வரை".
இது அனைத்து நிரலாக்க மொழிகளிலும் காணப்படும் உலகளாவிய வளையமாகும். மேலும் சில வழிகளில் இது ஒரு நிபந்தனை ஆபரேட்டரை ஒத்திருக்கிறது யோவ், இது ஒரு குறிப்பிட்ட நிபந்தனை பூர்த்தி செய்யப்பட்டுள்ளதா என்பதை சரிபார்க்கிறது. நிபந்தனை ஆபரேட்டருக்கு மாறாக மட்டுமே, போது ஒரு முறை அல்ல, ஒவ்வொரு மறு செய்கையிலும் சரிபார்ப்பைச் செய்கிறது. நிபந்தனை தவறானதாக இருந்தால் மட்டுமே, லூப் முடிவடைகிறது மற்றும் அதைத் தொடர்ந்து வரும் கட்டளை செயல்படுத்தப்படும். எளிமையான வார்த்தைகளில், அவர் வேலை செய்யும் சூழ்நிலை இனி செல்லுபடியாகாது.
நாம் ஒரு சுழற்சியை வரைந்தால் போது எளிமையாக, இது அத்தகைய திட்டத்தைப் பயன்படுத்தி செய்யப்படுகிறது.
நிரலின் முக்கிய கிளை (இது வளையத்திற்கு வெளியே இயங்கும்) நீல செவ்வகங்களுடன் இந்த படத்தில் சித்தரிக்கப்பட்டுள்ளது. டர்க்கைஸ் சுழற்சியின் உடலைக் குறிக்கிறது. இதையொட்டி, ஒரு ரோம்பஸ் என்பது ஒவ்வொரு மறு செய்கையிலும் சரிபார்க்கப்படும் ஒரு நிபந்தனையாகும்.
சைக்கிள் போது இரண்டு விதிவிலக்குகள் ஏற்படலாம்:
- சுழற்சியின் தொடக்கத்தில் தருக்க வெளிப்பாடு உண்மையாகத் திரும்பவில்லை என்றால், அது வெறுமனே தொடங்காது, செயல்படுத்தப்படுவதற்கு முன்பு முடிந்தது. பொதுவாக, இந்த நிலைமை சாதாரணமானது, ஏனெனில் சில சூழ்நிலைகளில், லூப் உடலில் வெளிப்பாடுகள் இருப்பதை விண்ணப்பம் வழங்காது.
- வெளிப்பாடு எப்போதும் உண்மையாக இருந்தால், இது ஒரு வளையத்திற்கு வழிவகுக்கும். அதாவது, சுழற்சியின் முடிவில்லா ஸ்க்ரோலிங்கிற்கு. எனவே, அத்தகைய நிரல்களில், எப்போதும் லூப் அல்லது நிரலிலிருந்து வெளியேறும் அறிக்கை இருக்க வேண்டும். இருப்பினும், நிரல் ஒரு குறிப்பிட்ட நிபந்தனையின் உண்மை அல்லது பொய்யைத் தீர்மானிக்க முடிந்தால் இந்த நிலைமை எழும். அவள் இதைச் செய்யத் தவறினால், நிரல் நிறுத்தப்பட்டவுடன் ஒரு பிழை திரும்பும். அல்லது நீங்கள் பிழையைக் கையாளலாம், பின்னர், அது ஏற்பட்டால், குறிப்பிட்ட குறியீடு செயல்படுத்தப்படும்.
ஒரு பிழையை எவ்வாறு கையாள்வது என்பதற்கு ஏராளமான விருப்பங்கள் இருக்கலாம். எடுத்துக்காட்டாக, தரவை சரியாக உள்ளிடுமாறு நிரல் பயனரைக் கேட்கலாம். எனவே, ஒரு நபர் எதிர்மறை எண்ணைக் குறிப்பிட்டால், அது நேர்மறையாக மட்டுமே இருக்கும், அல்லது எண்கள் மட்டுமே இருக்க வேண்டிய எழுத்துக்களை உள்ளிட்டால், நிரல் அதைப் பற்றி சொல்ல முடியும்.
லூப் எடுத்துக்காட்டுகள்
இந்த வழக்கில் பிழையைக் கையாளும் குறியீட்டின் எடுத்துக்காட்டு இங்கே.
n = உள்ளீடு ("ஒரு முழு எண்ணை உள்ளிடவும்: ")
அதே நேரத்தில் வகை(n) != int:
முயற்சி:
n = int(n)
ValueError தவிர:
அச்சு ("தவறான நுழைவு!")
n = உள்ளீடு ("ஒரு முழு எண்ணை உள்ளிடவும்: ")
n % 2 == 0 என்றால்:
அச்சு ("கூட")
வேறு:
அச்சு ("ஒற்றைப்படை")
சிக்கலான குறியீடு கட்டமைப்பை அறிவிக்க பைதான் பெருங்குடல்களைப் பயன்படுத்துகிறது என்பதை நினைவில் கொள்ளவும்.
மேலே உள்ள குறியீட்டில், எண் முழு எண்ணாக உள்ளதா என்பதைச் சரிபார்க்க வேண்டிய நிபந்தனையாக வரையறுத்துள்ளோம். ஆம் எனில், தவறானது திரும்பும். இல்லை என்றால் உண்மை.
குறியீட்டின் இரண்டாவது பகுதியில், ஆபரேட்டர் பயன்படுத்தப்படும் இடத்தில் if, பிரிவு செயல்பாட்டிற்குப் பிறகு மீதமுள்ளதைக் கண்டறிய % ஆபரேட்டரைப் பயன்படுத்தினோம். அடுத்த கட்டமாக எண் சமமாக உள்ளதா என்பதைச் சரிபார்க்க வேண்டும். இல்லையெனில், இந்த வழக்கில் மீதமுள்ள ஒன்று. அதன்படி, எண் ஒற்றைப்படை.
எளிமையான சொற்களில், மேலே உள்ள குறியீடு பயனரால் உள்ளிடப்பட்ட சரம் ஒரு எண்ணா என்பதை முதலில் சரிபார்க்கும். ஆம் எனில், இரண்டால் வகுக்கப்பட்டதில் மீதி இருக்கிறதா என்று பார்க்க இரண்டாவது சரிபார்ப்பு செய்யப்படுகிறது. ஆனால் பயனரால் உள்ளிடப்பட்ட மதிப்பு எண்ணாக இருக்கும் வரை இரண்டாவது தொகுதி செயல்படுத்தப்படாது.
அதாவது, நிலை ஏற்படும் வரை லூப் தொடர்ந்து செயல்படுத்தப்படும். இந்த சூழ்நிலையில், இது இப்படி வேலை செய்கிறது.
அதாவது, நீங்கள் எதிர் திசையில் இருந்து செல்லலாம்: நிகழ்வு தவறானதாக மாறும் வரை ஒரு குறிப்பிட்ட செயலை லூப் செய்யுங்கள்.
குறியீடு பாகுபடுத்துதல்
இப்போது இந்த குறியீடு எவ்வாறு செயல்படுகிறது என்பதை இன்னும் விரிவாகப் பார்ப்போம். இதைச் செய்ய, அதை படிப்படியாக பகுப்பாய்வு செய்வோம்.
- முதலில், பயனர் ஒரு சரத்தில் நுழைகிறார், இது n மாறியால் ஏற்றுக்கொள்ளப்படுகிறது.
- ஒரு வளையத்தைப் பயன்படுத்துதல் போது இந்த மாறியின் வகை சரிபார்க்கப்பட்டது. முதல் பதிவில், அது சமமாக இல்லை எண்ணாக. எனவே, சோதனையின் விளைவாக, இந்த நிபந்தனை உண்மை என்று கண்டறியப்பட்டுள்ளது. எனவே, லூப் உடல் நுழைந்தது.
- ஒரு ஆபரேட்டரின் உதவியுடன் முயற்சி ஒரு சரத்தை எண்ணாக மாற்ற முயற்சிக்கிறோம். இதைச் செய்தால், எந்தப் பிழையும் ஏற்படாது. அதன்படி, அதை செயலாக்க வேண்டிய அவசியமில்லை. எனவே, மொழிபெயர்ப்பாளர் சுழற்சியின் தொடக்கத்திற்குத் திரும்புகிறார், மேலும் காசோலையின் முடிவுகளின்படி, அது ஒரு முழு எண்ணாக மாறிவிட்டது. எனவே படி 7 க்கு செல்லலாம்
- மாற்றம் தோல்வியுற்றால், மதிப்புப் பிழை வீசப்படும். இந்த வழக்கில், நிரல் ஓட்டம் தவிர கையாளுபவருக்கு அனுப்பப்படும்.
- பயனர் புதிய மதிப்பை உள்ளிடுகிறார், இது n மாறிக்கு ஒதுக்கப்படுகிறது.
- மொழிபெயர்ப்பாளர் படி 2 க்கு திரும்பி மீண்டும் சரிபார்க்கிறார். இது ஒரு முழு எண் மதிப்பாக இருந்தால், படி 7 க்குச் செல்லவும். இல்லையெனில், படி 3 இன் படி மாற்றம் மீண்டும் முயற்சிக்கப்படும்.
- ஒரு ஆபரேட்டரின் உதவியுடன் if ஒரு எண்ணை 2 ஆல் வகுத்த பிறகு மீதி இருக்கிறதா என்பதை தீர்மானிக்கிறது.
- இல்லையெனில், "கூட" என்ற உரை திரும்பும்.
- இல்லையெனில், "ஒற்றைப்படை" என்ற உரை திரும்பும்.
இப்போது அத்தகைய உதாரணத்தைக் கவனியுங்கள். இந்த சுழற்சி எத்தனை முறை செல்லும் என்பதை தீர்மானிக்க முயற்சிக்கவும்?
மொத்தம் = 100
i = 0
நான் <5:
n = int(உள்ளீடு())
மொத்த = மொத்தம் - n
நான் = நான் + 1
அச்சு ("மீதம்", மொத்தம்)
சரியான பதில் 5. ஆரம்பத்தில், மாறியின் மதிப்பு i - பூஜ்யம். மாறி சமமாக உள்ளதா என்பதை மொழிபெயர்ப்பாளர் சரிபார்க்கிறார் i 4 அல்லது குறைவாக. ஆம் எனில், மதிப்பு திரும்பும். உண்மை, மற்றும் லூப் அதன்படி செயல்படுத்தப்படுகிறது. மதிப்பு ஒன்று அதிகரித்துள்ளது.
முதல் மறு செய்கைக்குப் பிறகு, மாறியின் மதிப்பு 1 ஆகிறது. ஒரு சரிபார்ப்பு செய்யப்படுகிறது, மேலும் இந்த எண் மீண்டும் 5 க்கும் குறைவாக இருப்பதை நிரல் புரிந்துகொள்கிறது. அதன்படி, லூப் பாடி இரண்டாவது முறையாக செயல்படுத்தப்படுகிறது. படிகள் ஒரே மாதிரியாக இருப்பதால், மதிப்பும் ஒன்றால் அதிகரிக்கப்படுகிறது, மேலும் மாறி இப்போது 2 க்கு சமமாக உள்ளது.
இந்த மதிப்பு ஐந்துக்கும் குறைவாக உள்ளது. பின்னர் லூப் மூன்றாவது முறையாக செயல்படுத்தப்படுகிறது, மாறியில் சேர்க்கப்பட்டது i 1 மற்றும் அதற்கு மதிப்பு 3 ஒதுக்கப்பட்டுள்ளது. இது மீண்டும் ஐந்திற்கும் குறைவாக உள்ளது. எனவே இது சுழற்சியின் ஆறாவது மறு செய்கைக்கு வருகிறது, இதில் மாறியின் மதிப்பு i 5 க்கு சமம் (எல்லாவற்றிற்கும் மேலாக, இது முதலில் பூஜ்ஜியமாக இருந்தது, நமக்கு நினைவிருக்கும் வரை). அதன்படி, இந்த நிபந்தனை சோதனையில் தேர்ச்சி பெறாது, மேலும் சுழற்சி தானாகவே நிறுத்தப்பட்டு, அதற்கு வெளியே உள்ள அடுத்த கட்டத்திற்கு மாறுவது (அல்லது நிரல் நிறுத்தம், பின்வரும் படிகள் வழங்கப்படாவிட்டால்) மேற்கொள்ளப்படுகிறது.
சுழற்சி எதிர் திசையிலும் ஏற்படலாம். ஒவ்வொரு அடுத்தடுத்த மறு செய்கையிலும், மாறியின் தற்போதைய மதிப்பிலிருந்து ஒன்று கழிக்கப்படும் குறியீட்டின் எடுத்துக்காட்டு இங்கே.
மொத்தம் = 100
மொத்தம் > 0:
n = int(உள்ளீடு())
மொத்த = மொத்தம் - n
அச்சு ("வளம் தீர்ந்துவிட்டது")
இந்த திட்டம் என்ன செய்கிறது என்று யூகிக்க முயற்சிக்கவும்! அதை ஒரு மாறியில் கற்பனை செய்து பாருங்கள் மொத்த நிரல் வளத்தைப் பற்றிய தகவல்கள் சேமிக்கப்படுகின்றன. ஒவ்வொரு முறையும் மொழிபெயர்ப்பாளர் ஆதாரம் இருக்கிறதா என்று சரிபார்க்கிறார். இல்லையெனில், "வளம் தீர்ந்துவிட்டது" என்ற உரை காட்டப்படும் மற்றும் நிரல் மூடப்படும். லூப்பின் ஒவ்வொரு மறு செய்கையிலும், பயனர் குறிப்பிடும் எண்ணிக்கையால் ஆதாரம் குறைகிறது.
இப்போது வீட்டுப்பாடம். மேலே உள்ள குறியீட்டை மாற்ற முயற்சிக்கவும், இதனால் மாறி உடல் ரீதியாக எதிர்மறையாக மாறாது.
si குறியீடு அஹான் உஸூ குட்பி
போன்றவை
ஹலோ
: lol: