Python Notes
HubHistory of Python - Complete Guide 2026Python Applications - Complete Guide 2026Python Features - Complete Guide 2026What is Python? - Complete Guide 2026Why Learn Python? - Complete Guide 2026Your First Python Program – Hello World & Beyond 2026How to Install Python on Windows, Mac & Linux – Complete Guide 2026Install VS Code for Python – Complete Setup Guide with Extensions 2026Python Environment Setup – Virtual Environments, pip & Project Structure 2026Python IDLE – Complete Guide for Beginners 2026Python CommentsPython Data TypesPython Input and OutputPython OperatorsPython SyntaxPython Strings BasicsPython Type CastingPython VariablesBreak, Continue and Pass in PythonElif Statement in PythonFor Loop in PythonIf-Else Statement in PythonIf Statement in PythonNested If in PythonPattern Programs in PythonWhile Loop in PythonDecorators in PythonFunction Arguments in PythonFunctions Basics in PythonGenerators in PythonLambda Functions in PythonRecursive Functions in PythonReturn Statement in PythonScope of Variables in PythonAbstraction in PythonClasses and Objects in PythonConstructors in PythonEncapsulation in PythonInheritance in PythonMagic Methods (Dunder Methods) in PythonMethod Overriding in PythonPolymorphism in PythonPython Comprehensions – List, Dict, Set & GeneratorPython Dictionaries – Key-Value StorePython Dictionary Methods – Complete ReferencePython List Methods – All Built-in MethodsPython Lists – Complete GuidePython Set Methods – Complete ReferencePython Sets – Unordered Unique CollectionsPython Tuples – Immutable SequencesPython Asynchronous Programming with asyncioPython Context ManagersAdvanced Python DecoratorsAdvanced Python GeneratorsPython Iterators - Advanced GuidePython Memory ManagementPython MultiprocessingPython MultithreadingCRUD Operations in Python DatabasesMySQL with Python (mysql-connector-python)ORM Introduction with SQLAlchemyPostgreSQL with Python (psycopg2)SQLite3 with PythonIntroduction to DjangoDjango Models and ORMDjango REST API with DRFDjango ViewsIntroduction to FlaskFlask RoutingFlask Templates with Jinja2Email Automation with PythonPDF Automation with PythonSelenium Web Automation with PythonTask Scheduler with PythonWeb Scraping with PythonData Analysis with PythonData Cleaning with PythonData Visualization ProjectData Visualization with MatplotlibNumPy IntroductionPandas IntroductionStatistical Visualization with SeabornClassification AlgorithmsClustering AlgorithmsIntroduction to Machine LearningMachine Learning Project: Churn PredictionModel Evaluation and SelectionRegression AlgorithmsSave pipeline (includes preprocessing + model)AI Assistant ProjectCalculator ProjectChatbot ProjectExpense Tracker ProjectFace Detection ProjectPassword Generator ProjectWeather App ProjectPython Coding Interview QuestionsPython OOP Interview Questions and AnswersPython Master CheatsheetPython Interview Questions and AnswersPython Best PracticesCommon Python Errors and SolutionsPython Debugging TechniquesPython Learning Resources
Master Python iterators with __iter__, __next__, custom iterator classes, infinite iterators, and real-world use cases with detailed examples and Hindi explanations.
Introduction
Python iterators are a fundamental concept that unlocks Python's "lazy evaluation" power. Whenever you use a for loop, Python uses the iterator protocol internally. Understanding iterators helps you write memory-efficient and performant code.
An iterator is an object that implements two methods:
__iter__()— returns the iterator object itself__next__()— returns the next value, raisesStopIterationwhen exhausted
An iterable is any object that implements __iter__() (lists, tuples, strings, dicts, sets).
2. Iterable vs Iterator
Example
# Iterable: has __iter__ but not necessarily __next__
my_list = [1, 2, 3]
print(hasattr(my_list, '__iter__')) # True
print(hasattr(my_list, '__next__')) # False — list is iterable, not iterator
# Iterator: has BOTH __iter__ and __next__
my_iter = iter(my_list)
print(hasattr(my_iter, '__iter__')) # True
print(hasattr(my_iter, '__next__')) # True
# Key difference: iterators are consumed; iterables are not
it1 = iter(my_list)
it2 = iter(my_list) # Fresh iterator — independent of it1
print(list(it1)) # [1, 2, 3]
print(list(it1)) # [] — already exhausted!
print(list(it2)) # [1, 2, 3] — fresh iterator
Output
True False True True [1, 2, 3] [] [1, 2, 3]
Example
# Checking if object is iterator or iterable
from collections.abc import Iterator, Iterable
data = [1, 2, 3]
data_iter = iter(data)
print(isinstance(data, Iterable)) # True
print(isinstance(data, Iterator)) # False
print(isinstance(data_iter, Iterable)) # True (iterators are also iterables)
print(isinstance(data_iter, Iterator)) # True
Output
True False True True
3. Custom Iterator Class
python example
# Simple counter iterator
class CountUp:
"""Iterator that counts from 1 to n"""
def __init__(self, start, end):
self.current = start
self.end = end
def __iter__(self):
return self # self return karo
def __next__(self):
if self.current > self.end:
raise StopIteration
value = self.current
self.current += 1
return value
# Usage
counter = CountUp(1, 5)
for num in counter:
print(num, end=" ")
# Output: 1 2 3 4 5
# Can also use next() directly
counter2 = CountUp(10, 12)
print(next(counter2)) # 10
print(next(counter2)) # 11
print(next(counter2)) # 12Output
1 2 3 4 5 10 11 12
📝 Hindi Explanation
To create a Custom Iterator, you need to define both__iter__()and__next__()methods in a class. Returnselfin__iter__(), and in__next__()return the next value or raiseStopIterationwhen done.
4. Iterator with State
Example
class FibonacciIterator:
"""Fibonacci numbers generate karne wala iterator"""
def __init__(self, max_count):
self.max_count = max_count
self.count = 0
self.a = 0
self.b = 1
def __iter__(self):
return self
def __next__(self):
if self.count >= self.max_count:
raise StopIteration
value = self.a
self.a, self.b = self.b, self.a + self.b
self.count += 1
return value
# Print first 10 Fibonacci numbers
fib = FibonacciIterator(10)
print(list(fib))
# Output: [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]
# Using in for loop
for num in FibonacciIterator(8):
print(num, end=" ")
# Output: 0 1 1 2 3 5 8 13 21
Output
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34] 0 1 1 2 3 5 8 13
Example
class EvenNumbers:
"""Iterator that returns only even numbers"""
def __init__(self, limit):
self.current = 0
self.limit = limit
def __iter__(self):
return self
def __next__(self):
self.current += 2
if self.current > self.limit:
raise StopIteration
return self.current
evens = EvenNumbers(10)
print(list(evens))
# Output: [2, 4, 6, 8, 10]
Output
[2, 4, 6, 8, 10]
5. Infinite Iterator
Example
class InfiniteCounter:
"""Kabhi na khatam hone wala counter"""
def __init__(self, start=0, step=1):
self.current = start
self.step = step
def __iter__(self):
return self
def __next__(self):
value = self.current
self.current += self.step
return value
# Infinite iterator — isliye islimitation lagao
counter = InfiniteCounter(start=5, step=3)
# First 5 values lena
import itertools
first_five = list(itertools.islice(counter, 5))
print(first_five)
# Output: [5, 8, 11, 14, 17]
# Using takewhile
counter2 = InfiniteCounter()
import itertools
under_100 = list(itertools.takewhile(lambda x: x < 20, counter2))
print(under_100)
# Output: [0, 1, 2, 3, ..., 19]
Output
[5, 8, 11, 14, 17] [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
📝 Hindi Explanation
An Infinite Iterator is one that never raisesStopIteration. Useitertools.islice()oritertools.takewhile()with such iterators to limit the output, otherwise you'll get an infinite loop.
6. Resettable Iterator
Example
class ResettableRange:
"""A resettable range iterator"""
def __init__(self, start, stop, step=1):
self.start = start
self.stop = stop
self.step = step
self.current = start
def __iter__(self):
return self
def __next__(self):
if self.current >= self.stop:
raise StopIteration
value = self.current
self.current += self.step
return value
def reset(self):
"""Restart the iterator"""
self.current = self.start
return self
r = ResettableRange(0, 5)
print(list(r)) # [0, 1, 2, 3, 4]
print(list(r)) # [] — exhausted
r.reset()
print(list(r)) # [0, 1, 2, 3, 4] — back to start
Output
[0, 1, 2, 3, 4] [] [0, 1, 2, 3, 4]
7. Separating Iterable and Iterator
Example
class NumberRange:
"""Iterable class — multiple times iterate kar sakte ho"""
def __init__(self, start, stop):
self.start = start
self.stop = stop
def __iter__(self):
# Return a fresh iterator every time
return NumberRangeIterator(self.start, self.stop)
class NumberRangeIterator:
"""Actual iterator class"""
def __init__(self, start, stop):
self.current = start
self.stop = stop
def __iter__(self):
return self
def __next__(self):
if self.current >= self.stop:
raise StopIteration
value = self.current
self.current += 1
return value
# You can iterate an Iterable multiple times
nums = NumberRange(1, 4)
print(list(nums)) # [1, 2, 3]
print(list(nums)) # [1, 2, 3] — FRESH iteration!
# Two independent iterators
it1 = iter(nums)
it2 = iter(nums)
print(next(it1)) # 1
print(next(it2)) # 1 — independent!
print(next(it1)) # 2
Output
[1, 2, 3] [1, 2, 3] 1 1 2
📝 Hindi Explanation
Best Practice: Keep Iterable and Iterator separate. If__iter__()returnsself, the object can only be iterated once. If it returns a fresh iterator each time, multiple independent iterations are possible.
8. Built-in Iterator Tools
Example
import itertools
# chain() — multiple iterables ko jodo
a = [1, 2, 3]
b = [4, 5, 6]
chained = list(itertools.chain(a, b))
print(chained)
# Output: [1, 2, 3, 4, 5, 6]
# zip() — parallel iteration
names = ["Alice", "Bob", "Charlie"]
scores = [95, 87, 92]
for name, score in zip(names, scores):
print(f"{name}: {score}")
# Output:
# Alice: 95
# Bob: 87
# Charlie: 92
# enumerate() — iterate with index
fruits = ["apple", "banana", "cherry"]
for i, fruit in enumerate(fruits, start=1):
print(f"{i}. {fruit}")
# Output:
# 1. apple
# 2. banana
# 3. cherry
# map() — function apply karo
numbers = [1, 2, 3, 4, 5]
squared = list(map(lambda x: x**2, numbers))
print(squared)
# Output: [1, 4, 9, 16, 25]
# filter() — filter based on condition
evens = list(filter(lambda x: x % 2 == 0, numbers))
print(evens)
# Output: [2, 4]
Output
[1, 2, 3, 4, 5, 6] Alice: 95 Bob: 87 Charlie: 92 1. apple 2. banana 3. cherry [1, 4, 9, 16, 25] [2, 4]
9. Iterator vs Generator
Example
# Iterator — class-based approach
class SquareIterator:
def __init__(self, n):
self.current = 1
self.n = n
def __iter__(self):
return self
def __next__(self):
if self.current > self.n:
raise StopIteration
result = self.current ** 2
self.current += 1
return result
# Generator — simpler approach
def square_generator(n):
for i in range(1, n + 1):
yield i ** 2
# Same output, generator is much simpler
print(list(SquareIterator(5))) # [1, 4, 9, 16, 25]
print(list(square_generator(5))) # [1, 4, 9, 16, 25]
# Memory comparison
import sys
# Iterator object size
sq_iter = SquareIterator(1000)
print(f"Iterator size: {sys.getsizeof(sq_iter)} bytes")
# Generator object size
sq_gen = square_generator(1000)
print(f"Generator size: {sys.getsizeof(sq_gen)} bytes")
# Both are memory efficient — values generated on demand
Output
[1, 4, 9, 16, 25] [1, 4, 9, 16, 25] Iterator size: 48 bytes Generator size: 104 bytes
10. Real-World: File Line Iterator
python example
class FileLineIterator:
"""Read a large file in a memory-efficient way"""
def __init__(self, filepath, encoding='utf-8'):
self.filepath = filepath
self.encoding = encoding
self._file = None
def __iter__(self):
self._file = open(self.filepath, 'r', encoding=self.encoding)
return self
def __next__(self):
line = self._file.readline()
if line == '':
self._file.close()
raise StopIteration
return line.rstrip('\n')
def __del__(self):
if self._file and not self._file.closed:
self._file.close()
# Usage (assuming data.txt exists)
# for line in FileLineIterator("data.txt"):
# process(line)
#
# Memory efficient: only one line loaded at a time!
# Better: Context manager version
class SafeFileIterator:
def __init__(self, filepath):
self.filepath = filepath
self._file = None
def __enter__(self):
self._file = open(self.filepath, 'r')
return self
def __exit__(self, *args):
if self._file:
self._file.close()
def __iter__(self):
return self
def __next__(self):
line = self._file.readline()
if not line:
raise StopIteration
return line.strip()
# with SafeFileIterator("data.txt") as f:
# for line in f:
# print(line)📝 Hindi Explanation
Real-world use case: When processing large files, loading the entire file into memory is expensive. A custom FileIterator reads only one line at a time, keeping memory usage constant regardless of file size.
11. Chaining Custom Iterators
Example
class MapIterator:
"""Apply function to each element"""
def __init__(self, iterable, func):
self.iterator = iter(iterable)
self.func = func
def __iter__(self):
return self
def __next__(self):
return self.func(next(self.iterator))
class FilterIterator:
"""Filter elements by condition"""
def __init__(self, iterable, predicate):
self.iterator = iter(iterable)
self.predicate = predicate
def __iter__(self):
return self
def __next__(self):
while True:
value = next(self.iterator) # StopIteration propagates naturally
if self.predicate(value):
return value
# Chain them!
numbers = range(1, 11)
result = FilterIterator(
MapIterator(numbers, lambda x: x * 2),
lambda x: x > 10
)
print(list(result))
# Output: [12, 14, 16, 18, 20]
Output
[12, 14, 16, 18, 20]
12. Best Practices
Example
# ✅ Good: Use iter() and next() over calling dunder methods directly
my_iter = iter([1, 2, 3])
value = next(my_iter, "default") # default value when exhausted
print(value) # 1
# ✅ Good: Always provide default for next()
empty_iter = iter([])
print(next(empty_iter, None)) # None — no exception!
# ✅ Good: Use itertools for complex operations
import itertools
# Cycle through colors
colors = itertools.cycle(["red", "green", "blue"])
first_six = [next(colors) for _ in range(6)]
print(first_six)
# Output: ['red', 'green', 'blue', 'red', 'green', 'blue']
# Accumulate running total
numbers = [1, 2, 3, 4, 5]
running_totals = list(itertools.accumulate(numbers))
print(running_totals)
# Output: [1, 3, 6, 10, 15]
# ❌ Bad: Modifying iterable while iterating
# my_list = [1, 2, 3, 4, 5]
# for item in my_list:
# if item % 2 == 0:
# my_list.remove(item) # DANGEROUS!
# ✅ Good: Create a copy or use list comprehension
my_list = [1, 2, 3, 4, 5]
odd_only = [x for x in my_list if x % 2 != 0]
print(odd_only)
# Output: [1, 3, 5]
Output
1 None ['red', 'green', 'blue', 'red', 'green', 'blue'] [1, 3, 6, 10, 15] [1, 3, 5]
13. Common Pitfalls
Example
# Pitfall 1: Iterator is one-way — can't go back
nums = iter([1, 2, 3])
print(list(nums)) # [1, 2, 3]
print(list(nums)) # [] — already exhausted!
# Fix: Store in list or create new iterator
nums = [1, 2, 3]
print(list(iter(nums))) # [1, 2, 3]
print(list(iter(nums))) # [1, 2, 3] — works!
# Pitfall 2: Confusing iterable and iterator
class BadIterator:
def __init__(self, data):
self.data = data
self.index = 0
def __iter__(self):
self.index = 0 # Reset on each iteration — this actually FIXES the issue
return self
def __next__(self):
if self.index >= len(self.data):
raise StopIteration
value = self.data[self.index]
self.index += 1
return value
b = BadIterator([1, 2, 3])
for x in b: pass
for x in b: print(x) # Works because __iter__ resets
# Pitfall 3: Not closing resources in iterators
# Always use try/finally or context managers
class SafeIterator:
def __init__(self):
self.resource = None
def __iter__(self):
return self
def __next__(self):
try:
pass # get next value
except Exception:
if self.resource:
self.resource.close() # cleanup on error
raise
Summary
| Concept | Key Point |
|---|---|
| Iterable | Has __iter__(), returns iterator |
| Iterator | Has __iter__() + __next__() |
| StopIteration | Signals end of iteration |
| iter() | Gets iterator from iterable |
| next() | Gets next value from iterator |
| Infinite Iterator | Never raises StopIteration |
| Lazy Evaluation | Values computed on demand |
When to Use Iterators vs Generators?
- Iterators: When you need complex state management, multiple methods, or class hierarchy
- Generators: When logic is simple and sequential — much less code
Example
# Quick Reference
class MyIterator:
def __init__(self, data):
self.data = data
self.index = 0
def __iter__(self):
return self
def __next__(self):
if self.index >= len(self.data):
raise StopIteration
item = self.data[self.index]
self.index += 1
return item
# Always test both consumption methods
it = MyIterator([10, 20, 30])
print(next(it)) # 10
print(list(it)) # [20, 30]
Output
10 [20, 30]
Remember: Every generator is an iterator, but not every iterator is a generator. Generators are the Pythonic way to create iterators!
⚠️ Common Mistakes
❌ Mistake 1: Using an iterator multiple times without reset
Example
numbers = iter([1, 2, 3, 4, 5])
print(sum(numbers)) # 15
print(sum(numbers)) # 0 — already exhausted! ⚠️
Output
15 0
Fix: Create a new iterator or store values in a list first. A consumed iterator won't produce values again.
❌ Mistake 2: Not returning self in __iter__()
Example
class BrokenIterator:
def __init__(self, data):
self.data = data
self.index = 0
def __next__(self):
if self.index >= len(self.data):
raise StopIteration
val = self.data[self.index]
self.index += 1
return val
# ❌ Won't work in a for loop!
# for item in BrokenIterator([1, 2, 3]):
# print(item) # TypeError: 'BrokenIterator' object is not iterable
Fix: Always define__iter__()to returnself. Without__iter__(), the object won't be considered iterable.
❌ Mistake 3: StopIteration raise karna bhoolna
Example
class ForeverBug:
def __init__(self, data):
self.data = data
self.index = 0
def __iter__(self):
return self
def __next__(self):
# ❌ No StopIteration — infinite loop ho jayega!
val = self.data[self.index % len(self.data)]
self.index += 1
return val
# list(ForeverBug([1,2,3])) # ❌ Never ends! Memory crash!
Fix: Always include a termination condition and raise StopIteration when the data is exhausted.❌ Mistake 4: Sharing mutable state inside an Iterator
Example
class SharedStateIterator:
shared_index = 0 # ❌ Class variable — sab instances share karenge!
def __init__(self, data):
self.data = data
def __iter__(self):
return self
def __next__(self):
if SharedStateIterator.shared_index >= len(self.data):
raise StopIteration
val = self.data[SharedStateIterator.shared_index]
SharedStateIterator.shared_index += 1
return val
Fix: Use instance variables (self.index), not class variables. Otherwise multiple iterators will interfere with each other.❌ Mistake 5: next() without default on empty iterator
python example
empty = iter([])
# ❌ Yeh crash karega!
# value = next(empty) # StopIteration exception!
# ✅ Default value do
value = next(empty, "No data")
print(value)Output
No data
Fix: Usenext(iterator, default)when you're not sure if data exists. This safely returnsNoneor a default value.
❌ Mistake 6: File iterator mein resource cleanup bhoolna
python example
class LeakyFileIterator:
def __init__(self, path):
self.file = open(path, 'r') # ❌ File kabhi close nahi hogi!
def __iter__(self):
return self
def __next__(self):
line = self.file.readline()
if not line:
raise StopIteration # ❌ File still open!
return line.strip()Fix: Callself.file.close()before raisingStopIteration, or implement a context manager (__enter__/__exit__).
❌ Mistake 7: Iterable modify karna while iterating
Example
data = [1, 2, 3, 4, 5]
# ❌ Unexpected behavior!
for item in data:
if item % 2 == 0:
data.remove(item)
print(data) # [1, 3, 5] — luckily works here but unreliable!
Output
[1, 3, 5]
Fix: Iterate over a copy using a list comprehension: for item in data[:]:✅ Key Takeaways
- 🔑 Iterator Protocol =
__iter__()+__next__()— these two methods make any object an iterator - 🔑 Iterable ≠ Iterator — A List is an iterable (can be iterated repeatedly), but a list_iterator is an iterator (consumed after one pass)
- 🔑 Lazy Evaluation — Iterators are memory efficient because values are generated on-demand, not all loaded into memory at once
- 🔑 StopIteration — This exception signals the end of iteration;
forloop catches it automatically - 🔑
next(iterator, default)— Providing a default value is safe practice to avoid exceptions - 🔑 Separate Iterable & Iterator — In production code, keep iterable and iterator classes separate so multiple independent iterations are possible
- 🔑 Infinite Iterators — Use with
itertools.islice()ortakewhile(), otherwise you'll get an infinite loop - 🔑 Generator > Iterator — For simple cases, use generator functions (less code, same performance); for complex state management, use class-based iterators
- 🔑 Resource Cleanup — Always include cleanup logic in file/network iterators (
try/finally, context managers) - 🔑 Built-in Tools — The
itertoolsmodule has powerful iterator utilities:chain(),cycle(),islice(),accumulate(),takewhile()
❓ FAQ
Q1: What is the difference between an Iterator and an Iterable?
Answer: An Iterable is an object with an __iter__() method (list, tuple, string, dict). An Iterator is an object with both __iter__() AND __next__() methods. Every Iterator is an Iterable, but not every Iterable is an Iterator.
Q2: How do you reuse an iterator once it's exhausted?
Answer: An exhausted iterator won't produce values again. Options are: (1) Create a new iterator with iter(iterable), (2) Keep Iterable and Iterator classes separate so __iter__() always returns a fresh iterator, (3) Convert to a list first if multiple passes are needed.
Q3: How does a for loop work internally?
Answer: for item in iterable: internally does this: first calls iter(iterable) to get an iterator, then repeatedly calls next(iterator) until StopIteration is raised. The StopIteration is caught automatically and the loop ends.
Q4: When should you use a Generator vs a class-based Iterator?
Answer: Use a Generator when the logic is simple and sequential — the yield keyword gets the job done with very little code. Use a class-based Iterator when you need complex state management, multiple public methods, or reset/rewind capability.
Q5: Are iterators thread-safe?
Answer: No, by default Python iterators are not thread-safe. If multiple threads call next() on the same iterator, race conditions can occur. For thread safety, wrap with threading.Lock() or use queue.Queue.
Q6: itertools.chain() vs + operator — what's the difference?
Answer: The + operator (like list1 + list2) creates a new list in memory. itertools.chain(list1, list2) returns a lazy iterator that yields items from both without copying. Chain is far more memory efficient for large data.
Q7: How do you safely use infinite iterators?
Answer: Always use a limiting mechanism with infinite iterators: itertools.islice(iterator, n) to take the first n items, itertools.takewhile(condition, iterator) to take while a condition is true, or a manual break in the loop.
Q8: When should you use the Iterator pattern in real projects?
Answer: (1) When processing large files line-by-line, (2) When fetching database results in batches, (3) When handling network streams/API pagination, (4) When generating infinite sequences (IDs, timestamps).
🎯 Interview Questions
Q1: What is the Iterator Protocol in Python? Explain with an example.
Answer: The Iterator Protocol is a Python convention requiring two methods: __iter__() which returns the iterator object, and __next__() which returns the next value or raises StopIteration. Any object implementing both is an iterator.
Q2: What is the fundamental difference between an Iterable and an Iterator? Explain with code.
Answer: An Iterable only has __iter__() (e.g., list, dict) — it can be iterated repeatedly because a fresh iterator is returned each time. An Iterator has both __iter__() and __next__() — it maintains position state and is consumed after one pass.
Q3: Create a custom iterator class that generates prime numbers up to n.
Answer: Store the limit in __init__, return self in __iter__, and in __next__ find and return the next prime. Use trial division for prime checking, and raise StopIteration when the limit is exceeded.
Q4: What are the two forms of the iter() function?
Answer: (1) iter(iterable) — creates an iterator from an iterable by calling __iter__(). (2) iter(callable, sentinel) — repeatedly calls the callable and yields results until the sentinel value is returned (then raises StopIteration).
Q5: When is it necessary to manually handle the StopIteration exception?
Answer: When you call next() directly (outside a for loop), you must handle StopIteration. The for loop handles it automatically. Best practice: use next(iter, default) to avoid exception handling altogether.
Q6: How does the Iterator pattern achieve memory efficiency? Compare with a List.
Answer: A List stores all elements in memory at once — 1 million items = 1 million objects in RAM. An Iterator uses lazy evaluation — only one value exists in memory at a time. For 1 million items: List ≈ 8MB, Iterator ≈ 120 bytes.
Q7: What are the drawbacks of keeping Iterable and Iterator in the same class?
Answer: If __iter__() returns self, the object can only be iterated once. Multiple for loops on the same object won't give expected results because the iterator's state is shared. Solution: Return a new iterator instance from __iter__().
Q8: Name 5 important functions from the itertools module and their use cases.
Answer: (1) chain(*iterables) — concatenate multiple iterables without memory copy. (2) islice(iter, start, stop) — slice from an iterator (works with infinite iterators). (3) cycle(iterable) — repeat infinitely. (4) accumulate(iter, func) — running totals. (5) takewhile(pred, iter) — take while predicate is true.
Q9: Can the __iter__ method in Python also be a generator function? Explain.
Answer: Yes! You can use yield inside the __iter__() method, which makes it automatically return a generator. This approach eliminates the need to write __next__ separately and keeps the code concise.
Q10: Real-world scenario: Database cursor as iterator — kaise implement karoge?
Answer: A database cursor uses the iterator pattern — fetchone() returns one row (like __next__), and when rows are exhausted, it returns None or raises an exception. This prevents loading millions of rows into memory at once.
Exam Focus
Revise definitions, diagrams, examples, and short-answer points for Python Iterators - Advanced Guide.
Interview Use
Prepare one clear explanation, one practical example, and one common mistake for this Python Master Course topic.
Search Terms
python-master-course, python master course, python, master, course, advanced, iterators, python iterators - advanced guide
Related Python Master Course Topics
Continue learning this concept
Advanced PythonPython Asynchronous Programming with asyncioDeep dive into Python async/await, asyncio event loop, coroutines, tasks, async generators, aiohttp, and real-world asynchronous patterns with Hindi explanations.Advanced PythonPython Context ManagersComprehensive guide to Python context managers using with statement, __enter__ and __exit__ methods, contextlib module, nested context managers and custom resource management.Advanced PythonAdvanced Python DecoratorsMaster advanced Python decorators including decorator factories, class decorators, stacking decorators, functools.wraps, parameterized decorators, and real-world patterns.Advanced PythonAdvanced Python GeneratorsDeep dive into Python generators, yield keyword, generator expressions, send(), throw(), close() methods, pipelines, and coroutines with Hindi explanations.Advanced PythonPython Memory ManagementComprehensive guide to Python memory management, reference counting, garbage collection, memory profiling, optimization techniques, and best practices with Hindi explanations.Advanced PythonPython MultiprocessingMaster Python multiprocessing with Process class, Pool, shared memory, inter-process communication, pipes, queues, and comparison with multithreading.