Python decorators are a feature of the language that allows the programmer to alter the behavior of a function or class at runtime and without having to use techniques such as subclassing.
For example, let’s assume I need to trace the code path over several functions. This is easily accomplished with a decorator:
def myTrace(f): def trace_func(): print "Entered", f.__name__ f() print "Exiting", f.__name__ return trace_func @myTrace def function1(): print "Inside Function1" function2() @myTrace def function2(): print "Inside Function2" function1()
The output of this script is:
Entered function1 Inside Function1 Entered function2 Inside Function2 Exiting function2 Exiting function1
Decorators in Python allow me to do more than just simple text substitution (C
macros). Decorators effectively replaced one function for another in the example
above. I can prove that there is actual substitution by adding the statement
print function1.__name__ to the end of the above script. What is
the current name of function1?
The more interesting thing that decorators allow me to do is to close over the parent scope of the decorator. Let’s look a this example:
def helloWorld(f): s = "World!" def new_func(): print f(), s return new_func @helloWorld def func(): return "Hello" func()
The output of the script above is Hello World!, but the only call is to
func() and that function does not print anything. This is because I substitute
func() for the
new_func() definition that I created inside the
decorator. The new definition is, for all intents and purposes, a closure,
because it encapsulates the context of the decorator and of
I can prove this theory: comment out the
@helloWorld decorator before the
func() definition and run the script again. What is the output now?