Memoisation in Python
The subject was discovered in 1968 by a bearded man.This bearded man's name is Donald Michie. The root of the word comes from the Latin meaning
"memorandum" and means "
Remembering, remembering something".Memoization is a technique for speeding up program flow.With this process, you can store-save the resulting ones after obtaining them. For example, in function calls, you will understand more easily with the examples I will give.For example, let's say you call a function again with the same parameters, instead of recalculating it, it calculates it over the value it saves in memory.You're going to need this technique so much that you're going to need it in more complicated situations and when you're officially working with a company.Memoization can be explicitly encoded by the programmer, but languages such as Python have mechanisms to facilitate the implementation of memoization.
In the previous location Rekursion() I defined 1 iterative 1 rekursive function, to calculate fibonacci numbers.
Python:
def fib(n):
Python:
if n == 0:
return 0
elif n == 1:
return 1
else: return fib(n-1) + fib(n-2)We're here to see how we can speed up our function with rekursion. In memoization, the function appears in the process and is in a kind of memory to make it faster in subsequent calls.It was, to be, an anclinity about how to use the Memoization technique, but we didn't name it that way.The only downside to this carving is that it causes the Rekursion process to lose its clarity and beauty.The code in the assa does not change our FIB function, so its readability and clarity are not affected.For this purpose, we use a forensic function of memoize() 2 argumans. Then we create a memo forensic dispute to record our value.Let's introduce him as a helper and let him freeze the value for us.When we call this function in the form of memoize (fib), it gives us the intrusions and intrusions in our fib function.
Python:
def memoize(f):
Python:
[B] memo = {}
def helper(x):
if x not in memo:
memo[x] = f(x)
return memo[x]
return helper
def fib(n):
if n == 0:
return 0
elif n == 1:
return 1
else:
return fib(n-1) + fib(n-2)
fib = memoize(fib)
print(fib(40))[/B]Yes, we see here that our FIB function is decorated by Memoization.
Of course, we can create a class and freeze the result from there and record it as an example;
Python:
class Memoize:
Python:
[B] def __init__(self, fn):
self.fn = fn
self.memo = {}
def __call__(self, *args):
if args not in self.memo:
self.memo[args] = self.fn(*args)
return self.memo[args][/B]important note ;
We used a lynration here, we can't use a normal mutable arguman.We can only use immutable argumans like Tupel.
Decorateure Python ;
Our real objects, that is, objects to be changed, are given as argumans. The décorateur freezes the modified object back.In other words, an unmodified function of the example is replaced by the name of the other object that has been modified.Python Decoratateure's Syntax is like java. Python's description seems to bounce back on this topic by using @ .I mentioned a lot of décor, but I couldn't say it, and I guess I didn't say that the "def memoize(f):" function was The Decorator in the example memoization I gave at the beginning of this article.
But we didn't use Python's Decoratateur-Syntax on that ore, the @sign.
Python:
fib = memoize(fib)We can use simplified water usage ;
Python:
@memoizeHowever, this command should be used before the function to be decorated!
And as we come to the end of the writing, let's assign the complete version of our fib function;
Python:
def memoize(f):
Python:
[B] memo = {}
def helper(x):
if x not in memo:
memo[x] = f(x)
return memo[x]
return helper
@memoize
def fib(n):
if n == 0:
return 0
elif n == 1:
return 1
else:
return fib(n-1) + fib(n-2)
#fib = memoize(fib)
print(fib(40))[/B]Before I forget, the function should not be commoted by negative, float numbers, if you call it, you can put it in infinite frost.Yes, now let's test whether the number is Positiv and calculate the exact number of factors to make our subject.But decorated with
Python:
def arguman_dogal_sayi_testi(f):
Python:
[B] def helper(x):
if type(x) == int and x > 0:
return f(x)
else:
raise Exception("Arguman integer degil")
return helper
@arguman_dogal_sayi_testi
def factorial(n):
if n == 1:
return 1
else:
return n * factorial(n-1)
for i in range(1,10):
print(i, factorial(i))
print(factorial(-1))[/B]Source : Memoisation, decoration() Python.
