Decorators

Author: Shikha-code36

08.Decorators/decorators-1.py

@@ -0,0 +1,53 @@
+#decorators-1.py
+# Decorators, as simple as it gets :)
+
+# Decorators are functions that compliment other functions,
+# or in other words, modify a function or method.
+
+# In the example below, we have a function named `decorated`.
+# This function just prints "This happened".
+# We have a decorator created named `inner_decorator()`.
+# This decorator function has an function within, which
+# does some operations (print stuff for simplicity) and then
+# returns the return-value of the internal function.
+
+# How does it work?
+# a) The function `decorated()` gets called.
+# b) Since the decorator `@my_decorator` is defined above
+# `decorated()`, `my_decorator()` gets called.
+# c) my_decorator() takes a function name as args, and hence `decorated()`
+# gets passed as the arg.
+# d) `my_decorator()` does it's job, and when it reaches `myfunction()`
+# calls the actual function, ie.. decorated()
+# e) Once the function `decorated()` is done, it gets back to `my_decorator()`.
+# f) Hence, using a decorator can drastically change the behavior of the
+# function you're actually executing.
+
+
+def my_decorator(my_function):  # <-- (4)
+    def inner_decorator():  # <-- (5)
+        print("This happened before!")  # <-- (6)
+        my_function()  # <-- (7)
+        print("This happens after ")  # <-- (10)
+        print("This happened at the end!")  # <-- (11)
+
+    return inner_decorator
+    # return None
+
+
+@my_decorator  # <-- (3)
+def decorated():  # <-- (2) <-- (8)
+    print("This happened!")  # <-- (9)
+
+
+if __name__ == "__main__":
+    decorated()  # <-- (1)
+
+
+'''
+O/P-
+This happened before!
+This happened!
+This happens after 
+This happened at the end!
+'''

08.Decorators/decorators-2.py

@@ -0,0 +1,33 @@
+# decorators-2.py
+# An updated version of decorators-1.py
+
+# This code snippet takes the previous example, and add a bit more information
+# to the output.
+
+import datetime
+
+
+def my_decorator(inner):
+    def inner_decorator():
+        print(datetime.datetime.utcnow())
+        inner()
+        print(datetime.datetime.utcnow())
+
+    return inner_decorator
+
+
+@my_decorator
+def decorated():
+    print("This happened!")
+
+
+if __name__ == "__main__":
+    decorated()
+
+'''
+O/P: (NOTE: The time will change of course :P)
+
+2022-07-16 12:24:18.704572
+This happened!
+2022-07-16 12:24:18.704572
+'''

08.Decorators/decorators-3.py

@@ -0,0 +1,35 @@
+# This is an updated version of decorators-2.py.
+# Here, the `decorated()` function takes an argument
+# and prints it back on terminal.
+
+# When the decorator `@my_decorator` is called, it
+# takes the function `decorated()` as its argument, and
+# the argument of `decorated()` as the argument of `inner_decorator()`.
+# Hence the arg `number` is passed to `num_copy`.
+
+import datetime
+
+
+def my_decorator(inner):
+    def inner_decorator(num_copy):
+        print(datetime.datetime.utcnow())
+        inner(int(num_copy) + 1)
+        print(datetime.datetime.utcnow())
+
+    return inner_decorator
+
+
+@my_decorator
+def decorated(number):
+    print("This happened : " + str(number))
+
+
+if __name__ == "__main__":
+    decorated(5)
+
+'''
+O/P-
+2022-07-16 12:26:14.060603
+This happened : 6
+2022-07-16 12:26:14.060603
+'''

08.Decorators/decorators-4.py

@@ -0,0 +1,30 @@
+#decorators-4.py
+
+# This example builds on the previous decorator examples.
+# The previous example, decorators-3.py showed how to
+# deal with one argument passed to the function.
+
+# This example shows how we can deal with multiple args.
+
+# Reminder : `args` is a list of arguments passed, while
+# kwargs is a dictionary passed as arguments.
+
+
+def decorator(inner):
+    def inner_decorator(*args, **kwargs):
+        print(args, kwargs)
+
+    return inner_decorator
+
+
+@decorator
+def decorated(string_args):
+    print("This happened : " + string_args)
+
+
+if __name__ == "__main__":
+    decorated("Hello, how are you?")
+
+# This prints :
+# # python 22-decorators-4.py
+# ('Hello, how are you?',)

