python use output from one function in other functions without calling all the other functions

Question

I have one core function that I call from many of the other functions in my script. Problem is that I do not want each function when it calls the core function to run it. Is there a way of storing the output of the core function so that when its called for the second, third time etc its not run?

E.g.

def core_func(a,b,c):
  do something....
  return x,y,z

def func2(a,b,c):
  x,y,z = core_func(a,b,c)
  do something with x,y,z

def func3(a,b,c):
  x,y,z = core_func(a,b,c)
  do something with x,y,z

etc..

func3 here would call core_func again after func2 has called it. How can I prevent that but at the same time use core_func output? A possible solution maybe return the outputs from func2 and use in func3 (but this would get a bit ugly).

Thanks

Callam Delaney · Accepted Answer · 2016-04-25 14:40:15Z

7

variable = core_func(arguments)

func2(variable)

func3(variable)

Store the results of the function in a variable!

edited Apr 25, 2016 at 14:40

answered Apr 25, 2016 at 14:25

Callam Delaney

6583 silver badges15 bronze badges

Sign up to request clarification or add additional context in comments.

Comments

dfranca · Accepted Answer · 2016-04-25 15:11:15Z

5

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

edited Apr 25, 2016 at 15:11

answered Apr 25, 2016 at 14:26

dfranca

5,3622 gold badges36 silver badges65 bronze badges

3 Comments

Bryan Oakley Over a year ago

This answer would be better if you showed an actual example

dfranca Over a year ago

@BryanOakley done, just added examples and a better explanation. Thanks for the feedback.

Callam Delaney Over a year ago

Never knew you could do this. Pretty cool if your function has a large overhead.

Collectives™ on Stack Overflow

python use output from one function in other functions without calling all the other functions

2 Answers 2

Comments

3 Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

Comments

3 Comments

Your Answer

Sign up or log in

Post as a guest

Related