Search for a command to run...
I am a developer by heart. Love programming and problem solving. and love to share whatever I learn. Feel free to contact me or follow on Twitter. I tweet about Programming, MEMEs, Quotes, Books etc. I also make youtube video related to programming and tutorials. checkout my channel also "a little coding"
No comments yet. Be the first to comment.
Let's discuss pros and cons of starting with javascript, python or c
These are useful apps that I actually use. Not any fancy apps.I have installed all these apps on my new mac mini M1. 1. Brave Main feature: ad blocker. Especially for youtube. I consume a lot of youtube videos, so it's really useful for me. Also, it'...
Here's how we can use a private AWS s3 bucket with Strapi with the help of CloudFront
Show the latest followers on your Twitter header
Put simply: Decorators wrap a function, modifying its behavior.
A simple decorator example:
def my_decorator(function):
def wrapper():
print("Something is happening before the function is called.")
function()
# do other stuff
print("Something is happening after the function is called.")
return wrapper
In this example, this decorator is changing the function's behavior by doing extra stuff before and after the function call.
There are mainly two ways we can use the above decorator.
Method 1:
def say_whee():
print("Whee!")
my_decorator(say_whee)
Method 2:
@my_decorator
def say_whee():
print("Whee!")
We will use the 2nd method in upcoming examples as it’s more readable.
Example use:
we can use a decorator to add logs before and after the execution of functions.
we can use a decorator to calculate and print the execution time of functions.
Decorator for function with return value:
def my_decorator(function):
def wrapper():
print("Something is happening before the function is called.")
value = function()
# do other stuff
print("Something is happening after the function is called.", value)
return value
return wrapper
Notice that we have just added the return value we got from calling the function.
Example use:
@my_decorator
def say_whee():
print("Whee!")
return 100
Decorator for function with arguments:
def my_decorator(func):
def wrapper(*args, **kwargs):
return func(*args, **kwargs)
return wrapper
@my_decorator
def say_whee(name):
print("Hello, " + name)
return 100
Passing arguments to the decorator:
def exception_handler(except_returns=None): # for multiple values pass in tuple e.g (value1, value2)
def decorator(function):
@wraps(function)
def wrapper(*args, **kwargs):
try:
return function(*args, **kwargs)
except Exception as e:
exc_type, exc_value, exc_traceback = sys.exc_info()
message = f"Exception in {function.__name__}, {exc_value}"
print(message)
return except_returns
return wrapper
return decorator
Notice that we are accepting values in the except_returns argument. The idea is to use this value when an exception occurs.
Technical Detail: The @functools.wraps decorator uses the function functools.update_wrapper()
to update special attributes like __name__ and __doc__ that are used in the introspection.
Use:
@exception_handler(0)
def function_with_exception(value, val2, val3):
print(a) # a is not defined
return 100
value = function_with_exception(1, 2, 3) # this will return 0
This article is a simplified version of these sources:
For ref: https://realpython.com/primer-on-python-decorators/#decorators-with-arguments
Class decorators: https://stackoverflow.com/a/9647491
decorators with args: https://stackoverflow.com/questions/5929107/decorators-with-parameters