Primer on Python Decorators
by:
blow post content copied from Real Python
click here to view original post
In this tutorial on Python decorators, you’ll learn what they are and how to create and use them. Decorators provide a simple syntax for calling higher-order functions.
By definition, a decorator is a function that takes another function and extends the behavior of the latter function without explicitly modifying it. This sounds confusing, but it’ll make more sense after you’ve seen a few examples of how decorators work.
In this tutorial, you’ll learn:
- What it means for functions to be first-class objects
- How to define functions so they can be used as decorators
- Which practical use cases can be tackled with decorators
- How to create decorators so that they follow best practices
You can find all the examples from this tutorial by downloading the accompanying materials below:
Get Your Code: Click here to download the free sample code that shows you how to create and use Python decorators.
Free Bonus: Click here to get access to a free "The Power of Python Decorators" guide that shows you three advanced decorator patterns and techniques you can use to write cleaner and more Pythonic programs.
Decorators Cheat Sheet: Click here to get access to a free three-page Python decorators cheat sheet that summarizes the techniques explained in this tutorial.
Decorators Q&A Transcript: Click here to get access to a 25-page chat log from our Python decorators Q&A session in the Real Python Community Slack where we discussed common decorator questions.
Take the Quiz: Test your knowledge with our interactive “Decorators” quiz. Upon completion you will receive a score so you can track your learning progress over time:
Python Functions
In order to understand decorators, you must first understand some finer points of how functions work. There are many aspects to functions, but in the context of decorators, a function returns a value based on the given arguments. Here’s a basic example:
>>> def add_one(number):
... return number + 1
...
>>> add_one(2)
3
In general, functions in Python may also have side effects rather than just turning an input into an output. The print()
function is an example of this: it returns None
while having the side effect of outputting something to the console. However, to understand decorators, it’s enough to think about functions as tools that turn given arguments into values.
First-Class Objects
In functional programming, you work almost entirely with pure functions that don’t have side effects. While not a purely functional language, Python supports many functional programming concepts, including treating functions as first-class objects.
This means that functions can be passed around and used as arguments, just like any other object like str
, int
, float
, list
, and so on. Consider the following three functions:
greeters.py
def say_hello(name):
return f"Hello {name}"
def be_awesome(name):
return f"Yo {name}, together we're the awesomest!"
def greet_bob(greeter_func):
return greeter_func("Bob")
Here, say_hello()
and be_awesome()
are regular functions that expect a name given as a string. The greet_bob()
function, however, expects a function as its argument. You can, for example, pass it the say_hello()
or the be_awesome()
function.
To test your functions, you can run your code in interactive mode. You do this with the -i
flag. For example, if your code is in a file named greeters.py
, then you run python -i greeters.py
:
>>> greet_bob(say_hello)
'Hello Bob'
>>> greet_bob(be_awesome)
'Yo Bob, together we're the awesomest!'
Note that greet_bob(say_hello)
refers to two functions, but in different ways: greet_bob()
and say_hello
. The say_hello
function is named without parentheses. This means that only a reference to the function is passed. The function isn’t executed. The greet_bob()
function, on the other hand, is written with parentheses, so it will be called as usual.
This is an important distinction that’s crucial for how functions work as first-class objects. A function name without parentheses is a reference to a function, while a function name with trailing parentheses calls the function and refers to its return value.
Inner Functions
It’s possible to define functions inside other functions. Such functions are called inner functions. Here’s an example of a function with two inner functions:
Read the full article at https://realpython.com/primer-on-python-decorators/ »
[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]
February 12, 2024 at 07:30PM
Click here for more details...
=============================
The original post is available in Real Python by
this post has been published as it is through automation. Automation script brings all the top bloggers post under a single umbrella.
The purpose of this blog, Follow the top Salesforce bloggers and collect all blogs in a single place through automation.
============================
![Salesforce Salesforce](https://1.bp.blogspot.com/-7PAEudGm-vA/X5xmpBCB6-I/AAAAAAAAACU/4l5vI_EgYqYlEXFHs1xEeyiYP9Dyl89IgCLcBGAsYHQ/s600/1.jpg)
Post a Comment