பைதான் லூப்பில் குறியீட்டை எவ்வாறு அணுகுவது

பைதான் சுழல்களைப் புரிந்துகொள்வது:

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

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

பைதான் லூப் இன்டெக்ஸிங் பற்றிய விரிவான விளக்கம்

முதல் ஸ்கிரிப்ட்டில், நாம் பயன்படுத்துகிறோம் enumerate() பட்டியல் மூலம் வளைய செயல்பாடு xs குறியீட்டை ஒரே நேரத்தில் கண்காணிக்கும் போது. தி start என்ற வாதம் enumerate() 1 க்கு அமைக்கப்பட்டது, இயல்புநிலை 0 க்கு பதிலாக 1 இலிருந்து தொடங்குவதை உறுதிசெய்கிறது. enumerate() செயல்பாடு குறியீட்டு மற்றும் மதிப்பின் ஜோடிகளை வழங்குகிறது, அதை நாம் திறக்கிறோம் index மற்றும் x லூப் ஹெடரில். தி print செயல்பாடு பின்னர் விரும்பிய வெளியீட்டு வடிவமைப்பின் படி இந்த மதிப்புகளை வடிவமைத்து வெளியிடுகிறது.

இரண்டாவது ஸ்கிரிப்ட் குறியீட்டை கைமுறையாக கண்காணிப்பதன் மூலம் அதே முடிவை அடைகிறது. நாங்கள் துவக்குகிறோம் index லூப் தொடங்கும் முன் 1. சுழற்சியின் உள்ளே, தற்போதைய குறியீட்டையும் மதிப்பையும் பயன்படுத்தி அச்சிடுகிறோம் format சரங்களின் முறை, பின்னர் அதிகரிப்பு index 1 ஐப் பயன்படுத்தி += இயக்குபவர். மூன்றாவது ஸ்கிரிப்ட் பயன்படுத்துகிறது range() மற்றும் len() 1 முதல் நீளம் வரை குறியீட்டு மதிப்புகள் மீது இயங்கும் ஒரு வளையத்தை உருவாக்க xs. லூப்பின் உள்ளே, பட்டியல் உறுப்புகளைப் பயன்படுத்தி அணுகுவோம் xs[index - 1] ஒவ்வொரு குறியீட்டிற்கும் சரியான மதிப்பைப் பெற.

xs = [8, 23, 45]
for index, x in enumerate(xs, start=1):
    print("item #{} = {}".format(index, x))

xs = [8, 23, 45]
index = 1
for x in xs:
    print("item #{} = {}".format(index, x))
    index += 1

xs = [8, 23, 45]
for index in range(1, len(xs) + 1):
    print("item #{} = {}".format(index, xs[index - 1]))

மாற்று அட்டவணைப்படுத்தல் முறைகளைப் புரிந்துகொள்வது

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

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