In Python, decorators are functions or classes that wrap around a function as a wrapper by taking a function as input and returning out a callable. They allow the creation of reusable building code blocks that can either change or extend behavior of other functions.

Conditional Decorators

Given a condition, the idea here is to execute code or basically wrap a function using a decorator if a certain condition is met or true. There are two ways by which we can use a decorator conditionally.

In Python, a decorator is a special type of function that can modify the behavior of another function. Decorators are used to add functionality to an existing function without modifying its source code. One type of decorator is a conditional decorator, which allows for the addition of conditional statements to a function.

Conditional decorators are defined in the same way as regular decorators, but they include a conditional statement that determines whether or not the decorated function will be executed. For example, let's say we have a function that prints a message to the console: 

def print_message():
    print("Hello, world!")

We can create a conditional decorator that only executes the function if a certain condition is met, like so: 

def execute_if(condition):
    def decorator(func):
        def wrapper():
            if condition:
                func()
        return wrapper
    return decorator

@execute_if(3 > 2)
def print_message():
    print("Hello, world!")

In this example, the execute_if decorator takes a condition as its argument and returns another decorator that modifies the behavior of the decorated function. The wrapper function within the decorator contains the conditional statement that determines whether or not the decorated function is executed.

When the print_message function is decorated with @execute_if(3 > 2), it will only be executed if the condition 3 > 2 evaluates to True. If the condition is False, the function will not be executed.

Overall, conditional decorators provide a flexible way to add conditional behavior to existing functions in Python.