Hero Vired Logo


Vired Library

Need help? Call us at


or Chat with us on

Yield in Python: The Ultimate Handbook for Effective Coding

Python's extensive library of utilities makes developers' life a lot easier. The yield keyword in Python is one such tool that may be used to swap out return statements from regular Python routines. This in-depth article will cover every aspect of yield in Python and its use in generator functions. So, let's begin. 

Table of Content

What is Yield in Python?

In Python yield is used in generator functions to define a generator. When the yield statement is encountered, it temporarily suspends the function's execution, returns a value to the caller, and remembers its state. The function can be resumed later, continuing from where it left off. When the yield function in Python is used, the function offers a result to the caller (just like a normal function would), but it will still keep every local variable unchanged. Python generator function is any function that has the yield keyword. 
Yield in Python

When developing a Python generator function, leverage the yield statement rather than returning with the return keyword all at once. When working with large datasets, the Python feature yield is really helpful. 

Understanding Python Yield

A Python generator function is a function that returns an iterable generator object rather than a single value. Using a basic loop or the next() or list() methods, you may access or read each value that the generator function returned, which is kept within a generator object. The keywords generator() and yield can be used to build generator functions. 

A good example is provided below:

def generator():
   yield "Welcome"
   yield "to"
   yield "HeroVired"
gen_object = generator()
for i in gen_object:

In the program mentioned above, you made a basic Python generator function and used a number of yield statements to return a number of values, which were then saved within a generator object that you made. The object's values can then be printed using a loop over the object. 

Syntax of the yield Keyword in Python

Below is the syntax example of yield in python:

def function():    
yield < expression > # writing an yield statement    
print( function )   

Why and When Should You Use Python Yield?

A generator function returns a generator object rather than data when the yield in Python is used inside it. In actuality, it keeps a local state for every value that is returned inside of this generator object. 

Memory would have been eaten up quickly if the return statement had been used, which would've returned an array of values. Therefore, in such circumstances, the yield must constantly be chosen over the return. 

Furthermore, the generator function's execution doesn't begin until the caller loops through the generator object. As a result, it both reduces memory usage and improves the program's overall effectiveness. Here are some scenarios in which you must utilize python yield: 

  • Instead of putting the returned data into a list when it is really large, you may utilize yield. 
  • Yield is a better choice if you wish to execute or compute massive datasets more quickly. 
  • Use of yield can help you use memory more efficiently. It can be deployed to generate an endless stream of data. 
  • A list's size can be adjusted to infinity without risking a memory limit problem. 
  • You can save a lot of time by starting from the previously defined yield statement when calling a function that has a yield statement continuously. 

Difference Between Return and Yield Python

Here are the key differences between return and yield in Python: 

Return In Python Yield In Python
The code deploys/executes until it reaches the return statement, which terminates with a single value returned to the caller.  The caller calls the generator function, which then creates a generator object by combining all the yield return values. Moreover, the caller must iterate over the object before the code runs. 
When a caller invokes a typical function, execution starts when it reaches the return statement and stops when it does not. After that, it gives the caller their value. The initial yield is carried out when a caller invokes the generating function, and the function terminates. After that, it returns to the caller the generator object, which contains the value. The cycle repeats again when the caller has reached or reiterated this value, yielding the following statement.
A standard function can only utilize one return statement. In a generator function, numerous yield statements are permissible. 
Memory is allotted for every returned value. Using the yield keywords results in no memory deployment.
It must only be applied to limited data sets. Exceptionally memory-efficient, particularly when working with huge data sets.
Larger data sizes result in longer execution times since additional processing is required. The yield keyword reduces the execution time for huge data collections.

Advantages and Disadvantages of Yield in Python

Below are the advantages and disadvantages of yield in python:

Pros of Using Yield in Python:

  • The load on the memory allocation system is controlled since local variable states are preserved. 
  • Time is saved by preserving the prior state rather than having to restart the procedure.

Cons of Using Yield in Python:

  • It's important to invoke the function correctly. Using yield might occasionally become erroneous if not. 
  • Coding complexity increases as a result of time and storage optimization, and its explanation is frequently opaque. 

Yield in Python

Example of Using Yield in Python | Fibonacci Series

You can utilize the general example provided here to fully comprehend the notion of yield in Python. Here is a Fibonacci program that was made by substituting the keyword yield for the return keyword. 

def fibonacci(n):
   temp1, temp2 = 0, 1
   total = 0
   while total < n:
       yield temp1
       temp3 = temp1 + temp2
       temp1 = temp2
       temp2 = temp3
       total += 1
fib_object = fibonacci(20)

In this case, you have produced a Fibonacci program that outputs the top 20 Fibonacci numbers. You have utilized the python 

yield method to store every value in an object rather than storing them individually in an array or list and then returning the list. This saves plenty of memory, particularly when the selection is wide. 

More Examples of Yield in Python

Certainly! Here are a few examples to illustrate the usage of yield in Python:

Example 1: Creating a Simple Generator

Copy code
def my_generator():
    yield 1
    yield 2
    yield 3

# Using the generator
gen = my_generator()
print(next(gen))  # Output: 1
print(next(gen))  # Output: 2
print(next(gen))  # Output: 3

Example 2: Generating Fibonacci Sequence

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

# Using the Fibonacci generator
fib_gen = fibonacci()
print(next(fib_gen))  # Output: 0
print(next(fib_gen))  # Output: 1
print(next(fib_gen))  # Output: 1
print(next(fib_gen))  # Output: 2

Example 3: Filtering Even Numbers

Copy code
def even_numbers(numbers):
    for num in numbers:
        if num % 2 == 0:
            yield num

# Using the even_numbers generator
nums = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
even_gen = even_numbers(nums)
print(next(even_gen))  # Output: 2
print(next(even_gen))  # Output: 4
print(next(even_gen))  # Output: 6

These examples demonstrate different use cases of python yield, including generating a sequence of values, generating an infinite sequence, and filtering values based on a condition.


In conclusion, multiple values can be returned from generator functions using Python's yield statements. It enhances the code's overall performance while being extremely memory-efficient. The values to be returned are stored as local variables, which saves memory. 

Furthermore, since the prior states are preserved, the function does not need to be executed from scratch each time. This is why python yield keywords are a great substitute for return statements and are quite well-liked among developers.


While the return keyword typically marks the completion of an execution and "returns" the outcome to the caller statement, the yield keyword serves to turn a conventional Python function into a generator.
Python's yield keyword works similarly to the return statement used for values, except that instead of only returning a value to the person who called the function that contains yield, it also returns a generator object.
Unlike the return statement, which totally closes the function, the yield statement only suspends it by storing all of its states in memory for future use. The function is not stopped when the generator function yields. Instead, the function is paused by the yield expression, which then hands control back to the caller.
In Python, the yield keyword is used in generator functions to create an iterator. When the yield statement is encountered, it temporarily suspends the function's execution, saves its state, and returns a value. The function can be resumed later, picking up where it left off.

Blogs from other domain

Carefully gathered content to add value to and expand your knowledge horizons

Hero Vired logo
Hero Vired is a premium LearnTech company offering industry-relevant programs in partnership with world-class institutions to create the change-makers of tomorrow. Part of the rich legacy of the Hero Group, we aim to transform the skilling landscape in India by creating programs delivered by leading industry practitioners that help professionals and students enhance their skills and employability.
Privacy Policy And Terms Of Use
©2023 Hero Vired. All Rights Reserved.
  • *
    These figures are indicative in nature and subject to inter alia a learner's strict adherence to the terms and conditions of the program. The figures mentioned here shall not constitute any warranty or representation in any manner whatsoever.