ഒരു പൈത്തൺ ലൂപ്പിൽ ഇൻഡക്സ് എങ്ങനെ ആക്സസ് ചെയ്യാം

പൈത്തൺ ലൂപ്പുകൾ മനസ്സിലാക്കുന്നു:

പൈത്തണിൽ ഫോർ ലൂപ്പ് ഉപയോഗിച്ച് ഒരു സീക്വൻസിലൂടെ ആവർത്തിക്കുമ്പോൾ, ഇൻഡെക്സ് മൂല്യം ആക്സസ് ചെയ്യുന്നത് പല ജോലികൾക്കും അത്യന്താപേക്ഷിതമാണ്. നിങ്ങൾ ലിസ്റ്റുകൾ, ട്യൂപ്പിൾസ് അല്ലെങ്കിൽ മറ്റ് ആവർത്തന വസ്തുക്കളുമായി പ്രവർത്തിക്കുകയാണെങ്കിലും, നിലവിലെ ഇനത്തിൻ്റെ സൂചിക അറിയുന്നത്, ഇനങ്ങൾ അവയുടെ സ്ഥാനത്തെ അടിസ്ഥാനമാക്കി പരിഷ്ക്കരിക്കുക അല്ലെങ്കിൽ ഒരു പ്രത്യേക ഫോർമാറ്റിൽ പ്രിൻ്റ് ചെയ്യുന്നത് പോലുള്ള വിവിധ സാഹചര്യങ്ങളിൽ സഹായിക്കും.

ഈ ഗൈഡിൽ, പൈത്തണിലെ ഒരു സീക്വൻസിലൂടെ ലൂപ്പ് ചെയ്യുമ്പോൾ സൂചിക മൂല്യം ആക്‌സസ് ചെയ്യുന്നതിനുള്ള വ്യത്യസ്ത വഴികൾ ഞങ്ങൾ പര്യവേക്ഷണം ചെയ്യും. ഈ രീതികൾ ചിത്രീകരിക്കുന്നതിന് ഞങ്ങൾ ഉദാഹരണങ്ങൾ ഉപയോഗിക്കും, നിങ്ങളുടെ സ്വന്തം പ്രോജക്റ്റുകളിൽ അവ ഫലപ്രദമായി പ്രയോഗിക്കാൻ കഴിയുമെന്ന് ഉറപ്പാക്കും. ഈ ലേഖനത്തിൻ്റെ അവസാനത്തോടെ, നിങ്ങളുടെ ലൂപ്പുകളിലെ ഇൻഡെക്സ് മൂല്യങ്ങൾ ആത്മവിശ്വാസത്തോടെ കൈകാര്യം ചെയ്യാനും ഉപയോഗിക്കാനും നിങ്ങൾക്ക് കഴിയും.

പൈത്തൺ ലൂപ്പ് ഇൻഡക്‌സിംഗിൻ്റെ വിശദമായ വിശദീകരണം

ആദ്യ സ്ക്രിപ്റ്റിൽ, ഞങ്ങൾ ഉപയോഗിക്കുന്നത് 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(), അവർക്ക് പട്ടികയിൽ നേരിട്ട് സൂചിക മൂല്യങ്ങൾ ഉൾപ്പെടുത്താം. നിലവിലുള്ള ഒരു ശ്രേണിയുടെ മൂല്യങ്ങളെയും സൂചികകളെയും അടിസ്ഥാനമാക്കി ഒരു പുതിയ ലിസ്റ്റ് സൃഷ്ടിക്കേണ്ടിവരുമ്പോൾ ഇത് പ്രത്യേകിച്ചും ഉപയോഗപ്രദമാകും, നിങ്ങളുടെ കോഡിലേക്ക് വഴക്കത്തിൻ്റെ ഒരു അധിക പാളി ചേർക്കുക.