Decorators and Generators Python

What You’ll Learn 📚

• Understand what decorators and generators are in Python.
• Learn how to create and use decorators with simple examples.
• Explore the power of generators for efficient looping.
• Troubleshoot common issues and mistakes.

Introduction to Decorators

Decorators are a powerful and expressive tool in Python that allow you to modify the behavior of a function or class. Think of them as wrappers that you can put around a function to enhance or alter its behavior without changing the actual function code. 🤔

Lightbulb Moment: Decorators are like adding a filter to your Instagram photo. The original photo remains unchanged, but it looks different with the filter applied!

Key Terminology

• Decorator: A function that takes another function and extends its behavior without explicitly modifying it.
• Wrapper Function: The function inside the decorator that actually modifies the behavior of the original function.

Simple Decorator Example

def my_decorator(func):
    def wrapper():
        print("Something is happening before the function is called.")
        func()
        print("Something is happening after the function is called.")
    return wrapper

@my_decorator
def say_hello():
    print("Hello!")

say_hello()

Progressively Complex Decorator Examples

Example 1: Logging Decorator

def log_decorator(func):
    def wrapper(*args, **kwargs):
        print(f"Calling function {func.__name__} with arguments {args} and {kwargs}")
        result = func(*args, **kwargs)
        print(f"Function {func.__name__} returned {result}")
        return result
    return wrapper

@log_decorator
def add(a, b):
    return a + b

add(5, 3)

Example 2: Timing Decorator

import time

def timing_decorator(func):
    def wrapper(*args, **kwargs):
        start_time = time.time()
        result = func(*args, **kwargs)
        end_time = time.time()
        print(f"Function {func.__name__} took {end_time - start_time} seconds to execute")
        return result
    return wrapper

@timing_decorator
def compute_square(n):
    return n * n

compute_square(10)

Introduction to Generators

Generators are a special type of iterator in Python that allow you to iterate over data without storing the entire dataset in memory. They are perfect for handling large datasets or streams of data. 🚀

Lightbulb Moment: Generators are like a playlist on shuffle. You don’t need to load all the songs at once; you just play one song at a time!

Key Terminology

• Generator: A function that uses yield to return a value and pause its state, resuming where it left off when called again.
• Yield: A keyword that returns a value from a generator function and pauses its execution.

Simple Generator Example

def simple_generator():
    yield 1
    yield 2
    yield 3

for value in simple_generator():
    print(value)

Progressively Complex Generator Examples

Example 1: Fibonacci Generator

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

fib = fibonacci_generator()
for _ in range(5):
    print(next(fib))

Example 2: File Line Generator

def read_file_line_by_line(file_path):
    with open(file_path, 'r') as file:
        for line in file:
            yield line.strip()

for line in read_file_line_by_line('example.txt'):
    print(line)

Common Questions and Answers

1. What is the main advantage of using decorators?

   Decorators allow you to add functionality to existing code in a clean and readable way without modifying the original code.

2. How do I know when to use a generator?

   Use generators when you need to iterate over large datasets or streams of data without loading everything into memory.

3. Can I use multiple decorators on a single function?

   Yes, you can stack multiple decorators on a function, and they will be applied in the order they are listed.

4. Why does my generator not produce any output?

   Ensure you are iterating over the generator or using next() to retrieve values.

5. What is the difference between yield and return?

   yield pauses the function and saves its state, while return exits the function and does not save the state.

Troubleshooting Common Issues

If your decorator isn’t working as expected, check if you’ve applied it correctly using the @decorator_name syntax. Also, ensure your wrapper function returns the result of the original function call.

If your generator isn’t yielding values, make sure you’re using yield instead of return and that you’re iterating over the generator correctly.

Practice Exercises

• Create a decorator that caches the results of a function call.
• Write a generator that yields prime numbers.

Try these exercises to reinforce your understanding! 💪

Additional Resources

• Python Decorator Documentation
• Python Generator Documentation