08.Decorators/decorators-5.py

@@ -0,0 +1,30 @@
+#decorators-5.py
+
+
+from __future__ import print_function
+
+
+# 2. Decorator function
+def handle_exceptions(func_name):
+    def inner(*args, **kwargs):
+        try:
+            return func_name(*args, **kwargs)
+        except Exception:
+            print("An exception was thrown : ", Exception)
+
+    return inner
+
+
+# 1. Main function
+@handle_exceptions
+def divide(x, y):
+    return x / y
+
+
+print(divide(8, 0))
+
+'''
+O/P-
+An exception was thrown :  <class 'Exception'>
+None
+'''

08.Decorators/decorators-6.py

@@ -0,0 +1,30 @@
+
+def decorator(inner):
+    def inner_decorator(*args, **kwargs):
+        print("This function takes " + str(len(args)) + " arguments")
+        inner(*args)
+
+    return inner_decorator
+
+
+@decorator
+def decorated(string_args):
+    print("This happened: " + str(string_args))
+
+
+@decorator
+def alsoDecorated(num1, num2):
+    print("Sum of " + str(num1) + "and" + str(num2) + ": " + str(num1 + num2))
+
+
+if __name__ == "__main__":
+    decorated("Hello")
+    alsoDecorated(1, 2)
+
+'''
+O/P-
+This function takes 1 arguments
+This happened: Hello
+This function takes 2 arguments
+Sum of 1and2: 3
+'''

08.Decorators/decorators-7.py

@@ -0,0 +1,29 @@
+#decorators-7.py
+
+# We have two functions, one which adds two numbers,
+# and another which subtracts two numbers.
+
+# We apply the decorator @double which takes in the
+# functions that is called with the decorator, and doubles
+# the output of the respective function.
+
+
+def double(my_func):
+    def inner_func(a, b):
+        return 2 * my_func(a, b)
+
+    return inner_func
+
+
+@double
+def adder(a, b):
+    return a + b
+
+
+@double
+def subtractor(a, b):
+    return a - b
+
+
+print(adder(5, 6)) #22
+print(subtractor(8, 2)) #12

08.Decorators/decorators-class.py

@@ -0,0 +1,36 @@
+#class-decorators.py
+
+# Till the previous examples, we saw function decorators.
+# But decorators can be applied to Classes as well.
+# This example deals with class decorators.
+
+# NOTE: If you are creating a decorator for a class, you'll it
+# to return a Class.
+
+# NOTE: Similarly, if you are creating a decorator for a function,
+# you'll need it to return a function.
+
+
+def honirific(cls):
+    class HonirificCls(cls):
+        def full_name(self):
+            return "Ms." + super(HonirificCls, self).full_name()
+
+    return HonirificCls
+
+
+@honirific
+class Name(object):
+    def __init__(self, first_name, last_name):
+        self.first_name = first_name
+        self.last_name = last_name
+
+    def full_name(self):
+        return " ".join([self.first_name, self.last_name])
+
+
+result = Name("Shikha", "Pandey").full_name()
+print("Full name: {0}".format(result))
+
+#Full name: Ms.Shikha Pandey
+# This needs further check. Erroring out.

README.md

@@ -8,6 +8,7 @@
 05. [Inheritance](https://github.com/Shikha-code36/Object-Oriented-Programming-OOPs-Python#05-inheritance)
 06. [Encapsulation](https://github.com/Shikha-code36/Object-Oriented-Programming-OOPs-Python#06-encapsulation)
 07. [Polymorphism](https://github.com/Shikha-code36/Object-Oriented-Programming-OOPs-Python#07-polymorphism)
+08. [Decorators](https://github.com/Shikha-code36/Object-Oriented-Programming-OOPs-Python#08-decorators)
 
 ------------
 ## What do you understand by OOPs?
@@ -149,4 +150,15 @@ Polymorphism in python defines methods in the child class that have the same nam
 
 [Detailed Explanation](07.Polymorphism)
 
+------------
+------------
+#### 08. Decorators
+
+A decorator takes in a function, adds some functionality and returns it.
+Decorators are used to add functionality to an existing code.
+
+This is also called metaprogramming because a part of the program tries to modify another part of the program at compile time.
+
+[Detailed Explanation](08.Decorators)
+
 ------------