Mastering Python Decorators: A Deep Dive

 


1. Introduction to Decorators

Python decorators are a powerful way to modify or enhance functions and methods without changing their code. They follow the higher-order function concept, allowing functions to be passed as arguments and returned from other functions.

Basic Example

python
def decorator_function(original_function):
    def wrapper_function():
        print(f"Executing {original_function.__name__}")
        return original_function()
    return wrapper_function
@decorator_function
def say_hello():
    print("Hello, World!")
say_hello()

🔹 Output:

nginx
Executing say_hello
Hello, World!

💡 @decorator_function is syntactic sugar for say_hello = decorator_function(say_hello).

2. Understanding Function Decorators

Decorators with Arguments

python
def repeat(n):
    def decorator(func):
        def wrapper(*args, **kwargs):
            for _ in range(n):
                func(*args, **kwargs)
        return wrapper
    return decorator
@repeat(3)
def greet():
    print("Hello!")
greet()

🔹 Output:

Hello!
Hello!
Hello!

💡 The decorator takes arguments (n), modifying how the function behaves dynamically.

3. Using functools.wraps to Preserve Metadata

Using functools.wraps ensures that the decorated function retains its original metadata (name, docstring).

python
import functools
def decorator_function(original_function):
    @functools.wraps(original_function)
    def wrapper_function(*args, **kwargs):
        print(f"Executing {original_function.__name__}")
        return original_function(*args, **kwargs)
    return wrapper_function
@decorator_function
def example():
    """This is an example function."""
    print("Example function executed!")
print(example.__name__)  # Retains 'example' instead of 'wrapper_function'
print(example.__doc__)   # Displays the function's docstring

4. Chaining Multiple Decorators

You can apply multiple decorators to a function:

python
def uppercase(func):
    def wrapper():
        return func().upper()
    return wrapper
def exclaim(func):
    def wrapper():
        return func() + "!!!"
    return wrapper
@uppercase
@exclaim
def greet():
    return "hello"
print(greet())  # Output: HELLO!!!

💡 Execution order: exclaim → uppercase → greet().

5. Class-Based Decorators

Instead of functions, decorators can also be implemented as classes with __call__.

python
class Logger:
    def __init__(self, func):
        self.func = func
    def __call__(self, *args, **kwargs):
        print(f"Logging: {self.func.__name__} called with {args}")
        return self.func(*args, **kwargs)
@Logger
def add(a, b):
    return a + b
print(add(3, 5))  # Output: Logging: add called with (3, 5)

💡 Useful for stateful decorators that maintain persistent data.

6. Real-World Use Cases

a) Logging Function Calls

python
CopyEdit
import time
def log_time(func):
    def wrapper(*args, **kwargs):
        start = time.time()
        result = func(*args, **kwargs)
        end = time.time()
        print(f"{func.__name__} took {end - start:.2f}s")
        return result
    return wrapper
@log_time
def process_data():
    time.sleep(2)
    print("Data processed!")
process_data()

💡 Use Case: Performance monitoring.

b) Access Control (Authentication Decorator)

python
def requires_auth(role):
    def decorator(func):
        def wrapper(*args, **kwargs):
            user_role = "admin"  # Example user role
            if user_role != role:
                print("Access denied!")
                return
            return func(*args, **kwargs)
        return wrapper
    return decorator
@requires_auth("admin")
def sensitive_function():
    print("Sensitive operation performed!")
sensitive_function()

💡 Use Case: API authentication.

c) Caching Expensive Function Calls

python
import functools
def cache(func):
    cache_data = {}
    @functools.wraps(func)
    def wrapper(*args):
        if args in cache_data:
            print("Fetching from cache...")
            return cache_data[args]
        result = func(*args)
        cache_data[args] = result
        return result
    return wrapper
@cache
def expensive_calculation(x):
    print("Performing expensive calculation...")
    return x * x
print(expensive_calculation(4))  # Performs calculation
print(expensive_calculation(4))  # Fetches from cache

💡 Use Case: Optimizing API calls, database queries, or expensive calculations.

Conclusion

Python decorators provide a powerful way to modify functions dynamically while keeping code clean and modular. From simple function wrappers to advanced logging, caching, and authentication, decorators are an essential tool in every Python developer’s toolkit.

WEBSITE: https://www.ficusoft.in/python-training-in-chennai/

Comments

Post a Comment

Popular posts from this blog

Best Practices for Secure CI/CD Pipelines

Image
  🔒 Best Practices for Secure CI/CD Pipelines In a world where software is built and deployed faster than ever, CI/CD pipelines have become the engine room of modern development. But with speed comes risk. If not properly secured, your CI/CD pipeline can become a prime target for attackers looking to inject malicious code, access secrets, or hijack production systems. Here are essential best practices to help you secure your CI/CD pipelines without slowing down your delivery. 1. 🔑 Protect Your Secrets Secrets (API keys, tokens, passwords) are gold for attackers. Use secret managers like HashiCorp Vault, AWS Secrets Manager, or GitHub Actions’ built-in secrets. Never store secrets in code, config files, or environment variables in plaintext. Rotate secrets regularly and audit access. 2. 👤 Enforce Least Privilege Access Only give users, services, and tools the permissions they absolutely need. Use role-based access control (RBAC) . Ensure build agents only have access to t...
Read more

What is DevSecOps? Integrating Security into the DevOps Pipeline

Image
  What is DevSecOps? Integrating Security into the DevOps Pipeline In today’s fast-paced digital landscape, delivering software quickly isn’t just a competitive advantage — it’s a necessity. Enter DevOps: the fusion of development and operations, aimed at streamlining software delivery through automation, collaboration, and continuous improvement. But as we build faster, we must also build safer . That’s where DevSecOps comes in. What is DevSecOps? DevSecOps stands for Development, Security, and Operations . It’s an evolution of the DevOps philosophy that embeds security practices directly into the DevOps pipeline  — from planning to production. Instead of treating security as a final step or a separate process, DevSecOps makes it an integral part of the development lifecycle . In short: DevSecOps = DevOps + Continuous Security. Why DevSecOps Matters Traditional security models often acted as bottlenecks, kicking in late in the software lifecycle, causing delays and costly r...
Read more

SEO for E-Commerce: How to Rank Your Online Store

Image
  🛒 SEO for E-Commerce: How to Rank Your Online Store Running an online store is exciting — but it means nothing if no one can find it. That’s where e-commerce SEO comes in. Search Engine Optimization helps your online store appear higher in search results, driving free, organic traffic that converts. Let’s break down what matters, and how you can boost your store’s visibility. 🔍 Why SEO Matters for E-Commerce 67% of clicks go to the first five results on Google Paid ads are costly — SEO delivers long-term ROI SEO builds trust, visibility, and traffic Whether you’re on Shopify, WooCommerce, Magento, or a custom build —  the fundamentals stay the same . ✅ E-Commerce SEO Checklist 1. Keyword Research for Product Pages Start with what people are actually searching for . 🔧 Tools: Google Keyword Planner Ubersuggest Ahrefs / SEMrush 🎯 Focus on: Product-specific keywords: “black leather sneakers” Long-tail keywords: “eco-friendly yoga mat for beginners” Buyer intent: ...
Read more