Python: précalcul/parties de mise en cache des fonctions

Question

Considérons la fonction suivante en Python (il est seulement un exemple fictif):

from math import factorial 

def f(x, param): 
    init = factorial(param) 
    return x**param/init 

Cette fonction est appelée à plusieurs reprises dans le code principal avec des valeurs différentes de x mais avec la même valeur de param. Cependant, la valeur de param est arbitraire et inconnue à l'avance.

Comment puis-je précalibrer ou mettre en mémoire cache la valeur de init lors du premier appel de fonction afin qu'il n'ait pas besoin d'être recalculé avec chaque appel de fonction?

Answer 1

Vous pouvez utiliser le lru_cache de functools mettre en cache les résultats de l'appel factoriel. L'exemple suivant crée une version en cache personnalisée de factorial à partir de math.factorial,

import math 
import functools 

@functools.lru_cache() 
def factorial(n): 
    return math.factorial(n) 

def f(x, param): 
    init = factorial(param) 
    return x**param/init 

Answer 2

Vous pouvez simplement définir la valeur par défaut de param pour être une variable globale. Ensuite, lorsque vous exécutez le programme et jeu param, il suffit de changer la valeur

default = 0 
def f(x, param=default): 
    if param==default: 
     init = default_init 
    else: 
     init = factorial(param) 
    return x**param/init 

def main(): 
    global default 
    default=arbitary_value 
    global default_init = factorial(default) 

Answer 3

Vous pouvez implémenter une classe avec init et param attributs comme suit:

from math import factorial 

class f: 
    def __init__(self, param): 
    self.init = factorial(param) 
    self.param = param 

    def __call__(self, x): 
    return x**self.param/self.init 


a = f(10) # __init__ 

for i in range(10): 
    print(a(i)) # __call__