अधिकांश प्रोग्रामिंग भाषाओं की तरह पायथन लूपिंग कंस्ट्रक्ट बनाने के लिए while और for स्टेटमेंट्स प्रदान करता है। for स्टेटमेंट विशेष रूप से लिस्ट, टपल या स्ट्रिंग जैसे इटरेबल्स को पार करने के लिए उपयोगी है। पायथन की स्टैंडर्ड लाइब्रेरी के itertools मॉड्यूल में अधिक कुशल और तेज़ इटरेशन टूल्स परिभाषित हैं। ये इटरेटर बिल्डिंग ब्लॉक्स हास्केल और SML जैसी फंक्शनल प्रोग्रामिंग भाषाओं में समान टूल्स के पायथनिक कार्यान्वयन हैं।
itertools मॉड्यूल में फ़ंक्शन्स तीन प्रकार के होते हैं:
- इनफिनिट इटरेटर्स
- फिनाइट इटरेटर्स
- कॉम्बिनेटोरिक इटरेटर्स
इनफिनिट इटरेटर्स
निम्न फ़ंक्शन्स अनंत अनुक्रम जनरेट करते हैं:
count()
यह फ़ंक्शन स्टार्ट वैल्यू से समान रूप से स्पेस्ड वैल्यूज़ का इटरेटर लौटाता है। फ़ंक्शन में क्रमिक मान को इस अंतराल से बढ़ाने के लिए वैकल्पिक स्टेप वैल्यू हो सकती है।
>>> from itertools import count >>> for x in count(20): ... print(x) ... >>> for x in count(100, 10): ... print(x) ...
पहला स्टेटमेंट 20 से शुरू होने वाला अनंत अनुक्रम जनरेट करेगा और दूसरा 100 से 10 की स्टेपिंग फ्रीक्वेंसी के साथ नंबर जनरेट करेगा। ध्यान दें कि लूप अनंत हैं और स्वयं समाप्त नहीं होंगे। इन्हें Ctrl-C दबाकर समाप्त किया जाएगा।
cycle()
यह फ़ंक्शन दिए गए इटरेबल से प्रत्येक एलिमेंट को लौटाना शुरू करता है और इसकी कॉपी सेव करता है। एक बार एलिमेंट्स समाप्त हो जाने पर, सेव की गई कॉपी में एलिमेंट्स लौटाए जाते हैं जिससे अनंत लूप बनता है।
>>> from itertools import cycle
>>> for x in cycle("hello"):
... print(x)
...
स्ट्रिंग में कैरेक्टर्स को कीबोर्ड इंटरप्ट Ctrl-C जारी होने तक दोहराव से प्रिंट किया जाएगा।
repeat()
यह फ़ंक्शन ऑब्जेक्ट तर्क को बार-बार लौटाता है। यदि दूसरा तर्क 'times' प्रदान किया जाता है, तो पुनरावृत्ति उतनी बार होती है।
>>> from itertools import repeat
>>> for x in repeat(1):
... print(x)
...
>>> for x in repeat('hello', 10):
... print(x)
...
पहला लूप 1 को अंतहीन प्रिंट करेगा। दूसरा 'hello' को 10 बार प्रिंट करता है।
फिनाइट इटरेटर्स
निम्न श्रेणी में फ़ंक्शन्स फिनाइट इटरेटर्स लौटाते हैं जो सबसे छोटे इनपुट अनुक्रम पर समाप्त होते हैं।
accumulate()
इस फ़ंक्शन के दो पैरामीटर्स हैं। पहला एक इटरेबल (लिस्ट, टपल या स्ट्रिंग) है। दूसरा पैरामीटर डिफ़ॉल्ट रूप से operator.add() है (operator मॉड्यूल में फ़ंक्शन जो स्टैंडर्ड जोड़ ऑपरेटर को लागू करता है), लेकिन कोई अन्य फ़ंक्शन हो सकता है जो दो न्यूमेरिक पैरामीटर्स प्राप्त करता है।
accumulate(sequence, func)
इनपुट अनुक्रम के पहले दो एलिमेंट्स को func द्वारा प्रोसेस किया जाता है। प्रोसेस का परिणाम अगले इटरेशन के लिए पहला पैरामीटर होता है और func के लिए दूसरा पैरामीटर इनपुट अनुक्रम में तीसरा एलिमेंट होता है। यह प्रक्रिया तब तक दोहराई जाती है जब तक अनुक्रम समाप्त नहीं हो जाता। accumulate फ़ंक्शन एक इटरेटर लौटाता है जिसमें प्रत्येक एलिमेंट क्रमिक एलिमेंट्स के प्रोसेसिंग का संचित परिणाम होता है।
निम्न उदाहरण में, लिस्ट में नंबरों को संचयी रूप से जोड़ा जाता है। ध्यान दें कि डिफ़ॉल्ट फ़ंक्शन तर्क जोड़ ऑपरेशन है।
>>> from itertools import accumulate >>> list(accumulate([1, 2, 3, 4, 5])) [1, 3, 6, 10, 15]
हम accumulate() फ़ंक्शन के दूसरे पैरामीटर के रूप में यूजर-डिफाइंड फ़ंक्शन रख सकते हैं:
>>> def multiply(x, y): ... return x * y ... >>> list(accumulate([1, 2, 3, 4, 5], multiply)) [1, 2, 6, 24, 120]
यह व्यवहार बिल्ट-इन reduce() फ़ंक्शन के समान है। reduce() फ़ंक्शन केवल संचय का अंतिम परिणाम लौटाता है, जबकि accumulate() सभी मध्यवर्ती परिणामों का इटरेटर बनाता है।
chain()
इस फ़ंक्शन में एक से अधिक इटरेबल्स पैरामीटर के रूप में हो सकते हैं। यह पहले इटरेबल के प्रत्येक एलिमेंट को परिणामी इटरेटर में यील्ड करता है और अगले पर तब तक आगे बढ़ता है जब तक इटरेबल पैरामीटर्स समाप्त नहीं हो जाते।
>>> from itertools import chain >>> list(chain([10, 20], 'hello', range(4))) [10, 20, 'h', 'e', 'l', 'l', 'o', 0, 1, 2, 3]
dropwhile()
यह फ़ंक्शन इटरेबल से एलिमेंट्स को तब तक ड्रॉप करके एक इटरेटर लौटाता है जब तक प्रीडिकेट फ़ंक्शन तर्क True लौटाता है। जिस क्षण फ़ंक्शन False लौटाता है, सभी शेष एलिमेंट्स इटरेटर को यील्ड किए जाते हैं।
>>> from itertools import dropwhile >>> def iseven(x): ... if x % 2 == 0: ... return True ... else: ... return False ... >>> list(dropwhile(iseven, [12, 90, 61, 4, 15])) [61, 4, 15]
filterfalse()
यह फ़ंक्शन उन एलिमेंट्स को फ़िल्टर करके एक इटरेटर लौटाता है जिनके लिए प्रीडिकेट फ़ंक्शन False परिणाम देता है।
>>> from itertools import filterfalse >>> def iseven(x): ... if x % 2 == 0: ... return True ... else: ... return False ... >>> list(filterfalse(iseven, [12, 90, 61, 4, 15])) [61, 15]
islice()
यह फ़ंक्शन इटरेबल से कुछ एलिमेंट्स चुनकर एक इटरेटर बनाता है। चयन मानदंड start, stop और step पैरामीटर्स पर निर्भर करता है। चयन start मान से शुरू होता है और stop मान तक जारी रहता है। यदि stop None है, तो यह इटरेबल के अंत तक जाता है, अन्यथा चयन निर्दिष्ट इंडेक्स पर रुकता है। Step पैरामीटर डिफ़ॉल्ट रूप से 1 है। एलिमेंट्स का चयन step पैरामीटर द्वारा बढ़ाया जाता है। कोई भी पैरामीटर नेगेटिव नहीं हो सकता।
>>> from itertools import islice >>> list(islice(range(10), 1, 5, 2)) [1, 3] >>> list(islice(range(10), 0, None, 3)) [0, 3, 6, 9] >>> list(islice(range(10), 5, None)) [5, 6, 7, 8, 9] >>> list(islice(range(10), 5)) [0, 1, 2, 3, 4]
कॉम्बिनेटोरिक इटरेटर्स
निम्न फ़ंक्शन इटरेबल ऑब्जेक्ट्स से कॉम्बिनेटोरिक इटरेटर्स जनरेट करते हैं।
product()
यह फ़ंक्शन एक इटरेटर जनरेट करता है जो इनपुट अनुक्रमों में एलिमेंट्स का कार्टेशियन प्रोडक्ट है। यह नेस्टेड फोर लूप्स बनाने के समतुल्य है, प्रत्येक प्रत्येक इटरेबल अनुक्रम को पार करने के लिए।
निम्न उदाहरण में लिस्ट कॉम्प्रिहेंशन तकनीक का उपयोग दो अनुक्रमों पर दो नेस्टेड लूप्स चलाकर कार्टेशियन प्रोडक्ट बनाने के लिए किया जाता है।
>>> [[x, y] for x in [1, 2, 3] for y in ['a', 'b', 'c']] [[1, 'a'], [1, 'b'], [1, 'c'], [2, 'a'], [2, 'b'], [2, 'c'], [3, 'a'], [3, 'b'], [3, 'c']]
product() फ़ंक्शन समान परिणाम उत्पन्न करता है:
>>> from itertools import product >>> list(product([1, 2, 3], ['a', 'b', 'c'])) [(1, 'a'), (1, 'b'), (1, 'c'), (2, 'a'), (2, 'b'), (2, 'c'), (3, 'a'), (3, 'b'), (3, 'c')]
permutations()
यह फ़ंक्शन इनपुट इटरेबल में एलिमेंट्स के सभी संभावित क्रमपरिवर्तन यील्ड करता है। प्रत्येक क्रमपरिवर्तन की लंबाई इस फ़ंक्शन के दूसरे पैरामीटर के रूप में निर्दिष्ट की जा सकती है। यदि निर्दिष्ट नहीं है, तो लंबाई एक है।
>>> list(permutations(range(1, 4), 2)) [(1, 2), (1, 3), (2, 1), (2, 3), (3, 1), (3, 2)]
combinations()
यह फ़ंक्शन इनपुट इटरेबल में एलिमेंट्स के सभी संभावित संयोजन यील्ड करता है। प्रत्येक संयोजन की लंबाई इस फ़ंक्शन के दूसरे पैरामीटर के रूप में निर्दिष्ट की जा सकती है। यदि निर्दिष्ट नहीं है, तो लंबाई एक है।
>>> from itertools import combinations >>> list(combinations(range(1, 4), 2)) [(1, 2), (1, 3), (2, 3)]
यह लेख पायथन लाइब्रेरी के itertools मॉड्यूल में परिभाषित विभिन्न इटरेटर टूल्स का परिचय देता है।
