जनरेटर

जनरेटर Python में एक विशेष प्रकार के इटरेटर होते हैं, जो आपको डेटा पर विलंबित रूप से इटरेट करने देते हैं। सारा डेटा एक साथ लौटाने के बजाय, वे एक-एक आइटम प्रदान करते हैं, जिससे मेमोरी की बचत होती है।

इस पाठ में आप Python में जनरेटर बनाना और उनका उपयोग करना सीखेंगे।

जनरेटर ऐसा फ़ंक्शन है जो yield कीवर्ड का उपयोग करके एक-एक करके मान लौटाता है। जनरेटर की next() विधि का हर आह्वान निष्पादन को उस स्थान से फिर शुरू करता है जहाँ उसने पिछली बार मान लौटाया था।

# Basic generator example
def my_generator():
    yield 1
    yield 2
    yield 3

# Using the generator
gen = my_generator()
print(next(gen))  # Outputs: 1
print(next(gen))  # Outputs: 2
print(next(gen))  # Outputs: 3

जनरेटर फ़ंक्शन की स्थिति सुरक्षित रखते हैं, इसलिए वे निष्पादन को ठीक उसी स्थान से फिर शुरू कर सकते हैं जहाँ उन्होंने उसे छोड़ा था। इससे मेमोरी की बचत होती है और वे बड़े डेटासेट के लिए आदर्श बन जाते हैं।

# Example: Generating a range of numbers
def range_generator(start, end):
    while start < end:
        yield start
        start += 1

for number in range_generator(1, 5):
    print(number)  # Outputs: 1, 2, 3, 4

जनरेटर अभिव्यक्तियाँ सूची कॉम्प्रिहेंशन के समान होती हैं, लेकिन इनमें वर्ग कोष्ठकों के बजाय साधारण कोष्ठकों का उपयोग किया जाता है। ये सूचियों के बजाय जनरेटर बनाती हैं।

# Generator expression
gen_exp = (x * x for x in range(5))

for value in gen_exp:
    print(value)  # Outputs: 0, 1, 4, 9, 16

जनरेटर सूचियों की तुलना में अधिक मेमोरी-कुशल होते हैं, क्योंकि वे सारा डेटा मेमोरी में संग्रहीत नहीं करते। इसके बजाय, वे आवश्यकता के अनुसार डेटा तुरंत उत्पन्न करते हैं।

# Comparing lists and generators
# List comprehension
list_comp = [x * x for x in range(1000000)]

# Generator expression
gen_exp = (x * x for x in range(1000000))

# List comprehension uses more memory
print(type(list_comp))  # Outputs: <class 'list'>
print(type(gen_exp))    # Outputs: <class 'generator'>

जनरेटर इन कार्यों के लिए आदर्श होते हैं:

• ऐसे बड़े डेटासेट को संसाधित करना जो मेमोरी में समा नहीं सकते।
• अनंत अनुक्रम उत्पन्न करना।
• डेटा का विलंबित मूल्यांकन करना।

जनरेटर अनंत अनुक्रम उत्पन्न कर सकते हैं, जैसे संख्याओं का कभी समाप्त न होने वाला अनुक्रम। अनंत निष्पादन को रोकने के लिए लूप को रोकना सुनिश्चित करें।

# Infinite generator example
def infinite_sequence():
    num = 0
    while True:
        yield num
        num += 1

# Using the infinite generator
for i in infinite_sequence():
    if i > 5:
        break
    print(i)  # Outputs: 0, 1, 2, 3, 4, 5

जनरेटर फ़ंक्शन में कई yield कथन हो सकते हैं, जिससे आप जटिल अनुक्रम बना सकते हैं:

# Multiple yields in a generator
def multi_yield():
    yield "First"
    yield "Second"
    yield "Third"

for value in multi_yield():
    print(value)  # Outputs: First, Second, Third

इन गलतियों से बचें:

• जनरेटर फ़ंक्शन में yield के बजाय return का उपयोग करना।
• लूप या next() की सहायता से जनरेटर को संसाधित न करना।
• ऐसे छोटे डेटासेट के लिए जनरेटर का उपयोग करना जहाँ सूचियाँ अधिक उपयुक्त होती हैं।

इस पाठ में आपने सीखा:

• जनरेटर क्या होते हैं और Python में कैसे काम करते हैं।
• जनरेटर फ़ंक्शन बनाने के लिए yield का उपयोग कैसे करें।
• जनरेटर और सूचियों के बीच अंतर।
• जनरेटर के उपयोग के मामले, जैसे अनंत अनुक्रम और बड़े डेटासेट।

बहुत अच्छा! अब अगले विषय पर चलते हैं।