Python Iterators and Generators — Understanding yield, Lazy Evaluation, and Memory-Efficient Loops

The Story That Explains Iterators & Generators 📺Iterators और Generators समझाने वाली कहानी 📺一个讲清迭代器与生成器的故事 📺

In Python, iterables, iterators and generators are three closely related ideas that beginners often mix up. All three let you loop through data — but the way they store, compute and hand out values is very different. Master them and you can handle huge files as easily as a handful of rows.

Python में iterables, iterators और generators तीन जुड़े हुए विचार हैं जिन्हें beginners अक्सर मिला देते हैं। तीनों से आप data पर loop चला सकते हैं — पर values रखने, निकालने और देने का उनका तरीक़ा बहुत अलग है। इन्हें समझ लीजिए तो आप बहुत बड़ी files भी कुछ rows जितनी आसानी से सँभाल लेंगे।

在 Python 中，可迭代对象、迭代器 和 生成器 是三个密切相关、初学者常常混淆的概念。它们都能让你遍历数据 — 但存储、计算和交出值的方式大不相同。掌握它们，你处理巨大的文件就会像处理几行数据一样轻松。

Containers & Iterables — The Foundation 🧱Containers और Iterables — नींव 🧱容器与可迭代对象 — 基础 🧱

A container is any object that holds a collection of values — list, tuple, dict, set and str are the most common. An iterable is any object that has an __iter__ method, which means Python knows how to get an iterator from it.

Container ऐसा object है जो values का संग्रह रखता है — list, tuple, dict, set और str सबसे आम हैं। Iterable ऐसा object है जिसमें __iter__ method हो, यानी Python उससे iterator निकालना जानता है।

容器 是任何保存一组值的对象 — 最常见的是 list、tuple、dict、set 和 str。可迭代对象 是任何有 __iter__ 方法的对象，也就是说 Python 知道如何从它得到一个迭代器。

# A list is iterable - but is NOT an iterator
list1 = [10, 20, 30]

print(hasattr(list1, '__iter__'))   # True  - it IS iterable
print(hasattr(list1, '__next__'))   # False - it is NOT an iterator

# This FAILS:
try:
    next(list1)
except TypeError as e:
    print("TypeError:", e)

# This WORKS - first get an iterator using iter()
it = iter(list1)
print(next(it))    # 10
print(next(it))    # 20
print(next(it))    # 30
try:
    next(it)
except StopIteration:
    print("StopIteration - nothing left")

Iterators — The Stateful Cursor 👆Iterators — याद रखने वाला Cursor 👆迭代器 — 有状态的游标 👆

An iterator is an object that remembers where it is in the sequence. It has two methods: __iter__ (which returns itself) and __next__ (which returns the next value, or raises StopIteration when there is nothing left).

Iterator ऐसा object है जो याद रखता है कि sequence में वह कहाँ है। इसमें दो methods होते हैं: __iter__ (जो ख़ुद को लौटाता है) और __next__ (जो अगली value लौटाता है, या कुछ न बचे तो StopIteration raise करता है)।

迭代器 是一个记得自己在序列中 处于何处 的对象。它有两个方法：__iter__（返回自身）和 __next__（返回下一个值，没有值时抛出 StopIteration）。

nums = [1, 2, 3]
it = iter(nums)

print(iter(it) is it)       # True  - an iterator's __iter__ returns itself
print(iter(nums) is nums)   # False - a list gives a NEW iterator each time

print(list(it))             # [1, 2, 3]  - uses up the iterator
print(list(it))             # []         - already exhausted
print(list(nums))           # [1, 2, 3]  - the list itself is untouched

🧪 Simulator: iter() / next() Lab🧪 Simulator: iter() / next() Lab🧪 模拟器：iter() / next() 实验室

Pick an object, then run lines in any order. Watch the cursor move. With a list or a string, iter() makes a new cursor every time; with an iterator, obj and it share one cursor. Checked against Python on 400 random sequences.

एक object चुनिए, फिर lines किसी भी क्रम में चलाइए। Cursor को चलते देखिए। List या string के साथ iter() हर बार नया cursor बनाता है; iterator के साथ obj और it एक ही cursor share करते हैं। 400 random sequences पर Python से जाँचा गया।

选一个对象，然后按任意顺序运行代码。观察游标的移动。对列表或字符串，iter() 每次都创建新游标；对迭代器，obj 和 it 共用同一个游标。已在 400 个随机序列上与 Python 对照。

Building a Custom Iterator — MyRange 🛠️Custom Iterator बनाना — MyRange 🛠️自己写一个迭代器 — MyRange 🛠️

Let's build our own iterator that works like Python 2's xrange() — producing numbers one at a time, without ever holding the full list in memory.

