What is the difference between a normal function and a generator function in Python?

Question

Jayant Kumar · Accepted Answer

Table of Contents
Introduction
In Python, functions are fundamental building blocks, but there are distinct types: normal functions and generator functions. Both serve to encapsulate code and return values, but they operate differently and are suited for different use cases. This guide explores the differences between normal functions and generator functions, highlighting their behavior, usage, and benefits.
Key Differences Between Normal Functions and Generator Functions
1. Return Behavior

Normal Function: A normal function uses the return statement to send a value back to the caller and terminate its execution. Once a value is returned, the function’s state is lost, and it cannot be resumed.
Generator Function: A generator function uses the yield statement to produce a series of values. Instead of terminating, it pauses and saves its state, allowing it to resume execution and continue yielding values from where it left off.

Example of a Normal Function:
def normal_function():
    return 1

result = normal_function()
print(result)  # Output: 1

In this example, normal_function() returns the value 1 and terminates.
Example of a Generator Function:
def generator_function():
    yield 1
    yield 2
    yield 3

gen = generator_function()
print(next(gen))  # Output: 1
print(next(gen))  # Output: 2

In this example, generator_function() yields values one at a time and can be resumed to yield the next value.
2. Execution Flow

Normal Function: Executes the entire block of code when called and completes its execution in a single step.
Generator Function: Suspends its execution at each yield statement and resumes from that point on subsequent calls. This allows the generator to produce a sequence of values lazily.

Example of Execution Flow in a Generator Function:
def count_up_to(max):
    count = 1
    while count &#x3C;= max:
        yield count
        count += 1

counter = count_up_to(3)
print(next(counter))  # Output: 1
print(next(counter))  # Output: 2
print(next(counter))  # Output: 3

In this example, the count_up_to() generator function yields numbers up to a specified maximum, pausing between yields.
3. Memory Usage

Normal Function: Typically uses more memory if the function returns a large list or dataset because all values are computed and stored at once.
Generator Function: More memory-efficient for large datasets or infinite sequences, as it generates values one at a time and does not store all values in memory.

Example of Memory Usage with a Normal Function:
def large_list():
    return [x for x in range(1000000)]

big_list = large_list()  # Uses a lot of memory

Example of Memory Usage with a Generator Function:
def large_sequence():
    for x in range(1000000):
        yield x

big_gen = large_sequence()  # Uses less memory

In the generator example, large_sequence() generates values on demand, avoiding high memory consumption.
4. Use Cases

Normal Function: Suitable for tasks where all results are needed immediately and can be returned at once. Common in cases where the output is a finite, precomputed set of values.
Generator Function: Ideal for tasks requiring lazy evaluation, such as handling large datasets, streaming data, or generating values on-the-fly. Useful for cases where you only need part of the data or need to work with infinite sequences.

Conclusion
The primary difference between a normal function and a generator function in Python lies in their handling of execution flow and memory usage. Normal functions use return to send a single result back and terminate, while generator functions use yield to produce a series of values lazily, allowing them to resume and continue execution. Generators are particularly useful for memory-efficient processing of large or infinite sequences, making them a powerful tool for many Python applications.

What is the difference between a normal function and a generator function in Python?

Similar Questions