Python Enumerate ट्यूटोरियल

इस ट्यूटोरियल में, हम चर्चा करेंगे कि Python में enumerate() फ़ंक्शन क्या है, इसे कब उपयोग किया जाता है, यह किस प्रकार की ऑब्जेक्ट बनाता है, इसका सिंटैक्स क्या है, और यह कैसे काम करता है। फिर, हम Python में अलग-अलग प्रकार के ऑब्जेक्ट्स को enumerate करने के उदाहरण देखेंगे, enumerate() फ़ंक्शन के विकल्पों पर नज़र डालेंगे, और समझेंगे कि वे उसी कार्य के लिए कम उपयुक्त क्यों हैं।

Python में Enumerate क्या है और इसे कब इस्तेमाल किया जाता है?

enumerate() फ़ंक्शन Python का एक बिल्ट-इन फ़ंक्शन है जो किसी iterable (आइटम्स का कलेक्शन या कोई भी अन्य Python ऑब्जेक्ट जो iteration का समर्थन करता है, जैसे tuples, lists, sets, या strings) को लेता है, उसके आइटम्स पर अंदरूनी तौर पर iterate करता है, और एक enumerate ऑब्जेक्ट लौटाता है। दूसरे शब्दों में, यह फ़ंक्शन किसी iterable के प्रत्येक आइटम को 1-1 बढ़ने वाली गिनती असाइन करता है और उस ऑब्जेक्ट पर लूप चलाते समय iterations को ट्रैक करने में मदद करता है। enumerate ऑब्जेक्ट बनने के बाद, हम इसे list, tuple, या dictionary में बदल सकते हैं (क्रमशः list(), tuple(), या dict() फ़ंक्शन्स का उपयोग करके), या सीधे इसी ऑब्जेक्ट पर लूप लगाकर आइटम्स और उनके संबंधित इंडेक्स, दोनों तक पहुंच सकते हैं।

enumerate() फ़ंक्शन का उपयोग for-loops की तुलना में मेमोरी और कंप्यूटिंग दक्षता के लिहाज़ से लाभदायक होता है क्योंकि यह एक ही बार में इंडेक्स और संबंधित आइटम दोनों लौटाता है।

सिंटैक्स

enumerate() फ़ंक्शन का सिंटैक्स बहुत सरल है:

enumerate(iterable, start=0)

यहाँ, iterable वह iterable ऑब्जेक्ट है जिसे हम enumerate करना चाहते हैं, और start एक वैकल्पिक पैरामीटर है जो काउंटर के शुरुआती इंडेक्स को परिभाषित करता है (डिफ़ॉल्ट रूप से, यह सामान्य Python का 0-आधारित इंडेक्स होगा)।

ध्यान दें कि किसी iterable पर enumerate() लागू करने से मूल ऑब्जेक्ट में कोई बदलाव नहीं होता। इसके बजाय, यदि हम इसे आगे उपयोग करना चाहते हैं, तो परिणामी enumerate ऑब्जेक्ट को किसी वैरिएबल में असाइन करना चाहिए।

अब देखते हैं कि यह फ़ंक्शन Python के अलग-अलग प्रकार के iterables पर कैसे काम करता है।

लिस्ट को Enumerate करना

सबसे पहले, हम Python लिस्ट पर enumerate() फ़ंक्शन लागू करेंगे:

drinks = ['tea', 'coffee', 'cappuccino', 'lemonade']
enumerated_drinks = enumerate(drinks)
print(type(enumerated_drinks))
print(enumerated_drinks)

 आउटपुट:

<class 'enumerate'>
<enumerate object at 0x000002DC3A1145C0>

परिणामी ऑब्जेक्ट का टाइप enumerate है, और जब हमने इसे प्रिंट करने की कोशिश की, तो हमें दोबारा ऑब्जेक्ट का टाइप और यह कंप्यूटर मेमोरी में कहाँ स्टोर है, यही दिखा। चलिए, उसी तरह इस ऑब्जेक्ट के पहले एलिमेंट तक पहुँचने की कोशिश करते हैं जैसे हम Python लिस्ट या tuple के साथ करते हैं:

print(enumerated_drinks[0])

 आउटपुट:

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
~\AppData\Local\Temp/ipykernel_5948/1233607596.py in <module>
----> 1 print(enumerated_drinks[0])

TypeError: 'enumerate' object is not subscriptable

हमें एक त्रुटि मिली जो बताती है कि enumerate ऑब्जेक्ट के घटकों तक इस तरह से नहीं पहुँचा जा सकता। इसके बजाय, इसके लिए हमें इसे list, tuple, या dictionary में बदलना होगा, या सीधे enumerate ऑब्जेक्ट पर लूप लगाना होगा। चलिए अपने enumerate ऑब्जेक्ट को list में बदलते हैं:

