Mastering Python Decorators with 3 Practical Real-World Examples

Shagun Sharma — Mon, 14 Sep 2026 15:41:07 +0000

If you have been programming in Python for a while, you have probably seen the "@" symbol placed above function definitions. These are called Decorators.
Decorators can feel confusing for beginners, but they are extremely powerful. In simple terms, a decorator allows you to add new functionality to an existing function without modifying its original code.
In this guide, we will break down how decorators work and look at 3 real-world examples you can use in your projects today.

What is a Python Decorator?

In Python, functions are first-class objects. This means functions can be:

Passed as arguments to other functions.
Returned from other functions.
Assigned to variables.
A decorator is simply a function that takes another function as an argument, wraps some extra behavior around it, and returns the modified function.

1. Execution Time Measurement Decorator

When optimizing code, you often need to know how long a specific function takes to run. Instead of writing timing logic inside every function, you can create a reusable "@timer" decorator.

import time
def timer(func):
     def wrapper(*args, **kwargs):
         start_time = time.time()
         result = func(*args, **kwargs)
         end_time = time.time()
         print(f"Execution time for {func.__name__}:     
         {end_time - start_time:.4f} seconds")
         return result
    return wrapper
@timer 
def heavy_calculation():
    # Simulating a slow task
    time.sleep(2)
    return "Task Completed"
# Calling the function
heavy_calculation()

2. Function Logging Decorator

In production applications, logging function calls with their arguments helps immensely with debugging.

def log_function_call(func):
    def wrapper(*args, **kwargs):
        print(f"[LOG]: Calling '{func.__name__}' with arguments {args}")
        result = func(*args, **kwargs)
        print(f"[LOG]: '{func.__name__}' returned {result}")
        return result
    return wrapper

@log_function_call
def add_numbers(a, b):
    return a + b

add_numbers(10, 20)

3. Simple Authentication Check Decorator

Decorators are widely used in web frameworks like Flask and FastAPI to restrict access to specific routes based on user roles or login status.

def require_authentication(func):
    def wrapper(user, *args, **kwargs):
        if not user.get("is_authenticated"):
            print("Access Denied: Please log in first.")
            return None
        return func(user, *args, **kwargs)
    return wrapper

@require_authentication
def view_dashboard(user):
    print(f"Welcome to your dashboard, {user['name']}!")

# Simulated user objects
guest_user = {"name": "Alice", "is_authenticated": False}
logged_in_user = {"name": "Shagun", "is_authenticated": True}

view_dashboard(guest_user)      # Output: Access Denied
view_dashboard(logged_in_user)  # Output: Welcome to your dashboard, Shagun!

Key Takeaways

DRY Principle: Decorators help you keep your code clean by avoiding repeated code for tasks like logging, timing, and security checks.
Flexibility: Use *args and *kwargs inside the wrapper function so your decorator works with any number of positional or keyword arguments.

A Complete Guide to Connecting Python with SQLite

Shagun Sharma — Sun, 13 Sep 2026 09:35:49 +0000

When building small to medium-scale applications, you often need a lightweight database that requires zero configuration. SQLite is a self-contained, serverless database engine that comes pre-installed with Python, making it an ideal choice for beginner developers and quick projects.
In this tutorial, you will learn how to set up an SQLite database, perform basic CRUD(Create, Read, Update, Delete) operations, and handle database errors smoothly in python.

Prerequisites

To follow along with this tutorial, you will need:

Basic understanding of Python syntax (variables, functions, and loops).
Python 3.x installed on your system.

Step 1: Connecting to the SQLite Database

Python provides a built-in module called "sqlite3", so you do not need to install any external libraries.
Create a new Python file named db_tutorial.py and add the following code:

import sqlite3
try:
    # Connects to 'app_database.db'.If it doesn't exist,   
    Python creates it.
    connection = sqlite3.connect("app_database.db")
    cursor = connection.cursor()
    print("Database connected successfully!")
except sqlite3.Error as e:
       print(f" Error connecting to database: {e}")

How it works:

sqlite3.connect() opens a connection to the database file.
connection.cursor() creates a cursor object, which allows us to execute SQL statements.

Step 2: Creating a Table

Now that we have established a connection let's create a table named "users" to store user information.

# SQL query to create a users table
create_table_query = """
CREATE TABLE IF NOT EXISTS users (
       id INTEGER PRIMARY KEY AUTOINCREMENT,
       name TEXT NOT NULL,
       email TEXT UNIQUE NOT NULL
);
"""
cursor.execute(create_table_query)
connection.commit()
print("Table created successfully!")

Key Takeaways:

AUTOINCREMENT ensures every user get a unique id.
connection.commit() saves changes to the database.

Step 3: Inserting Data into the Database

To add data safely, we use parameterized queries instead of formatting raw strings. This prevents "SQL Injection" security vulnerabilities.

def add_user(name, email):
    insert_query = "Insert INTO users (name, email)         
                     VALUES (?, ?)"
    try:
        cursor.execute(insert_query, (name,email))
        connection.commit()
        print(f"User '{name}' added successfully!")
  except sqlite3.IntegrityError:
         print(f" Error: Email '{email}' already
               exists.")
# Testing the insert function
add_user("Rahul Sharma", "rahul@example.com")
add_user("Priya Singh", "priya@example.com")

Step 4: Reading Data from the Database

To fetch and display records from SQLite, use fetchall() or fetchone() methods.

cursor.execute("SELECT * FROM users")
rows = cursor.fetchall()
print("\n--- Registered Users ---")
for row in rows:
       print(f"ID: {row[0]} | Name: {row[1]} | Email:  
             {row[2]}")

Step 5: Closing the Connection

Always close the database connection once operations are complete to prevent resource leaks and file lock errors.

# Close the cursor and connection at the end of the script
cursor.close()
connection.close()
print("Database connection closed.")

Conclusion

SQLite is a powerful tool for developers looking to integrate local data storage without managing a full SQL server. In this guide, we covered how to connect to SQLite, execute parameterized queries safely, and manage database errors.
Next Steps:
Try adding an UPDATE and DELETE function to expand this project into a full CRUD application!

DEV Community: Shagun Sharma