Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://www.geeksforgeeks.org/python/generators-in-python/ below:

Generators in Python - GeeksforGeeks

Last Updated : 29 Jul, 2025

A generator function is a special type of function that returns an iterator object. Instead of using return to send back a single value, generator functions use yield to produce a series of results over time. This allows the function to generate values and pause its execution after each yield, maintaining its state between iterations.

Example:

def fun(max):
    cnt = 1
    while cnt <= max:
        yield cnt
        cnt += 1

ctr = fun(5)
for n in ctr:
    print(n)

Explanation: This generator function fun yields numbers from 1 up to a specified max. Each call to next() on the generator object resumes execution right after the yield statement, where it last left off.

• Memory Efficient : Handle large or infinite data without loading everything into memory.
• No List Overhead : Yield items one by one, avoiding full list creation.
• Lazy Evaluation : Compute values only when needed, improving performance.
• Support Infinite Sequences : Ideal for generating unbounded data like Fibonacci series.
• Pipeline Processing : Chain generators to process data in stages efficiently.

Let's take a deep dive in python generators:

Creating a generator in Python is as simple as defining a function with at least one yield statement. When called, this function doesn’t return a single value; instead, it returns a generator object that supports the iterator protocol. The generator has the following syntax in Python:

def generator_function_name(parameters):
# Your code here
yield expression
# Additional code can follow

Example: we will create a simple generator that will yield three integers. Then we will print these integers by using Python for loop.

def fun():
    yield 1            
    yield 2            
    yield 3            
 
# Driver code to check above generator function
for val in fun(): 
    print(val)

• Yield: is used in generator functions to provide a sequence of values over time. When yield is executed, it pauses the function, returns the current value and retains the state of the function. This allows the function to continue from same point when called again, making it ideal for generating large or complex sequences efficiently.
• Return: is used to exit a function and return a final value. Once return is executed, function is terminated immediately and no state is retained. This is suitable for cases where a single result is needed from a function.

Example with return:

def fun():
    return 1 + 2 + 3

res = fun()
print(res)  

Generator expressions are a concise way to create generators. They are similar to list comprehensions but use parentheses instead of square brackets and are more memory efficient.

Syntax:

(expression for item in iterable)

Example: We will create a generator object that will print the squares of integers between the range of 1 to 6 (exclusive).

sq = (x*x for x in range(1, 6))
for i in sq:
    print(i)

Suppose we need to create a stream of Fibonacci numbers. Using a generator makes this easy, you just call next() to get the next number without worrying about the stream ending.

• Generators are especially useful for processing large data files, like logs, because:
• They handle data in small parts, saving memory
• They don’t load the entire file at once
• While iterators can do similar tasks, generators are quicker to write since you don’t need to define __next__ and __iter__ methods manually.

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4