चलिए अपना iterator बनाते हैं जो Python 2 के xrange() जैसा काम करे — एक-एक करके नंबर दे, पूरी list कभी memory में रखे बिना।

我们来写一个自己的迭代器，让它像 Python 2 的 xrange() 一样工作 — 一次产生一个数字，从不把整个列表放进内存。

class MyRange:
    """A minimal version of Python 2's xrange as a class-based iterator."""

    def __init__(self, start, end):
        self.value = start
        self.end   = end

    def __iter__(self):
        return self            # iterators return themselves

    def __next__(self):
        if self.value >= self.end:
            raise StopIteration
        current = self.value
        self.value += 1
        return current


# Use it exactly like the built-in range
r = MyRange(1, 5)
for num in r:
    print(num, end=' ')

That is about 15 lines of code for a lazy sequence. Powerful — but long. Python has a much shorter route to the same behaviour: the yield keyword.

Lazy sequence के लिए लगभग 15 lines का code। ताक़तवर — पर लंबा। Python में यही व्यवहार पाने का बहुत छोटा रास्ता है: yield keyword।

一个惰性序列大约要 15 行代码。很强大 — 但太长了。Python 有一条短得多的路能得到同样的效果：yield 关键字。

Enter Generators — Iterators With Superpowers ⚡Generators — ख़ास ताक़त वाले Iterators ⚡生成器登场 — 拥有超能力的迭代器 ⚡

A generator is a special kind of iterator built from a function that contains at least one yield. As soon as Python sees yield anywhere in a function body, that function becomes a generator function — calling it does not run the code; it just returns a generator object.

Generator एक ख़ास तरह का iterator है जो ऐसे function से बनता है जिसमें कम से कम एक yield हो। Python जैसे ही function body में कहीं yield देखता है, वह function generator function बन जाता है — उसे बुलाने पर code नहीं चलता; बस एक generator object मिलता है।

生成器 是一种特殊的迭代器，由至少包含一个 yield 的函数构建。只要 Python 在函数体中任何地方看到 yield，这个函数就成为 生成器函数 — 调用它不会执行代码，只会返回一个生成器对象。

def my_range(start, end):
    """A generator version of MyRange - 4 lines instead of 15."""
    while start < end:
        yield start
        start += 1


# Calling the function does NOT run the body
gen = my_range(1, 5)
print(gen)

# Values are produced only on demand
for num in gen:
    print(num, end=' ')

How yield Actually Works — Step by Step ⏯️yield असल में कैसे काम करता है — क़दम-दर-क़दम ⏯️yield 究竟如何工作 — 逐步拆解 ⏯️

👣 Simulator: Generator Step by Step👣 Simulator: Generator क़दम-दर-क़दम👣 模拟器：生成器逐步演示

Recorded with sys.settrace. Watch the my_range frame appear on the call stack at each next(), then disappear at yield — while its locals stay safe in the frozen box.

sys.settrace से रिकॉर्ड किया हुआ। हर next() पर my_range का frame call stack पर आता है, फिर yield पर हट जाता है — जबकि उसके locals frozen डिब्बे में सुरक्षित रहते हैं।

用 sys.settrace 录制。观察 my_range 的帧在每次 next() 时出现在调用栈上，又在 yield 时消失 — 而它的局部变量安全地保存在 冻结 框里。

Generator Expressions — Comprehensions With Parentheses 🫧Generator Expressions — Parentheses वाली Comprehensions 🫧生成器表达式 — 带圆括号的推导式 🫧

Just as list comprehensions give you short list creation, generator expressions give you short generator creation. The syntax is the same, except you use parentheses () instead of square brackets [].

जैसे list comprehensions से छोटे में list बनती है, वैसे generator expressions से छोटे में generator बनता है। Syntax वही है, बस square brackets [] की जगह parentheses () लगते हैं।

就像列表推导式能简洁地创建列表，生成器表达式 能简洁地创建生成器。语法完全相同，只是把 方括号 [] 换成 圆括号 ()。

# List comprehension - builds the whole list in memory
squares_list = [x * x for x in range(10)]
print(squares_list)

# Generator expression - builds a generator (nothing computed yet)
squares_gen = (x * x for x in range(10))
print(squares_gen)

# Use the values on demand
for sq in squares_gen:
    print(sq, end=' ')

🐢🐇 Simulator: Lazy vs Eager🐢🐇 Simulator: Lazy बनाम Eager🐢🐇 模拟器：惰性 vs 立即

Both columns square the numbers with a function sq(x) that announces each computation. The list computes everything first; the generator computes only what the consumer asks for. Change n and the consumer, then press Play. The event order comes from real Python runs.

