# source : https://python-course.eu/advanced-python/currying-in-python.php

# h(x) = g(f(x))

def compose(g, f):

def h(x):

return g(f(x))

return h

def celsius_fahrenheit(t):

return 1.8 * t + 32

def correct_error(t):

return 0.9 * t - 0.5

convert = compose(correct_error, celsius_fahrenheit)

print(convert(10), celsius_fahrenheit(10))

def compose(g, f):

def h(*args, **kwargs):

return g(f(*args, **kwargs))

return h

def calucate_bmi(weight, height):

return weight / height**2

def evaluate_bmi(bmi):

msg = 'Obese Class III (Very severely obese)'

if bmi < 15:

msg = 'Very severely underweight'

elif bmi < 16:

msg = 'Severely underweight'

elif bmi < 18.5:

msg = 'Underweight'

elif bmi < 25:

msg = 'Normal (healthy weight)'

elif bmi < 30:

msg = 'Overweight'

elif bmi < 35:

msg = 'Obese Class I (Moderately obese)'

elif bmi < 40:

msg = 'Obese Class II (Severely obese)'

return msg

bmi_calculator = compose(evaluate_bmi, calucate_bmi)

weight = 69 # in kg

height = 1.8 # in m

print(bmi_calculator(weight, height))

def summation(*args):

return sum(args)

def curry(func):

# to keep the name of the curried function:

curry.__curried_func_name__ = func.__name__

f_args, f_kwargs = [], {}

def f(*args, **kwargs):

nonlocal f_args, f_kwargs

if args or kwargs:

print("Calling curried function with:")

print("args: ", args, "kwargs: ", kwargs)

f_args += args

f_kwargs.update(kwargs)

print("Currying the values:")

print("f_args: ", f_args)

print("f_kwargs:", f_kwargs)

return f

else:

print("Calling " + curry.__curried_func_name__ + " with:")

print(f_args, f_kwargs)

result = func(*f_args, *f_kwargs)

f_args, f_kwargs = [], {}

return result

return f

curried_summation = curry(summation)

curried_summation(1)(2)(3)(4, 5)

# it will keep on currying:

# curried_arimean(6, 7)

print(curried_summation())

def add_world(wrapped_func):

def inner_func():

wrapped_func()

print('World')

return inner_func

@add_world

def hello():

print('Hello', end=' ')

hello()

"""

Here's the example of nested function aka decorators.

if you can guess the ouput you can guess the order of execution.

"""

def a(wrapped_func):

def inner(*args, **kwargs):

print('A')

wrapped_func()

return inner

def b(wrapped_func):

def inner(*args, **kwargs):

print('B')

wrapped_func('C')

return inner

@a

@b

def c(c=None):

print(c)

c()

def add(wrapped_func):

def inner(*args, **kwargs):

c = args[0] + args[1]

print('Adding value : {}, {}'.format(args[0], args[1]))

print('Result {}'.format(c))

return wrapped_func(c)

return inner

def sqaure(wrapped_func):

def inner(*args, **kwargs):

c = args[0] ** 2

print('Squaring : {}'.format(args[0]))

print('Result {}'.format(c))

return c

return inner

@add

@sqaure

def maths_on_numners(a= None, b = None):

pass

a, b = 6, 9

value = maths_on_numners(a, b)

out_msg = 'Value returned = {value}'

print(out_msg.format(value = value))

import time

cached = {}

def memo(wrapped_func):

def inner(n1, n2):

params = '{}{}'.format(n1, n2)

if params not in cached:

value = wrapped_func(n1, n2)

cached[params] = value

return value

return cached[params]

return inner

@memo

def calucate_sum(n1, n2):

_sum = 0

for i in range(n1, n2):

_sum += i

return _sum

start = time.time()

value = calucate_sum(1, 100000000)

end = time.time()

total_time = end - start

print('Before memo')

print('Value = {}, total time = {}'.format(value, total_time))

start = time.time()

value = calucate_sum(1, 100000000)

end = time.time()

total_time = end - start

print('\nAfter memo')

print('Value = {}, total time = {}'.format(value, total_time))