Question

I have some expensive function f(x) that I want to only calculate once, but is called rather frequently. In essence, the first time the function is called, it should compute a whole bunch of values for a range of x since it will be integrated over anyway and then interpolate that one with splines, and cache the coefficients somehow, possibly in a file for further use.

My idea was to do something like the following, since it would be pretty easy to implement. First time the function is called, it does something, then redefines itself, then does something else from then on. However, it does not work as expected and might in general be bad practice.

def f():
    def g():
        print(2)
    print(1)
    f = g
f()
f()

Expected output:

1
2

Actual output:

1
1

Defining g() outside of f() does not help. Why does this not work? Other than that, the only solution I can think of right now is to use some global variable. Or does it make sense to somehow write a class for this?

Answer 1

This is overly complicated. Instead, use memoization:

def memoized(f):
    res = []
    def resf():
       if len(res) == 0
           res.append(f())
       return res[0]
    return resf

and then simply

@memoized
def f():
   # expensive calculation here ...
   return calculated_value

In Python 3, you can replace memoized with functools.lru_cache.