दोनों columns numbers का square sq(x) function से करते हैं जो हर गणना बताता है। List पहले सब कुछ निकालती है; generator सिर्फ़ उतना निकालता है जितना consumer माँगे। n और consumer बदलिए, फिर Play दबाइए। Events का क्रम असली Python runs से है।

两列都用一个会报告每次计算的函数 sq(x) 来求平方。列表先把 所有 值都算出来；生成器只计算消费者要求的那些。修改 n 和消费者，然后按 Play。事件顺序来自真实的 Python 运行。

Memory & Performance — The Real Difference 📊Memory और Performance — असली फ़र्क़ 📊内存与性能 — 真正的差别 📊

This is where generators earn their keep. Let's measure the memory of a list comprehension and a generator expression doing the same work for 10 million items.

यहीं generators की असली क़ीमत दिखती है। चलिए 10 million items पर एक ही काम करने वाली list comprehension और generator expression की memory नापें।

生成器的价值正体现在这里。我们来测量一下：对 1000 万个元素做同样计算时，列表推导式和生成器表达式各占多少内存。

import sys

# List comprehension - stores everything
lst = [x * 2 for x in range(10_000_000)]
print(f"List memory:      {sys.getsizeof(lst):,} bytes")

# Generator expression - stores almost nothing
gen = (x * 2 for x in range(10_000_000))
print(f"Generator memory: {sys.getsizeof(gen):,} bytes")

Speed Comparison — Summing 10 Million NumbersSpeed की तुलना — 10 Million Numbers का जोड़速度对比 — 对 1000 万个数求和

import time

# List comprehension - build then sum
t = time.perf_counter()
total = sum([x for x in range(10_000_000)])
print(f"List:      {time.perf_counter() - t:.2f}s")

# Generator expression - stream directly into sum
t = time.perf_counter()
total = sum(x for x in range(10_000_000))
print(f"Generator: {time.perf_counter() - t:.2f}s")

Practical Example 1 — Fibonacci Forever ♾️Practical Example 1 — अंतहीन Fibonacci ♾️实战示例 1 — 无穷的斐波那契 ♾️

A classic use of generators: an infinite sequence. A list of infinite Fibonacci numbers is impossible — a generator is not.

Generators का क्लासिक इस्तेमाल: अंतहीन sequence। अंतहीन Fibonacci numbers की list असंभव है — generator नहीं।

生成器的经典用法：无穷序列。无穷斐波那契数的列表是不可能的 — 生成器却可以。

def fibonacci():
    """An infinite Fibonacci generator."""
    a, b = 0, 1
    while True:
        yield a
        a, b = b, a + b


# Take the first 10 Fibonacci numbers
fib = fibonacci()
for _ in range(10):
    print(next(fib), end=' ')

Combined With itertools.isliceitertools.islice के साथ结合 itertools.islice

from itertools import islice

def fibonacci():
    a, b = 0, 1
    while True:
        yield a
        a, b = b, a + b

# Take Fibonacci numbers 20 through 29 without building a big list
first_ten_from_20 = list(islice(fibonacci(), 20, 30))
print(first_ten_from_20)

Practical Example 2 — Reading a Huge File 📜Practical Example 2 — बहुत बड़ी File पढ़ना 📜实战示例 2 — 读取超大文件 📜

Suppose you must scan a 20 GB server log for the word "ERROR". Loading it with file.readlines() would fill your RAM. A generator handles it with only one line in memory at a time. Here it runs on a small sample file, app.log, so you can see real output:

मान लीजिए आपको 20 GB server log में "ERROR" खोजना है। file.readlines() से load करने पर RAM भर जाएगी। Generator एक बार में memory में सिर्फ़ एक line रखकर इसे सँभाल लेता है। असली output दिखाने के लिए यहाँ यह एक छोटी sample file app.log पर चलता है:

假设你要在 20 GB 的服务器日志里查找 "ERROR"。用 file.readlines() 加载会撑爆内存。生成器一次只在内存里保留一行就能搞定。为了展示真实输出，这里在一个小样本文件 app.log 上运行：

def grep_errors(path):
    """Yield every line in a log file that contains 'ERROR'."""
    with open(path) as f:
        for line in f:          # file objects are iterators too!
            if 'ERROR' in line:
                yield line.rstrip()


# Streams line by line - only one line in memory at a time
errors = grep_errors('app.log')

# Print the first 5 error lines
for line, _ in zip(errors, range(5)):
    print(line)

Advanced — send(), close() and yield from 🎛️Advanced — send(), close() और yield from 🎛️进阶 — send()、close() 与 yield from 🎛️

Generators can do more than produce values. They can also receive them.

Generators सिर्फ़ values बनाते ही नहीं। वे values ले भी सकते हैं।

生成器不仅能产生值，还能 接收 值。

def echo():
    """A generator that echoes whatever you send into it."""
    while True:
        received = yield
        print(f"Got: {received}")


