Understanding Python Decorators: A Deep Dive

Aman Giri — Sat, 26 Oct 2024 03:30:03 +0000

Python decorators are powerful tools that allow us to modify or enhance the behavior of functions or methods. Common use cases include logging, authorization, and more.
However, when asked to define a decorator, many might say,

It's a wrapper for a function.

While this is technically correct, there's much more happening under the hood.

Dissecting a Simple Decorator
Let's explore a straightforward example:

def my_decorator(func):
    def wrapper(*args, **kwargs):
        print("Before calling the function")
        result = func(*args, **kwargs)
        print("After calling the function")
        return result
    return wrapper

@my_decorator
def say_hello(name):
    print(f"Hello, {name}!")

Here, my_decorator is a decorator for the function say_hello. When say_hello is defined, it is automatically passed to my_decorator, transforming the function call into:
say_hello = my_decorator(say_hello)

When Does This Transformation Happen?
This transformation occurs during the compilation of the code, specifically at function definition time—not at execution time.

Disassembling the Code
To understand how decorators work at a lower level, we can use the dis module to examine the bytecode of the decorated function:

import dis

@my_decorator
def say_hello(name):
    print(f"Hello, {name}!")

dis.dis(say_hello)

Bytecode Breakdown

The output of dis.dis(say_hello) might look like this:

Explanation of the Bytecode

Before Calling the Function
- LOAD_GLOBAL: Loads the print function.
- LOAD_CONST: Loads the message 'Before calling the function'.
- CALL_FUNCTION: Calls print.
- POP_TOP: Discards the return value.
Calling the Original Function
- LOAD_DEREF: Loads the original function (func) captured by the closure.
- LOAD_FAST: Loads the positional and keyword arguments.
- BUILD_MAP: Creates a new dictionary for keyword arguments.
- CALL_FUNCTION_EX: Calls the original function with the arguments.
- STORE_FAST: Stores the result in a local variable.
After Calling the Function
- Similar to the first part, it calls print to output 'After calling the function'.
- Returning the Result
- Loads the result variable and returns it.

Conclusion
Python decorators are more than just function wrappers; they enable us to modify function behavior at definition time. By understanding how they work and examining the bytecode, we can use decorators more effectively in our projects.

That's it for now! If there’s anything else you’d like me to dive into, just let me know!

From Developer to Reviewer: A Junior Developer's Checklist for Reviewing Database Queries

Aman Giri — Sun, 08 Sep 2024 12:19:45 +0000

As a developer, it's crucial to deliver quality code that is not only functional but also optimized for performance. Over my three years in the developer domain, I transitioned from a hands-on developer to a reviewer role. One of the key areas I've focused on during reviews is database query optimization.

Why Focus on Database Queries?
Database queries can significantly impact the performance of an application. A well-written query can fetch data efficiently, while a poorly written one can lead to excessive database hits, slowing down the entire system. As a junior developer, you might wonder how to assess the performance of these queries during code reviews. Here's my go-to checklist.

Checklist for Reviewing Database Queries

Number of Database Hits:
- The first step is to determine how many database hits are being made by a piece of code. Each hit to the database can add latency, so fewer hits generally mean better performance.
- Pro Tip: Use Django’s connection.queries and reset_queries to track the number of queries executed and the time taken for each. For example:
Reducing the Number of Hits:
- Once you know the number of hits, the next step is to see if you can reduce them. Reducing database hits can often be achieved by optimizing the queries or combining multiple queries into one.
- Key Techniques:
  - Lazy vs. Eager Loading: Understand when a query is being evaluated. Lazy loading delays the query until the data is actually needed, but this can lead to the N+1 query problem. Eager loading, using select_related or prefetch_related, fetches related objects in a single query, reducing the total number of hits.
  - Joins: If you need data from related tables, consider using join queries. Django’s select_related (for foreign key relationships) and prefetch_related (for many-to-many or reverse foreign key relationships) are your friends here.
Avoiding Redundant Queries:
- Check for redundant queries, where the same query is executed multiple times. This can often be avoided by caching the result or restructuring the code.
- Example: Instead of querying for a related object inside a loop, fetch all related objects once before the loop.
Memory Considerations:
- While reducing database hits is important, also consider memory usage. Loading a massive dataset into memory can cause your application to slow down or crash. Aim to only pull in the records/data you need.

Conclusion
Reviewing database queries for performance is a skill that develops with time and experience. As a junior developer, start by focusing on the basics—counting database hits and finding ways to reduce them. Tools like connection.queries, reset_queries, and Django's ORM features are invaluable in this process. Over time, you'll develop an intuition for spotting performance issues just by looking at the code. Until then, rely on the tools and techniques discussed here to guide you.

Additional Tips:

Understand the Execution Plan: Dive deeper by understanding the SQL execution plan generated by your ORM queries. Tools like EXPLAIN in SQL can help you understand how your database engine is executing queries, which can provide insights into potential optimizations.

A Tip for Fresher Developers:
To start reviewing other people's code, you don't need to know every flow of the system. Begin by reviewing small things like code quality and optimization. Start by doing the first pass, focusing on the basics, and eventually, you will become a great reviewer.
Also, while reviewing, try to be polite and helpful in your comments rather than being arrogant. Remember, the goal is to improve the code and help your team, not just to point out mistakes.

DEV Community: Aman Giri

Understanding Python Decorators: A Deep Dive

From Developer to Reviewer: A Junior Developer's Checklist for Reviewing Database Queries