What is the use of the "yield" keyword in Python?

Question

Jayant Kumar · Accepted Answer

Table of Contants
Introduction
The yield keyword in Python is used to create a generator, a type of iterable that generates values one at a time as they're needed, rather than computing them all at once. This allows for more memory-efficient programs, especially when working with large datasets or infinite sequences. Unlike a normal function that returns a value and terminates, a function with yield pauses and preserves its state, allowing it to resume where it left off on subsequent calls.

Yield vs Return in Python
The primary difference between yield and return is how they handle control flow and memory. While return sends back a value and terminates the function, yield pauses the function and can be resumed to continue execution from where it left off.
Example:
def generate_numbers():
    for i in range(5):
        yield i

gen = generate_numbers()
print(next(gen))  # Output: 0
print(next(gen))  # Output: 1

Here, the generate_numbers function pauses at each yield statement, returning a value each time it's called with next().

Key Use Cases for Yield in Python
1. Memory-Efficient Iteration with Generators
The main advantage of yield is memory efficiency. When processing large data streams or files, it's more efficient to yield values one by one rather than storing them in memory all at once.
Example:
def read_large_file(file_name):
    with open(file_name) as file:
        for line in file:
            yield line

# Only reads one line at a time
for line in read_large_file("huge_file.txt"):
    print(line)

This allows for efficient handling of large files without loading the entire file into memory.
2. Creating Infinite Sequences
Because generators with yield do not terminate until exhausted, you can create infinite sequences, which are useful when you don't know how many values are required ahead of time.
Example:
def infinite_sequence():
    num = 0
    while True:
        yield num
        num += 1

gen = infinite_sequence()
print(next(gen))  # Output: 0
print(next(gen))  # Output: 1

Here, the generator will continue producing numbers indefinitely without consuming excessive memory.

Practical Examples

Fibonacci Sequence with Yield:

The Fibonacci sequence is an excellent example of using yield to generate values on demand.
def fibonacci():
    a, b = 0, 1
    while True:
        yield a
        a, b = b, a + b

fib = fibonacci()
for _ in range(10):
    print(next(fib))  # Outputs first 10 Fibonacci numbers

Yielding Values from Multiple Generators:

You can yield from multiple generators in a single function by using yield in a loop or calling other generator functions.
def chain_generators():
    yield from range(3)
    yield from ["a", "b", "c"]

for value in chain_generators():
    print(value)

This combines two generators, one generating numbers and the other generating letters.

Conclusion
The yield keyword is a powerful tool for creating memory-efficient iterators, allowing you to generate values on demand without storing them all at once. Whether you're working with large data sets or implementing infinite sequences, yield makes your Python code more efficient by enabling lazy evaluation and reducing memory usage. It’s particularly useful in situations where performance and memory constraints are a concern, making it a valuable feature for Python developers.

What is the use of the "yield" keyword in Python?

Similar Questions