Working With Decorators In Python

Abe Garcia — Thu, 30 May 2019 23:58:33 +0000

In my last post, I wrote about functional closures in Python and I mentioned that the most interesting thing about them is that they can be used to create decorators. And they do just that, they decorate existing functions with additional functionality, and they're also reusable so they can be applied to multiple different functions at once.

Decorators Defined

A decorator is essentially a higher order function that both accepts a function as an argument and also returns a function. The result is a function that has the same functionality as the one you passed into the decorator along with whatever extra functionality you defined within the decorator body. This is best explained through a code example:

def example_func():
    print("I'm a function!")

def decorator(func):
    def inner():
        func()
        print("I've been decorated!")
    return inner

Now we can say:

decorated_func = decorator(example_func)
decorated_func()

Now if we run the program, the output will be:

I'm a function!
I've been decorated!

Decorators actually have a cool bit of syntactic sugar where instead of typing this:

decorated_func = decorator(example_func)
decorated_func()

We can just add @decorator above the decorated function's definition like so:

@decorator
def example_func():
    print("I'm a function!")

Now if you call example_func(), the output will be the same as it was previously.

Decorating A Function That Takes Arguments

Decorators can also be applied to a function that takes in parameters, and the decorator will actually have access to any parameters passed into the decorated function.

Take this function:

def capitalize_first_name(func):
    def wrapper(first_name,last_name):
        capitalized = first_name.upper()
        func(capitalized,last_name)
    return wrapper

@capitalize_first_name
def print_name(first_name,last_name):
    print(f"Hi, my name is {first_name} {last_name}")

Now, for example, if we say print_name("John", "Doe"),
the output will be Hi, my name is JOHN Doe! without us ever having to alter the original function.

And you don't always need to have the same number of arguments for a decorator to work; you can pass the *args operator into the wrapper and be able to work with any function with any number of arguments!

Conclusion

Decorators are, in my opinion, one of the coolest features that Python has to offer. You don't always have a good reason to use them, and you probably shouldn't unless you actually have to, but they can be incredibly useful when the situation calls for them. Decorators are highly used in web frameworks like Flask and Django to add HTTP routing functionality, authentication, and more.

Understanding Functional Closures

Abe Garcia — Thu, 09 May 2019 19:58:10 +0000

While learning functional programming in JavaScript and Python, one of the hardest concepts to wrap my head around was the idea of closures. Every explanation I found only served to confuse me more so I decided to write a clear explanation with real code examples.

What Is A Closure?

Inner Functions

The first step to understanding closures is understanding inner functions, i.e., a function declared within another function.

def outer():
    x = 3
    def inner():
        print(x+5)
    inner()

outer() #prints 8 to the console

If we call the function outer(), we can see that it prints out 8. This is because the inner function has access to the variable x, which is in its enclosing scope. So the flow here is outer begins execution and sets the variable x equal to three. The next thing it does is define a function within itself which will print the result of adding 5 to x. It then executes the inner function and returns control to the main program.

Returning The Inner Function

The interesting part happens when we return the inner function from the outer function instead of calling it.

def outer():
    x = 3
    def inner():
        print(x+5)
    return inner

result = outer()  #here we save the returned value of the outer function to a variable

If you were to then print the result variable, this is what gets printed to the console:

<function inner at 0x7f5e8c381668>

Interestingly, we now have a function object assigned to our result variable, which means we can actually call it by adding parentheses to it.
If we call our new result() function, we can see that it still prints out 8. This means that our result function actually remembered what was inside its enclosing scope (the outer function) even though the outer function finished execution long before we ever called our result function. And that's exactly what a closure is! It's the recalling of a variable declared in an enclosing scope even when the program execution has moved on and is no longer in that scope. You could even use the 'del' keyword to delete the outer function and everything inside it, but our result function would still remember the value of x.

Why Use A Closure?

Using a closure can create some form of data privacy, since the main program has no access to anything declared inside the outer function. The only things that could have access to those variables are any functions defined inside the outer function itself. If you're a Python developer though, the most interesting application of closures by far is the concept of decorators.

DEV Community: Abe Garcia