Topic 2: Metaprogramming and Decorators


Metaprogramming refers to the practice of writing code that can inspect, generate, or modify itself or other parts of the program. It’s like “code that manipulates code”. One of the most common metaprogramming tools in Python is the decorator.

Metaprogramming in Python

Python is inherently reflective, meaning the language has built-in capacities to inspect and modify its structure and behavior. Some tools and aspects of this include:

  1. Reflection: The capability for a program to inspect its structure. In Python, this includes functions like getattr(), setattr(), and hasattr().
  2. Introspection: Extends reflection by allowing the program to analyze its internal state. Functions such as type(), id(), and dir() provide introspective capabilities.
  3. Meta-classes: These are classes of classes, defining how a class behaves. It’s a deeper aspect of metaprogramming often reserved for more complex use cases.


Decorators in Python provide a very handy way to add functionality or modify behavior of functions or classes without changing their code. They are a form of metaprogramming because they modify the behavior of functions and methods at the time they are defined.

Basic Decorator

Here’s a simple decorator example:

def simple_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 @simple_decorator def say_hello(): print("Hello!") say_hello()

When say_hello() is called, the output will be:

Something is happening before the function is called. Hello! Something is happening after the function is called.

The @simple_decorator is a shorthand for: say_hello = simple_decorator(say_hello).

Decorators with Arguments

Sometimes, it’s beneficial to pass arguments to decorators:

def repeat(num_times): def decorator_repeat(func): def wrapper(*args, **kwargs): for _ in range(num_times): result = func(*args, **kwargs) return result return wrapper return decorator_repeat @repeat(num_times=3) def greet(name): print(f"Hello {name}") greet("Alice")

The output will be:

Hello Alice Hello Alice Hello Alice

Built-in Decorators

Python has several built-in decorators:

  • @staticmethod: Indicates a static method in a class, which doesn’t access or modify the class state.
  • @classmethod: Indicates a class method, which can’t modify the object state but can modify the class state.
  • @property: Used to get the value of a private attribute without any change.

Advantages and Drawbacks


  1. Code Reusability: Decorators allow us to apply the same functionality across multiple functions or methods.
  2. Code Organization: They can lead to cleaner, more readable code by abstracting away boilerplate.


  1. Complexity: For beginners, decorators can seem like magic and be hard to debug.
  2. Performance Overhead: Decorators introduce a layer of indirection which might add slight overhead.


Metaprogramming, and particularly the use of decorators, is a powerful tool in the Python programmer’s toolkit. It enables dynamic modifications and extensions of code behavior, leading to more reusable and concise code. However, like all tools, it should be used judiciously to ensure code maintainability and clarity.