Python Yield Keyword Tutorial – Complete Guide

Anyone looking to understand the vast landscape of Python has no doubt come across the “yield” keyword. As you delve deeper into Python, mastering the skill to use “yield” efficiently can be a significant boost.

What is Yield in Python?

“Yield” is a keyword in Python that is used in the body of a function like a return statement. But it is much more than just a return statement. A yield statement pauses the functioning whenever it is called and resumes its operation when needed, an especially handy feature when dealing with large datasets.

Why should you learn to use Yield?

Utilizing “yield” correctly can be an asset for a few reasons:

  • Memory Efficiency: It doesn’t store the interim results in memory, making it more memory-efficient when working with large datasets.
  • Readable Code: “Yield” can make your code more readable and thereby manageable.
  • Handles Complex Control Flow: You can use “yield” to control the functions execution time and state, making it fit for handling more complex control flows.

With the “yield” keyword on your Python arsenal, you gain a significant advantage to handle data-intensive tasks more efficiently. So why not take a ride deep into understanding and exploring “yield”!

Now let’s move on to the coding part. You’ll not just read about “yield”, but see it in action. The code examples are straightforward, interactive and studded with commenting, so there’s no room for confusion.

CTA Small Image

Coding Tutorial: Part 1

Imagine you’re building a game where each action is a function, and the functions are chained together to navigate the game flow. Now within those actions, you have multiple stages. “Yield” can elegantly help you manage the stages within each action.

def action1():
    print("Action 1 initiated")
    yield "Stage1"
    print("Stage 1 completed")
    yield "Stage2"
    print("Stage 2 completed")
    yield "Stage3"
    print("Stage 3 completed")

game = action1()


In the above code snippet, action1() is a game action that has 3 stages. The yield function is used to pause after every stage and resume for the next stage only when necessary.

Now let’s explore more coding examples and further down the world of Python “yield”.

Coding Tutorial: Part 2

Let’s now imagine a scenario where the games get progressively difficult. In such a situation, the “yield” keyword will help us to hold the execution of certain actions, keeping it midway, and get back to it when required.

def action2():
    for i in range(3):
        print("Level " + str(i+1) + " initiated")
        print("Level " + str(i+1) + " completed")

game = action2()

print("Do some other action")
print("Do some other action")

In the above scenario, action2() initiates a game level (Level 1, 2, and 3 progressively) and completes it later but only when next(game) is called.

Coding with Yield: Part 3

Let’s continue to explore the Python yield keyword’s powers by trying out a couple more examples. This time, we’ll focus on using yield to generate a series of numbers and work with more complex data structures.

Example 1: Generators and series of numbers

def numGenerator(n):
    num = 0
    while num < n:
        yield num
        num += 1

series = numGenerator(5)

for num in series:

In this example, numGenerator generates a series of numbers up to ‘n’. Unlike traditional functions that would calculate all numbers at once (using more memory), heapq ‘yields’ one number at a time, thereby saving memory.

Coding with Yield: Part 4

Example 2: Using Yield with Lists

def listGenerator():
    my_list = range(3)
    for i in my_list:
        yield i*i

squares = listGenerator()

for square in squares:

The listGenerator function here generates squares of numbers in the range(3). Again, by using yield, we’re able to calculate and output each square one at a time, rather than all at once.

Example 3: Nested Yield Statements

def nestedYield():
    yield "First yield"
    yield from secondaryYield()
    yield "Last yield"

def secondaryYield():
    for i in range(2):
        yield "Yield from secondary function"

for item in nestedYield():

This code example illustrates how we can use the yield from statement to yield all values from a secondary generator directly within another generator function. It simplifies the code and makes it more readable.

Example 4: Yield in Recursive Functions

def recursiveGenerator(n):
    if n > 0:
        yield n
        yield from recursiveGenerator(n-1)

for num in recursiveGenerator(5):

In this final example, we can see how yield can be effectively used in recursive functions. Our recursiveGenerator function starts at a number ‘n’ and works its way down to 0, yielding each number in the recursive cycle.

In the end, there is much more to Python’s yield than meets the eye. It provides a powerful tool for memory management, controlling execution flow, and even enhancing code readability. These examples have merely scratched the surface of its potential.

