Introduction to Generators

Generators are a special type of iterator in Python that allow you to iterate over data lazily. Instead of returning all the data at once, they yield one item at a time, making them memory-efficient.

In this lesson, you’ll learn how to create and use generators in Python.

What Is a Generator?

A generator is a function that uses the yield keyword to return values one at a time. Each call to the generator’s next() method resumes execution from where it last yielded.

# 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

How Generators Work

Generators save the state of the function, so they can resume execution exactly where they left off. This makes them memory-efficient and ideal for large datasets.

# 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 Expressions

Generator expressions are similar to list comprehensions but use parentheses instead of square brackets. They create generators instead of lists.

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

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

Generators vs. Lists

Generators are more memory-efficient than lists because they don’t store all the data in memory. Instead, they generate data on the fly.

# 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'>

Use Cases for Generators

Generators are ideal for:

• Processing large datasets that don’t fit into memory.
• Generating infinite sequences.
• Lazy evaluation of data.

Infinite Generators

Generators can produce infinite sequences, such as an endless sequence of numbers. Make sure to stop the loop to prevent infinite execution.

# 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

Generator Functions with Multiple Yields

Generator functions can have multiple yield statements, allowing you to create complex sequences:

# 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

Common Mistakes with Generators

Here are some mistakes to avoid:

• Using return instead of yield in a generator function.
• Not consuming the generator with a loop or next().
• Using generators for small datasets where lists are more appropriate.

What Did We Learn?

In this lesson, you learned:

• What generators are and how they work in Python.
• How to use yield to create generator functions.
• The differences between generators and lists.
• Use cases for generators, such as infinite sequences and large datasets.

Great job! Let’s move to the next topic.