list_enumerated_drinks = list(enumerated_drinks)
print(list_enumerated_drinks)

 आउटपुट:

[(0, 'tea'), (1, 'coffee'), (2, 'cappuccino'), (3, 'lemonade')]

अब हमें परिणामी लिस्ट की आंतरिक संरचना साफ़ दिखाई देती है: प्रत्येक आइटम एक 2-तत्वों वाला tuple है जहाँ पहला तत्व मूल लिस्ट में संबंधित आइटम का इंडेक्स है और दूसरा तत्व आइटम स्वयं। हम इस लिस्ट के एलिमेंट्स तक पहुँचने के लिए सामान्य इंडेक्सिंग का उपयोग कर सकते हैं:

print(list_enumerated_drinks[0])
print(list_enumerated_drinks[0][1])

 आउटपुट:

(0, 'tea')
tea

अब मूल लिस्ट से बने enumerate ऑब्जेक्ट को tuple में बदलने की कोशिश करते हैं। साथ ही, इस बार हम start वैकल्पिक पैरामीटर को 1 पर सेट करेंगे:

tuple_enumerated_drinks = tuple(enumerate(drinks, start=1))
print(tuple_enumerated_drinks)

 आउटपुट:

((1, 'tea'), (2, 'coffee'), (3, 'cappuccino'), (4, 'lemonade'))

ऊपर दिए गए tuple की आंतरिक संरचना पहले बनाई गई लिस्ट के समान है। हालांकि, इस बार हमने काउंटिंग को बदलकर इसे Python के 0-आधारित इंडेक्सिंग के बजाय अधिक "मानवीय शैली" का बना दिया।

enumerate ऑब्जेक्ट की एक रोचक मेथड यहाँ उल्लेखनीय है: next() मेथड। चलिए enumerated_drinks ऑब्जेक्ट को फिर से बनाते हैं और इस मेथड को काम में देखते हैं:

enumerated_drinks = enumerate(drinks)
print(next(enumerated_drinks))
print(next(enumerated_drinks))
print(next(enumerated_drinks))
print(next(enumerated_drinks))
print(next(enumerated_drinks))

 आउटपुट:

(0, 'tea')
(1, 'coffee')
(2, 'cappuccino')
(3, 'lemonade')

---------------------------------------------------------------------------
StopIteration                             Traceback (most recent call last)
~\AppData\Local\Temp/ipykernel_5948/330134057.py in <module>
      4 print(next(enumerated_drinks))
      5 print(next(enumerated_drinks))
----> 6 print(next(enumerated_drinks))

StopIteration: 

जैसा कि हम देखते हैं, enumerate ऑब्जेक्ट पर हर बार इस मेथड को कॉल करने पर यह उससे अगला आइटम लौटाता है (और हम फिर से पुष्टि कर सकते हैं कि प्रत्येक आइटम संबंधित काउंट-आइटम जोड़ी वाला 2-तत्वों का tuple है)। जब सभी आइटम समाप्त हो जाते हैं, तो enumerate ऑब्जेक्ट समाप्त हो जाता है, और उस पर next() मेथड कॉल करने का प्रयास StopIteration त्रुटि फेंकता है। वास्तव में, यदि हम अब इस enumerate ऑब्जेक्ट को list में बदलने की कोशिश करें, तो हम देखेंगे कि यह खाली है

print(list(enumerated_drinks))

 आउटपुट:

[]

इसका मतलब है कि enumerate ऑब्जेक्ट पर next() मेथड के हर उपयोग पर, उससे एक आइटम निकाला जाता है, इसलिए हर बार यह छोटा होता जाता है, और अंततः पूरी तरह समाप्त हो जाता है। हम enumerate ऑब्जेक्ट्स का यह गुण आगे भी देखेंगे जब हम उन पर for-loop लागू करने पर चर्चा करेंगे।

यदि आप Python लिस्ट्स और Python की अन्य बुनियादी अवधारणाओं के बारे में अधिक जानना चाहते हैं, तो आप DataCamp का Introduction to Python कोर्स कर सकते हैं।

Tuple को Enumerate करना

tuple पर enumerate() फ़ंक्शन का उपयोग लिस्ट पर उपयोग के समान ही है:

drinks = ('tea', 'coffee', 'cappuccino', 'lemonade')
enumerated_drinks = enumerate(drinks)
print(enumerated_drinks)

 आउटपुट:

<enumerate object at 0x000002DC3A098D40>