e = echo()
next(e)              # prime the generator (run to the first yield)
e.send('hello')      # Got: hello
e.send(42)           # Got: 42
e.close()            # stops the generator cleanly


# yield from - hand over to a sub-generator
def countdown(n):
    while n > 0:
        yield n
        n -= 1

def combined():
    yield from countdown(3)
    yield from ['go!', 'done']

print(list(combined()))

🎛️ Simulator: send() Lab🎛️ Simulator: send() Lab🎛️ 模拟器：send() 实验室

Drive the echo() generator yourself. Try send() before priming, prime it with next(), send values, then close it and try again. Checked against Python on 300 random sequences.

echo() generator को ख़ुद चलाइए। Prime करने से पहले send() आज़माइए, next() से prime कीजिए, values भेजिए, फिर close करके दोबारा कोशिश कीजिए। 300 random sequences पर Python से जाँचा गया।

亲手驱动 echo() 生成器。先试试在预激之前 send()，再用 next() 预激，发送一些值，然后关闭它再试一次。已在 300 个随机序列上与 Python 对照。

The Three Ideas Side by Side 🎯तीनों विचार साथ-साथ 🎯三个概念并排比较 🎯

Common Pitfalls (and Good Habits) 🩹आम ग़लतियाँ (और अच्छी आदतें) 🩹常见陷阱（与好习惯）🩹

🩺 Simulator: Bug Doctor🩺 Simulator: Bug Doctor🩺 模拟器：Bug 医生

Five real mistakes with iterators and generators. Buggy code on the left, fixed code on the right, changed lines marked.

Iterators और generators की पाँच असली ग़लतियाँ। बाईं ओर buggy code, दाईं ओर ठीक किया हुआ, बदली lines चिह्नित।

五个与迭代器和生成器有关的真实错误。左边是有 bug 的代码，右边是修正后的代码，改动的行已标出。

Real-World Case Study — Streaming CSV Totals 🌍Real-World Case Study — Streaming CSV Totals 🌍真实案例 — 流式 CSV 汇总 🌍

Suppose you have a 5 GB sales CSV with 200 million rows, and you need total revenue per country. Loading it all at once would exhaust your RAM. A generator pipeline handles it with one row in flight at a time. Here the same code runs on a small sample, sales_2026.csv:

मान लीजिए आपके पास 200 million rows वाली 5 GB sales CSV है, और आपको हर देश की कुल कमाई चाहिए। सब एक साथ load करने पर RAM ख़त्म हो जाएगी। Generator pipeline एक बार में एक row चलाकर इसे सँभाल लेती है। यहाँ वही code एक छोटे sample sales_2026.csv पर चलता है:

假设你有一个 5 GB、2 亿行的销售 CSV，需要按国家汇总收入。一次性全部加载会耗尽内存。生成器流水线一次只处理一行就能搞定。这里同样的代码在一个小样本 sales_2026.csv 上运行：

import csv
from collections import defaultdict

def read_rows(path):
    """Stage 1 - yield each row as a dict, one at a time."""
    with open(path, newline='') as f:
        yield from csv.DictReader(f)

def only_2026(rows):
    """Stage 2 - keep 2026 sales only."""
    for row in rows:
        if row['date'].startswith('2026'):
            yield row

def parse_amount(rows):
    """Stage 3 - turn the amount text into a number."""
    for row in rows:
        row['amount'] = float(row['amount'])
        yield row

# Build the pipeline - nothing runs yet
pipeline = parse_amount(only_2026(read_rows('sales_2026.csv')))

# Only NOW do rows flow through - one at a time
totals = defaultdict(float)
for row in pipeline:
    totals[row['country']] += row['amount']

for country, revenue in sorted(totals.items(), key=lambda x: -x[1])[:5]:
    print(f"{country:20s} ${revenue:,.2f}")

🚰 Simulator: Pipeline Flow🚰 Simulator: Pipeline Flow🚰 模拟器：流水线演示

Pull one row at a time through the three generator stages into totals. 2025 rows are dropped at only_2026() and never reach parse_amount(). Only one row is ever in flight.

तीन generator stages से totals तक एक-एक row खींचिए। 2025 वाली rows only_2026() पर रुक जाती हैं और parse_amount() तक कभी नहीं पहुँचतीं। एक समय में सिर्फ़ एक row चलती है।

一次拉一行，让它经过三个生成器阶段进入 totals。2025 年的行会在 only_2026() 被丢弃，永远到不了 parse_amount()。任何时候都只有一行在流动。

Golden Rules and Quiz 🏆सुनहरे नियम और Quiz 🏆黄金法则与小测验 🏆

Quick Quiz — 8 Questionsछोटा Quiz — 8 सवाल小测验 — 8 道题