पायथन इटरेटर

पायथन इटरेटर

इटरेटर एक ऑब्जैक्ट है जो मात्राओं की गणनीय संख्या शामिल करता है。

इटरेटर इटरेबल ऑब्जैक्ट है, जिसका अर्थ है कि आप सभी मात्राओं को अनुक्रमित कर सकते हैं。

प्रौद्योगिकीय रूप से, पायथन में, इटरेटर ऐसे ऑब्जैक्ट हैं जो इटरेटर प्रोटोकॉल को कार्यान्वित करते हैं, जो निम्नलिखित तरीकों को शामिल करते हैं __iter__() और __नेक्स्ट__()।

इटरेटर VS इटरेबल ऑब्जैक्ट (Iterable)

सूची, टुपल, डिक्शनर और सेट इटरेबल ऑब्जैक्ट हैं। वे इटरेबल कंटेनर हैं, जिनसे आप इटरेटर (Iterator) प्राप्त कर सकते हैं (Iterator)।

ये सभी ऑब्जैक्ट इटरेटर प्राप्त करने के लिए एक तरीका है iter() तरीका:

उदाहरण

मात्राओं को इटरेट करने के लिए एक इटरेटर वापस करता है और प्रत्येक मात्रा को प्रिंट करता है:

mytuple = ("apple", "banana", "cherry")
myit = iter(mytuple)
print(next(myit))
print(next(myit))
print(next(myit))

उदाहरण चलाएं

यहां तक कि स्ट्रिंग भी इटरेबल ऑब्जैक्ट है और इटरेटर वापस कर सकता है:

उदाहरण

स्ट्रिंग भी इटरेबल ऑब्जैक्ट है, जो एक श्रृंखला अक्षरों को शामिल करता है:

mystr = "banana"
myit = iter(mystr)
print(next(myit))
print(next(myit))
print(next(myit))
print(next(myit))
print(next(myit))
print(next(myit))

उदाहरण चलाएं

इटरेटर अनुक्रम

हम भी for लूप का उपयोग करके इटरेबल ऑब्जैक्ट का अनुक्रम कर सकते हैं:

उदाहरण

मात्राओं को इटरेट करता है:

mytuple = ("apple", "banana", "cherry")
for x in mytuple:
  प्रिंट(एक्स)

उदाहरण चलाएं

उदाहरण

इटरेटर स्ट्रिंग में अक्षरों को इटरेट करता है:

mystr = "banana"
for x in mystr:
  प्रिंट(एक्स)

उदाहरण चलाएं

सूचना:for लूप वास्तव में एक इटरेटर ऑब्जैक्ट बना देता है और प्रत्येक लूप अंश के लिए अगर आपके पास पर्याप्त मथड़ी होती है。

इटरेटर बनाना होगा

अगर आप ऑब्जैक्ट/क्लास को एक इटरेटर के रूप में बनाना चाहते हैं, तो आपको ऑब्जैक्ट को __iter__() और __नेक्स्ट__() मथड़ी होती है。

जैसा कि आपने पायथन की वर्ग/ऑब्जैक्ट पर की शिक्षा ली है, सभी वर्गों के पास एक नाम __init__() के फ़ंक्शन, जो आपको ऑब्जैक्ट को बनाते समय कुछ चालू करने की अनुमति देता है。

__iter__() __इटर__()

__नेक्स्ट__() मेथड का काम इसी प्रकार है, आपको कार्य कर सकते हैं (आरंभ आदि), लेकिन हमेशा इटरेटर ऑब्जैक्ट को वापस करना होगा。

उदाहरण

मेथड भी आपको कार्य करने की अनुमति देती है और आपको अनुसूची में अगला आयाम वापस करना होगा。

क्लास माईनबर्स:
  डेफ़ __इटर__(सेल्फ़):
    सेल्फ़.ए = 1
    रिटर्न सेल्फ़
  डेफ़ __नेक्स्ट__(सेल्फ़):
    एक्स = सेल्फ़.ए
    सेल्फ़.ए = सेल्फ़.ए + 1
    रिटर्न एक्स
माईक्लास = माईनबर्स()
माईइटर = इटर(माईक्लास)
एक नंबर वाले इटरेटर को सिर्जा करें जो 1 से शुरू होता है और प्रत्येक श्रृंखला में 1 बढ़ता है (1, 2, 3, 4, 5 आदि को वापस करता है):
एक नंबर वाले इटरेटर को सिर्जा करें जो 1 से शुरू होता है और प्रत्येक श्रृंखला में 1 बढ़ता है (1, 2, 3, 4, 5 आदि को वापस करता है):
एक नंबर वाले इटरेटर को सिर्जा करें जो 1 से शुरू होता है और प्रत्येक श्रृंखला में 1 बढ़ता है (1, 2, 3, 4, 5 आदि को वापस करता है):
एक नंबर वाले इटरेटर को सिर्जा करें जो 1 से शुरू होता है और प्रत्येक श्रृंखला में 1 बढ़ता है (1, 2, 3, 4, 5 आदि को वापस करता है):
एक नंबर वाले इटरेटर को सिर्जा करें जो 1 से शुरू होता है और प्रत्येक श्रृंखला में 1 बढ़ता है (1, 2, 3, 4, 5 आदि को वापस करता है):

उदाहरण चलाएं

स्टॉपइटरेशन

प्रिंट(नेक्स्ट(माईइटर)) अगर आपके पास पर्याप्त नेक्स्ट()

इटरेशन को हमेशा चलाने से रोकने के लिए, हम एक स्टेटमेंट का उपयोग कर सकते हैं, या फ़िर for लूप में इसे उपयोग कर सकते हैं, तो उपरोक्त उदाहरण हमेशा चलता रहेगा。 स्टॉपइटरेशन स्टेटमेंट.

में __नेक्स्ट__() मेथड में, अगर इटरेशन निर्धारित बारंबारता पूरी कर दी है, तो हम एक रुकने की शर्त जोड़ सकते हैं ताकि त्रुटि उत्पन्न करें:

उदाहरण

20 इटरेशन के बाद रुकना:

क्लास माईनबर्स:
  डेफ़ __इटर__(सेल्फ़):
    सेल्फ़.ए = 1
    रिटर्न सेल्फ़
  डेफ़ __नेक्स्ट__(सेल्फ़):
    अगर सेल्फ़.ए <= 20:
      एक्स = सेल्फ़.ए
      सेल्फ़.ए = सेल्फ़.ए + 1
      रिटर्न एक्स
    अल्थर्नेटिव:
      रेइज़ स्टॉपइटरेशन
माईक्लास = माईनबर्स()
माईइटर = इटर(माईक्लास)
फ़ॉर एक्स इन माईइटर:
  प्रिंट(एक्स)

उदाहरण चलाएं