Python verwenden Ausgabe von einer Funktion in anderen Funktionen, ohne alle anderen Funktionen aufzurufen

Question

Ich habe eine Kernfunktion, die ich von vielen anderen Funktionen in meinem Skript aufrufen. Problem ist, dass ich nicht jede Funktion möchte, wenn sie die Kernfunktion aufruft, um sie auszuführen. Gibt es eine Möglichkeit, die Ausgabe der Kernfunktion so zu speichern, dass sie, wenn sie zum zweiten, dritten Mal usw. aufgerufen wird, nicht läuft?

z.

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 hier nennen würde wieder core_func nach func2 es genannt hat. Wie kann ich das verhindern, aber gleichzeitig core_func ausgeben? Eine mögliche Lösung könnte die Ausgaben von func2 zurückgeben und in func3 verwenden (aber das würde ein bisschen hässlich werden).

Dank

Answer 1

variable = core_func(arguments) 

func2(variable) 

func3(variable) 

Speichern Sie die Ergebnisse der Funktion in einer Variablen!

Answer 2

können Sie verwenden memoize

ein Rückgabewert der Funktion Caches jedes Mal aufgerufen wird.

Also, werden Sie den Rückgabewert ohne die Rechenzeit

dh bekommen jedes Mal, wenn Sie die Funktion mit den gleichen Parametern aufrufen:

Wenn Sie mit Python2 Sie benötigen zu ihrer Umsetzung Sie können einen Blick haben, wie es auf den Link oben und wenden es dann auf Ihre Funktion implementiert ist:

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 

Wenn Sie Python3 verwenden haben Sie es kostenlos mit dem lru_cache decorator

Decorator, um eine Funktion mit einer memoizing Callable zu umhüllen, die zu den maxsize letzten Anrufen speichert. Es kann Zeit sparen, wenn eine teure oder E/A-gebundene Funktion regelmäßig mit denselben Argumenten aufgerufen wird.

from functools import lru_cache 

@lru_cache(maxsize=32) 
def core_func(a, b, c): 
    do something.... 
    return x,y,z