फिर से, हमें एक enumerate ऑब्जेक्ट मिला जिसके आइटम्स तक सामान्य Python इंडेक्सिंग से नहीं पहुँचा जा सकता। आइए, इस ऑब्जेक्ट को किसी अन्य रूप में बदलते हैं, इस बार dictionary में:

dict_enumerated_drinks = dict(enumerated_drinks)
print(dict_enumerated_drinks)

 आउटपुट:

{0: 'tea', 1: 'coffee', 2: 'cappuccino', 3: 'lemonade'}

परिणामी dictionary का प्रत्येक key:value पेयर संबंधित काउंट-आइटम जोड़ी का प्रतिनिधित्व करता है। हम dictionary के मानों तक सामान्य Pythonic तरीके से पहुँच सकते हैं:

print(dict_enumerated_drinks[0])
print(dict_enumerated_drinks[3])

 आउटपुट:

tea
lemonade

यदि आप Python dictionaries और pandas में और गहराई तक जाना चाहते हैं, तो Intermediate Python कोर्स देखें। 

String को Enumerate करना

क्योंकि Python strings वर्णों का अनुक्रम होती हैं और इसलिए iterable ऑब्जेक्ट्स भी होती हैं, हम किसी string के लिए भी एक enumerate ऑब्जेक्ट बना सकते हैं:

enumerated_hello_world = enumerate('Hello, World!', start=10)
print(enumerated_hello_world)

 आउटपुट:

<enumerate object at 0x000002DC3A145C40>

जैसा कि हमने पहले किया था, इस ऑब्जेक्ट को list में बदलते हैं:

list_enumerated_hello_world = list(enumerated_hello_world)
print(list_enumerated_hello_world)

 आउटपुट:

[(10, 'H'), (11, 'e'), (12, 'l'), (13, 'l'), (14, 'o'), (15, ','), (16, ' '), (17, 'W'), (18, 'o'), (19, 'r'), (20, 'l'), (21, 'd'), (22, '!')]

हमें परिचित 2-तत्वों वाले tuples दिखाई देते हैं, जहाँ पहला तत्व string के संबंधित वर्ण की गिनती है (इस मामले में – 10 से शुरू), और दूसरा – स्वयं वह वर्ण। स्पेस और विराम चिह्न भी गिने जाते हैं।

आइए enumerated_hello_world ऑब्जेक्ट को फिर से बनाते हैं, इस बार start=10 के बिना, और उस पर next मेथड लागू करते हैं:

enumerated_hello_world = enumerate('Hello, World!')
print(next(enumerated_hello_world))
print(next(enumerated_hello_world))
print(next(enumerated_hello_world))
print(next(enumerated_hello_world))
print(next(enumerated_hello_world))
print(next(enumerated_hello_world))
​
# Creating a list from the remaining enumerate object
print(list(enumerated_hello_world))

 आउटपुट:

(0, 'H')
(1, 'e')
(2, 'l')
(3, 'l')
(4, 'o')
(5, ',')
[(6, ' '), (7, 'W'), (8, 'o'), (9, 'r'), (10, 'l'), (11, 'd'), (12, '!')]

ऊपर दिए गए कोड के आखिरी लाइन में, हमने next() मेथड का उपयोग रोक दिया और enumerated_hello_world ऑब्जेक्ट को list में बदल दिया। परिणामी लिस्ट में, next() मेथड को कई बार लागू करने के बाद मूल enumerate ऑब्जेक्ट के शेष वर्ण शामिल हैं।

For-Loop के साथ Enumerate करना

आखिर में, देखते हैं कि enumerate() फ़ंक्शन for-loop के साथ मिलकर कैसे काम करता है:

for item in enumerate(['tea', 'coffee', 'cappuccino', 'lemonade']):
  print(item)

 आउटपुट:

(0, 'tea')
(1, 'coffee')
(2, 'cappuccino')
(3, 'lemonade')

हर iteration पर संबंधित काउंट-आइटम tuple लौटाया जाता है, ठीक वैसे ही जैसे हम next() मेथड का उपयोग करते हैं। भले ही ऊपर के कोड से यह साफ़ न हो, enumerate ऑब्जेक्ट भी प्रत्येक iteration में अपने आइटम्स (यानी, 2-तत्वों वाले tuples) एक-एक करके खोता जाता है। इसे दिखाने के लिए, ऊपर के कोड को अलग रूप में लिखते हैं और सभी iterations के बाद परिणामी लिस्ट की लंबाई जाँचते हैं:

drinks = ['tea', 'coffee', 'cappuccino', 'lemonade']
enumerated_drinks = enumerate(drinks)
​
for item in enumerated_drinks:
  print(item)
 
print(list(enumerated_drinks))

 आउटपुट: 