Remember that at Zenva, we believe in exploring more, learning more, and achieving more. So, keep those curiosity levels up and never stop coding!

Coding with Yield: Part 5

In this section, we will further delve into the world of Python’s “yield” with more complex examples.

Example 1: Yielding a Fibonacci Series

The Fibonacci sequence is an infinite series where each number is the sum of the two preceding ones, usually starting with 0 and 1. But generating the series can be tedious and memory-intensive in Python. Using the “yield” keyword simplifies this process considerably.

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

f = fibonacci()

for _ in range(10):

In this code snippet, the fibonacci() function generates an infinite series of Fibonacci numbers. The ‘yield’ keyword makes the function a generator that gives us one Fibonacci number at a time, reducing the load on memory substantially.

Example 2: Creating a Pipeline with Yield

One of the best uses of the ‘yield’ keyword is in creating a pipeline in Python to allow processing of elements one at a time.

def readfile():
    for line in open('large_text_file.txt'):
        yield line

def filterlines(lines):
    return (line for line in lines if "python" in line)

def printlines(lines):
    for line in lines:

lines = readfile()
filtered_lines = filterlines(lines)

The code above simulates reading a large text file line by line, filtering the lines with the word “Python”, and printing each filtered line to the terminal.

Coding with Yield: Part 6

We g↻ through for more examples that illustrate the utility of ‘yield’ in handling complex processes and workflows.

Example 3: Implementing a Countdown

def countdown(n):
    while n > 0:
        yield n
        n -= 1

for num in countdown(5):

This function, countdown(), uses ‘yield’ to implement a countdown starting from a number ‘n’ and decrementing by one until it reaches 0.

Example 4: Yield in Exception Handling

def inf_loop():
    i = 0
        while 1: yield i
    except GeneratorExit:
        print('Exiting Infinite Loop')

g = inf_loop()

This infinite loop uses ‘yield’ to yield the value of ‘i’ at every loop iteration. The ‘except’ block is used to handle the GeneratorExit exception when the close() method is called on the generator.

From our examples, it is clear that the ‘yield’ keyword is very versatile and can be applied to a variety of scenarios when writing Python code. Whether it’s reading large data files, managing complex processes, or performing memory-intensive calculations, ‘yield’ comes in extremely handy.

Keep on practicing, keep on coding! At Zenva, we are with you every step of your coding journey. Never stop learning and pushing the boundaries of your skills.

Where to Go Next with Your Python Learning Journey?

So, you’ve discovered the power of Python’s “yield” keyword and you’re wondering what lies next on your coding journey.

That’s why we created the Python Mini-Degree program. It’s more than just a collection of Python courses; it’s a comprehensive, yet flexible learning path to empower you with Python programming. The Python Mini-Degree offered by Zenva Academy is a versatile, comprehensive collection of courses designed to teach you Python programming. It covers various facets of Python including, but not limited to, coding basics, algorithms, object-oriented programming, and creating your own games and apps.

  • Learn Python’s Coding Basics
  • Explore Algorithms in Python
  • Master Object-Oriented Programming
  • Create your own Games and Apps

And the best part? You will learn by doing! Our courses center around projects you can add to your portfolio.

The curriculum is designed to cater to all learning levels – begin your Python journey or take it a notch higher. Additionally, our courses give you the flexibility to learn at your convenience. They are available 24/7, meaning you can access them anytime, from anywhere.

So, what are you waiting for? Embrace the world of Python coding with Zenva and begin your journey to become a Python pro.


Mastering Python commands like “yield” offers a new vista of possibilities for your coding journey. Each step expands your horizons to contribute more and create solutions that matter. Through this interactive guide, we hope to ignite a spark in you to create, explore, and achieve the unseen!

But as always, the journey doesn’t stop here. There’s a universe of Python out there, ripe to be explored and we’re here to accompany you on this thrilling voyage. Our Python Mini-Degree is a stepping stone into this exciting world of Python and much more.

At Zenva, we believe in conquering limits, transcending boundaries, and scripting new milestones. You can too! Let’s set forth on this amazing adventure together. Happy coding!

Did you come across any errors in this tutorial? Please let us know by completing this form and we’ll look into it!

Python Blog Image

FINAL DAYS: Unlock coding courses in Unity, Godot, Unreal, Python and more.