પાયથોન લૂપમાં ઇન્ડેક્સને કેવી રીતે ઍક્સેસ કરવું

પાયથોન લૂપ્સને સમજવું:

જ્યારે પાયથોનમાં લૂપ માટે ક્રમ સાથે પુનરાવર્તિત થાય છે, ત્યારે ઇન્ડેક્સ મૂલ્યને ઍક્સેસ કરવું ઘણા કાર્યો માટે આવશ્યક બની શકે છે. ભલે તમે યાદીઓ, ટ્યુપલ્સ અથવા અન્ય પુનરાવર્તિત ઑબ્જેક્ટ્સ સાથે કામ કરી રહ્યાં હોવ, વર્તમાન આઇટમના અનુક્રમણિકાને જાણવું એ વિવિધ પરિસ્થિતિઓમાં મદદ કરી શકે છે, જેમ કે આઇટમ્સને તેમની સ્થિતિના આધારે સંશોધિત કરવી અથવા તેને ચોક્કસ ફોર્મેટમાં છાપવી.

આ માર્ગદર્શિકામાં, અમે પાયથોનમાં સિક્વન્સમાંથી લૂપ કરતી વખતે ઇન્ડેક્સ મૂલ્યને ઍક્સેસ કરવાની વિવિધ રીતોનું અન્વેષણ કરીશું. અમે આ પદ્ધતિઓને સમજાવવા માટે ઉદાહરણોનો ઉપયોગ કરીશું, ખાતરી કરો કે તમે તેને તમારા પોતાના પ્રોજેક્ટ્સમાં અસરકારક રીતે લાગુ કરી શકો છો. આ લેખના અંત સુધીમાં, તમે આત્મવિશ્વાસ સાથે તમારા લૂપ્સમાં અનુક્રમણિકા મૂલ્યોનું સંચાલન અને ઉપયોગ કરી શકશો.

પાયથોન લૂપ ઇન્ડેક્સીંગની વિગતવાર સમજૂતી

પ્રથમ સ્ક્રિપ્ટમાં, અમે ઉપયોગ કરીએ છીએ 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(), તેઓ સૂચિમાં સીધા જ ઇન્ડેક્સ મૂલ્યોનો સમાવેશ કરી શકે છે. આ ખાસ કરીને ઉપયોગી થઈ શકે છે જ્યારે તમારે વર્તમાન ક્રમના મૂલ્યો અને સૂચકાંકોના આધારે નવી સૂચિ બનાવવાની જરૂર હોય, તમારા કોડમાં સુગમતાનો વધારાનો સ્તર ઉમેરીને.