(0, 'tea')
(1, 'coffee')
(2, 'cappuccino')
(3, 'lemonade')
[]

जैसा कि next() मेथड के उपयोग में था, enumerate ऑब्जेक्ट पर iterate करना उसे धीरे-धीरे समाप्त कर देता है।

फिर भी, पिछले कोड पर लौटते हैं। हम प्रत्येक 2-तत्वों वाले tuple से हर एलिमेंट को अलग-अलग कैसे एक्सेस कर सकते हैं? इसके लिए, हम एक और iteration वैरिएबल जोड़ेंगे और tuples को अनपैक करेंगे:

for count, drink in enumerate(['tea', 'coffee', 'cappuccino', 'lemonade']):
  print(count, drink)

 आउटपुट:

0 tea
1 coffee
2 cappuccino
3 lemonade

ऊपर, हमने प्रत्येक tuple के लिए दो वैरिएबल्स लौटाए: एक आइटम की गिनती के लिए और एक स्वयं आइटम के लिए।

ध्यान दें कि हम ऊपर जैसा ही ऑपरेशन enumerate() फ़ंक्शन के बिना भी लागू कर सकते हैं। उदाहरण के लिए, हम लूप के बाहर एक काउंटर वैरिएबल शुरू कर सकते हैं और लूप के प्रत्येक iteration में उसे 1 से बढ़ा सकते हैं:

count = 0
for drink in ['tea', 'coffee', 'cappuccino', 'lemonade']:
  print(count, drink)
  count += 1

 आउटपुट:

0 tea
1 coffee
2 cappuccino
3 lemonade

वैकल्पिक रूप से, हम किसी पूर्व-परिभाषित लिस्ट (या tuple, string, आदि) पर range() और len() फ़ंक्शन्स के संयोजन का उपयोग कर सकते हैं:

drinks = ['tea', 'coffee', 'cappuccino', 'lemonade']
for count in range(len(drinks)):
  print(count, drinks[count])

 आउटपुट:

0 tea
1 coffee
2 cappuccino
3 lemonade

इसके अलावा, enumerate() फ़ंक्शन के इन दोनों विकल्पों में, हम फिर भी काउंट वैरिएबल को शून्य से शुरू न करने के लिए समायोजित कर सकते हैं:

count = 1
for drink in ['tea', 'coffee', 'cappuccino', 'lemonade']:
  print(count, drink)
  count += 1
​
print('\n')
 
drinks = ['tea', 'coffee', 'cappuccino', 'lemonade']
for count in range(len(drinks)):
  print(count + 1, drinks[count])

 आउटपुट:

1 tea
2 coffee
3 cappuccino
4 lemonade


1 tea
2 coffee
3 cappuccino
4 lemonade

हालाँकि, enumerate() फ़ंक्शन के उपयोग की तुलना में, ऊपर दिए गए दोनों तरीक़े अधिक बोझिल हैं, बग-प्रवण हैं (जैसे, हम प्रत्येक iteration में काउंटर को मैन्युअली अपडेट करना भूल सकते हैं), और अधिक कोड की ज़रूरत होती है। इसलिए, जब भी हमें किसी iterable के प्रत्येक iteration पर काउंट और आइटम दोनों तक पहुँचना हो, enumerate() फ़ंक्शन का उपयोग सबसे Pythonic तरीका है।

निष्कर्ष

इस ट्यूटोरियल में, हमने Python में enumerate() फ़ंक्शन के बारे में कई बातें सीखीं, जिनमें इसके अनेक उपयोग, संभावित विकल्प, और अंततः यह अपने विकल्पों से अधिक प्रभावी क्यों है, शामिल हैं। enumerate() फ़ंक्शन अधिकांश शुरुआती Python उपयोगकर्ताओं के लिए परिचित नहीं होगा, और यहाँ तक कि उन्नत प्रोग्रामर भी इस अविश्वसनीय रूप से उपयोगी फ़ंक्शन से अनजान हो सकते हैं। 

यदि आप enumerate() के बारे में और सीखना चाहते हैं, तो Python Data Science Toolbox (Part 2) कोर्स पर विचार करें, जो iterators और iterables को विस्तार से समझाता है और नई कौशल का अभ्यास करने के लिए इंटरैक्टिव अभ्यास प्रदान करता है। इसके अतिरिक्त, यदि आप अन्य Python अवधारणाओं में निपुण होना चाहते हैं, तो आपको Learn Python with DataCamp में रुचि हो सकती है, जो विभिन्न स्किल और करियर ट्रैक्स, चीट शीट्स, ट्यूटोरियल्स, Python प्रमाणपत्र, और आकलन परीक्षण प्रदान करता है।