#using decorators to add or modify class methods

class MyClass:

    def __init__(self):

        self._x = None

​

    @property

    def x(self):

        """I'm the 'x' property."""

        return self._x

​

    @x.setter

    def x(self, value):

        self._x = value

​

    @x.deleter

    def x(self):

        del self._x

​

### Decorators: Decorators are nothing but nested functions, where the parent function 

### takes only a function as input and the child function modifies the behavior of input function

import time

from functools import wraps

def decorator(func):

    """A decorator that prints how long a function took to run."""

    # Use @wraps to bind function's meta data like docstring / function name etc

    @wraps(func)

    # Define the wrapper function to return.

    def changed_func(*args, **kwargs):

        t_start = time.time()

        # Call the decorated function and store the result.

        result = func(*args, **kwargs)

        t_total = time.time() - t_start

        print('{} took {}s'.format(func.__name__, t_total))

        return result

    return changed_func

​

@decorator

def sleep_n_seconds(n):

    time.sleep(n)

​

sleep_n_seconds(5) # 5.00001

​

########################

### Decorator Factory: An outermost function that wraps around a decorator and takes argument for 

### the decorator since the decorator itself cannot take any argument other than a single function

​

from functools import wraps

# an outer function that takes argument

def decorator_factory(n):

    """Define and return a decorator"""

    def decorator(func):

        @wraps(func)

        def changed_func(*args, **kwargs):

            for i in range(n):

                func(*args, **kwargs)

        return changed_func

    return decorator

​

run_three_times = decorator_factory(3)

@run_three_times

def print_sum(a, b):

    print(a + b)

​

@decorator_factory(3)

def print_sum(a, b):

    print(a + b)

def deco(function):

    def wrap(num):

        if num % 2 == 0:

            print(num,"is even ")

        else:

            print(num,"is odd")

        function(num)

    return wrap

@deco

def display(num):

    return num

display(9)   # pass any number to check whether number is even or odd

# this functon converts any string into uppercase

def deco(function):

    def wrap(s):

        return s.upper()

        function(s)

    return wrap

​

@deco

def display(s):

    return s 

print(display("not bad"))

from functools import wraps

​

def logit(func):

    @wraps(func)

    def with_logging(*args, **kwargs):

        print(func.__name__ + " was called")

        return func(*args, **kwargs)

    return with_logging

​

@logit

def addition_func(x):

   """Do some math."""

   return x + x

​

​

result = addition_func(4)

# Output: addition_func was called

​

from functools import wraps

​

def logit(logfile='out.log'):

    def logging_decorator(func):

        @wraps(func)

        def wrapped_function(*args, **kwargs):

            log_string = func.__name__ + " was called"

            print(log_string)

            # Open the logfile and append

            with open(logfile, 'a') as opened_file:

                # Now we log to the specified logfile

                opened_file.write(log_string + '\n')

            return func(*args, **kwargs)

        return wrapped_function

    return logging_decorator

​

@logit()

def myfunc1():

    pass

​

myfunc1()

# Output: myfunc1 was called

# A file called out.log now exists, with the above string

​

@logit(logfile='func2.log')

def myfunc2():

    pass

​

myfunc2()

# Output: myfunc2 was called

# A file called func2.log now exists, with the above string

​

class ClassHolder:

    def __init__(self):

        self.classes = {}

​

    def add_class(self, c):

        self.classes[c.__name__] = c

​

    # -- the decorator

    def held(self, c):

        self.add_class(c)

​

        # Decorators have to return the function/class passed (or a modified variant thereof), however I'd rather do this separately than retroactively change add_class, so.

        # "held" is more succint, anyway.

        return c 

​

    def __getitem__(self, n):

        return self.classes[n]

​

food_types = ClassHolder()

​

@food_types.held

class bacon:

    taste = "salty"

​

@food_types.held

class chocolate:

    taste = "sweet"

​

@food_types.held

class tee:

    taste = "bitter" # coffee, ftw ;)

​

@food_types.held

class lemon:

    taste = "sour"

​

print(food_types['bacon'].taste) # No manual add_class needed! :D

>>> from functools import wraps

>>> def my_decorator(f):

...     @wraps(f)

...     def wrapper(*args, **kwds):

...         print('Calling decorated function')

...         return f(*args, **kwds)

...     return wrapper

...

>>> @my_decorator

... def example():

...     """Docstring"""

...     print('Called example function')

...

>>> example()

Calling decorated function

Called example function

>>> example.__name__

'example'

>>> example.__doc__

'Docstring'

# decorator function to convert to lowercase

def lowercase_decorator(function):

   def wrapper():

       func = function()

       string_lowercase = func.lower()

       return string_lowercase

   return wrapper

# decorator function to split words

def splitter_decorator(function):

   def wrapper():

       func = function()

       string_split = func.split()

       return string_split

   return wrapper

@splitter_decorator # this is executed next

@lowercase_decorator # this is executed first

def hello():

   return 'Hello World'

hello()   # output => [ 'hello' , 'world' ]

# decorator function to convert to lowercase

def lowercase_decorator(function):

   def wrapper():

       func = function()

       string_lowercase = func.lower()

       return string_lowercase

   return wrapper

# decorator function to split words

def splitter_decorator(function):

   def wrapper():

       func = function()

       string_split = func.split()

       return string_split

   return wrapper

@splitter_decorator # this is executed next

@lowercase_decorator # this is executed first

def hello():

   return 'Hello World'

hello()   # output => [ 'hello' , 'world' ]

from functools import wraps

​

def a_new_decorator(a_func):

    @wraps(a_func)

    def wrapTheFunction():

        print("I am doing some boring work before executing a_func()")

        a_func()

        print("I am doing some boring work after executing a_func()")

    return wrapTheFunction

​

@a_new_decorator

def a_function_requiring_decoration():

    """Hey yo! Decorate me!"""

    print("I am the function which needs some decoration to "

          "remove my foul smell")

​

print(a_function_requiring_decoration.__name__)

# Output: a_function_requiring_decoration