जेनरेटर के उपयोग के साथ और उसके बिना मेमोरी उपयोग की कल्पना करने से दक्षता लाभों को समझने में मदद मिल सकती है। नीचे दो परिदृश्यों में मेमोरी उपयोग की तुलना की गई है:

1. जेनरेटर का उपयोग किए बिना (सभी डेटा को एक ही बार में मेमोरी में लोड करना)।
2. जेनरेटर का उपयोग करना (एक समय में एक आइटम लोड करना)।

परिदृश्य 1: जेनरेटर के बिना

मान लें कि हमारे पास एक साधारण फ़ंक्शन है जो 0 से 999,999 तक संख्याओं की एक श्रृंखला लौटाता है। यह फ़ंक्शन सभी डेटा को एक ही बार में मेमोरी में लोड करता है।

मेमोरी उपयोग (जनरेटर के बिना)

जब फ़ंक्शन getNumbersArray को कॉल किया जाता है:

• प्रारंभिक मेमोरी: कम, केवल फ़ंक्शन और पर्यावरण सेटअप मेमोरी में हैं।
• निष्पादन के दौरान: जैसे-जैसे लूप चलता है, मेमोरी का उपयोग रैखिक रूप से बढ़ता है, सभी 1,000,000 नंबरों को एक सरणी में रखता है।
• पीक मेमोरी: बहुत ऊंची, मेमोरी में सभी डेटा को एक साथ रखती है।
• निष्पादन के बाद: स्क्रिप्ट समाप्त होने तक या सरणी स्पष्ट रूप से अनसेट होने तक मेमोरी उच्च बनी रहती है।

|            Memory Usage Without Generators           |
|------------------------------------------------------|
| Start    | *                                         |
|          | **                                        |
|          | ***                                       |
|          | ****                                      |
|          | *****                                     |
|          | ******                                    |
|          | *******                                   |
| ...      | ******************************************|
| End      | ******************************************|
|------------------------------------------------------|

परिदृश्य 2: जेनरेटर का उपयोग करना

अब, हम एक समय में एक नंबर प्राप्त करने के लिए जनरेटर फ़ंक्शन का उपयोग करते हैं।

मेमोरी उपयोग (जेनरेटर का उपयोग करना)

जब जेनरेटर फ़ंक्शन नंबर जेनरेटर को कॉल किया जाता है:

• प्रारंभिक मेमोरी: कम, केवल फ़ंक्शन और पर्यावरण सेटअप मेमोरी में हैं।
• निष्पादन के दौरान: मेमोरी का उपयोग कम रहता है क्योंकि एक समय में मेमोरी में केवल एक ही नंबर रखा जाता है।
• पीक मेमोरी: कम, जनरेटर के लिए केवल एक आइटम प्लस ओवरहेड।
• निष्पादन के बाद: पुनरावृत्ति समाप्त होने के तुरंत बाद मेमोरी उपयोग कम हो जाता है।

|            Memory Usage With Generators              |
|------------------------------------------------------|
| Start    | *                                         |
|          | *                                         |
|          | *                                         |
|          | *                                         |
|          | *                                         |
|          | *                                         |
|          | *                                         |
| ...      | *                                         |
| End      | *                                         |
|------------------------------------------------------|

सारांश

• जेनरेटर के बिना: मेमोरी का उपयोग डेटासेट के आकार के साथ बढ़ता है और स्क्रिप्ट निष्पादन के दौरान उच्च रहता है।
• जेनरेटर के साथ: डेटासेट आकार की परवाह किए बिना मेमोरी उपयोग स्थिर और कम रहता है, क्योंकि एक समय में केवल एक आइटम संसाधित होता है।

जेनरेटर एक समय में एक आइटम प्रदान करके और स्क्रिप्ट के निष्पादन के दौरान कम मेमोरी उपयोग को बनाए रखते हुए, विशेष रूप से बड़े डेटासेट के लिए महत्वपूर्ण मेमोरी दक्षता लाभ प्रदान करते हैं।