when a python function is decorated in which scopes is that decoration visible

Python function decorators are a powerful feature that allows you to modify or enhance the behavior of functions. When a function is decorated, the decorator is essentially a wrapper around the original function, and it can influence the function's behavior. Decorators are widely used in Python for various purposes, such as logging, authentication, and performance monitoring.
In this tutorial, we'll explore the visibility of decorators in different scopes and provide code examples to illustrate how decorators work.
Let's start by creating a simple decorator and decorating a function with it:
In the code above, the my_decorator function is defined and used to decorate the say_hello function. When you call say_hello(), the my_decorator function wraps around it, adding behavior before and after the original function. The output will be:
Decorators are visible in the scope where they are defined. In the example above, my_decorator is defined at the module level, making it visible globally throughout the module. This means you can use the @my_decorator syntax to decorate any function defined within the same module.
Let's see what happens when we use the decorator in a different module:
module1.py:
module2.py:
In this case, we import the my_decorator function from module1 and use it to decorate the say_goodbye function in module2. When you run say_goodbye() in module2.py, the output will be:
This demonstrates that decorators can be defined in one module and used to decorate functions in another module.
Decorators can also be defined within a function, and they will be visible only within that function's scope. This is less common but can be useful in certain cases: