You can use memoize
Caches a function's return value each time it is called.
So, every time you call the function with the same parameters you'll get the return value without the computing time
i.e:
If you're using Python2 you need to implement it, you can have a look how it's implemented on the link above and then apply it to your function:
class memoized(object):
'''Decorator. Caches a function's return value each time it is called.
If called later with the same arguments, the cached value is returned
(not reevaluated).
'''
def __init__(self, func):
self.func = func
self.cache = {}
def __call__(self, *args):
if not isinstance(args, collections.Hashable):
# uncacheable. a list, for instance.
# better to not cache than blow up.
return self.func(*args)
if args in self.cache:
return self.cache[args]
else:
value = self.func(*args)
self.cache[args] = value
return value
def __repr__(self):
'''Return the function's docstring.'''
return self.func.__doc__
def __get__(self, obj, objtype):
'''Support instance methods.'''
return functools.partial(self.__call__, obj)
@memoized
def core_func(a, b, c):
do something....
return x,y,z
If you're using Python3 you've it for free with the lru_cache decorator
Decorator to wrap a function with a memoizing callable that saves up
to the maxsize most recent calls. It can save time when an expensive
or I/O bound function is periodically called with the same arguments.
from functools import lru_cache
@lru_cache(maxsize=32)
def core_func(a, b, c):
do something....
return x,y,z
