Python Generators Tutorial – Complete Guide

Are you looking to dive deeper into the world of Python programming? If so, you’ve probably come across the term “Python generators”. This intriguing concept can be quite confusing when you first encounter it, but don’t worry, we’ve got you covered!

In this comprehensive tutorial, we aim to break down the concept of Python generators for you. Not only will you understand what they are, but we’ll also delve into how they’re used and why investing time into mastering them is a smart manoeuvre. Let’s dive in!

What Are Python Generators?

Python generators are a special type of function that return an iterable set of items. But, rather than building and returning an entire array of results at once, generators yield one result at a time. This can provide some serious benefits, particularly when dealing with large collections of data.

Why Bother With Python Generators?

Now that we’ve answered the question of “what”, let’s focus on the “why”. Why should you bother learning about generators?

  • Memory Efficiency: Generators are a fantastic way to work with large data. They allow you to create a data stream without allocating memory for the whole list at once.
  • Laziness: Generators are evaluated lazily. This means values are only computed when needed, saving processing time.
  • Iteration Control: Using generators gives developers stronger control over the iteration process, allowing to handle flow control and exception handling with ease.
CTA Small Image

Creating a Basic Python Generator

With the concepts of what and why behind us, let’s get into the actual practice of creating Python generators.

The simplest way to create a generator is by using the keyword yield in a function. Let’s look at a basic example:

def simple_generator():
    yield 1
    yield 2
    yield 3

for number in simple_generator():

In this example, simple_generator() is the generator function. When it’s called in the for loop, the generator outputs the numbers 1, 2 and 3 one by one, and not all at once.

Creating a Generator with a Loop

You can also use loops in your generator functions, creating even more powerful generators. Let’s create a generator that yields square numbers:

def squares(n):
  for i in range(n):
    yield i ** 2

for number in squares(5):

This time, our squares(n) generator function outputs the square of each number in the range of n. For this example, it prints 0, 1, 4, 9, and 16.

Python Generators with Conditions

Adding to the power of generators, you can implement conditions in your functions as well. Consider the following example:

def even_numbers(n):
    for i in range(n):
        if i % 2 == 0:
            yield i

for number in even_numbers(10):

The even_numbers(n) function uses a condition to yield only even numbers in the range of n. For this example, it will print 0, 2, 4, 6 and 8.

Using next() with Python Generators

You can manually iterate through a generator function using the built-in next() function. Let’s modify our first generator function for this:

def simple_generator():
    yield 1
    yield 2
    yield 3

gen = simple_generator()

print(next(gen))  # Output: 1
print(next(gen))  # Output: 2
print(next(gen))  # Output: 3

This time we assign the generator function to a variable and use next() on that variable to go through the generator.

Python Generators with Expressions

Python also supports generator expressions, which are a high performance, memory efficient generalization of list comprehensions and lambdas.

gen = (x ** 2 for x in range(5))
for number in gen:

Here, we built a generator expression that calculates the square of each number in the range of 5. It then prints 0, 1, 4, 9, and 16.

Python Generators with Fibonacci Sequence

Let’s apply the power of generators to something more complex, like generating a fibonacci sequence:

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

for number in fibonacci(10):

As a result, the function prints the Fibonacci sequence numbers that are less than 10: 0, 1, 1, 2, 3, 5, 8.

Sending Data into Generators

Python generators not only produce data for iteration, but can also consume data using the send() function:

def generator_func():
    while True:
        x = yield
        print(f'Value received: {x}')

gen = generator_func()

next(gen)  # prime the generator

gen.send('Hello, Zenva!')
gen.send('Python Generators are cool!')

This function generator_func() receives and prints the data sent to the generator. We had to call next() in the code before we could start sending values.

Taking Values from User

Let’s see how you can use generators to take a series of user inputs until a specific condition is met:

def user_inputs():
    while True:
        data = yield
        if data == 'q':
            print(f'You entered: {data}')

user = user_inputs()

next(user)  # prime the generator


In this example, user_inputs() is a generator function that constantly yields until the user enters ‘q’. It outputs whatever the user inputs, unless ‘q’ is entered, in which case the cycle breaks.

Where to Go Next – Continuing Your Python Journey

Excellent work! You’ve set a solid foundation in Python generators and gone well on your way to becoming a proficient Python programmer. But don’t stop now, there’s so much more to learn and explore! To keep making strides in your development journey, we highly recommend expanding your knowledge with our Python Mini-Degree.

The Python Mini-Degree is a comprehensive and engaging compilation of courses designed by us at Zenva to take you from Python beginner to professional. This program covers everything from basics of programming and algorithms to creating games, apps and even AI chatbots! All courses include interactive lessons, hands-on projects, quizzes and live code practices.

  • Beginner to Professional: Our courses cater to all levels of programmers. Whether you are a beginner or an experienced developer looking to add Python to your skillset, we have the right course for you.
  • Projects and Certification: Throughout the courses, students will create their own projects and upon completion receive certificates, boosting their portfolio and showcasing their newly acquired skills.
  • Flexibility: With our courses, you can learn at your own pace and on your own schedule. They are accessible on all devices, allowing you to learn whenever and wherever you want.

At Zenva, you learn from experienced and certified instructors, ensuring you get high-quality and effective education. All of this, partnered with the popularity and high-demand of Python in the job market, makes our Mini-Degree an excellent choice for individuals looking to excel in their careers.

You can also explore our broader collection of Python courses. We assure you that this is an investment that will positively impact your future!


In conclusion, the utilization of Python generators can significantly optimize memory usage and improve the overall efficiency of your Python programs. By equipping yourself with the knowledge of how to create and utilize generators, you’re making a wise investment in your development repertoire.

Are you feeling inspired to deepen your Python skills? Then don’t wait any longer and begin your learning adventure today. Whether you’re a beginner or looking to level up, our Python Mini-Degree is the perfect launchpad for your journey to becoming a Python pro. Happy learning!

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.