🐍 Lesson 17: Python Decorators – Enhance Functions Dynamically

Welcome to Lesson 17! Today we’ll learn about decorators — a powerful feature in Python that allows you to modify or enhance functions without changing their code.

---

⭐ What You Will Learn in This Lesson

• Understand what decorators are and how they work
• Learn to use decorators with functions and arguments
• Enhance functionality dynamically without modifying the original code
• Implement real-world use cases like logging, authentication, and more
• Master @decorator syntax for cleaner code

---

👥 Who Is This Lesson For?

• Intermediate Python learners who want to enhance their code dynamically
• Anyone working on larger projects that need reusable enhancements
• Developers interested in building frameworks and advanced Python features

---

📦 What Is a Decorator?

A decorator is a function that takes another function as input, adds functionality, and returns it. It’s commonly used for logging, authentication, timing, and more.

---

🧩 1. Basic Decorator Example

def my_decorator(func):
    def wrapper():
        print("Before the function runs")
        func()
        print("After the function runs")
    return wrapper

def say_hello():
    print("Hello, Python!")

# Apply decorator
decorated = my_decorator(say_hello)
decorated()

Output:

Before the function runs
Hello, Python!
After the function runs

---

🧩 2. Using @decorator Syntax

Python allows a shortcut to apply decorators using @:

def my_decorator(func):
    def wrapper():
        print("Before function")
        func()
        print("After function")
    return wrapper

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

greet()

---

🧩 3. Decorators with Arguments

Decorators can also work with functions that have parameters:

def decorator(func):
    def wrapper(name):
        print("Hello,", name)
        func(name)
        print("Goodbye,", name)
    return wrapper

@decorator
def say_name(name):
    print("Inside function:", name)

say_name("Alice")

---

🧩 4. Why Decorators Matter

• Add functionality without modifying the original function
• Useful for logging, authentication, caching, and performance monitoring
• Keeps code clean, modular, and reusable
• Common in real-world Python frameworks like Flask and Django

---

🧪 Practice

1. Create a decorator that prints “Start” before a function and “End” after it.
2. Write a decorator that measures the execution time of a function.
3. Create a decorator that converts a string returned by a function to uppercase.
4. Apply multiple decorators to a single function.
5. Experiment with decorators to handle exceptions in functions.

---

❌ Common Mistakes

• Not returning the decorated function correctly in the decorator
• Forgetting to pass arguments to the wrapped function inside the decorator
• Confusing the order of decorators when stacking them

---

❓ Frequently Asked Questions (FAQ)

1. What happens if I apply multiple decorators?

Decorators are applied from bottom to top. The function is passed through the innermost decorator first.

2. Can decorators work with functions that have arguments?

Yes, use a wrapper function inside the decorator to accept and pass arguments.

3. What are the real-world use cases for decorators?

Decorators are useful for logging, access control, caching, and tracking function performance.

---

🚀 What’s Next?

In the next lesson, you’ll learn about:

• Iterators and generators in Python
• Creating your own iterators
• Efficient data processing with generators

---

➡ Next Lesson

Go to Lesson 18 →