# Store past results of a function

I have a function that takes in two arrays, does some calculation, and then returns a new array. The function is called maybe 60,000 times (or 500k, depending), where up to 25% of the times it is called, it is redoing a previous calculation.

``````prev_calc = {}
def arrayMagic(ar1,ar2):
ar1_t = tuple(ar1)
ar2_t = tuple(ar2)

if (ar1_t,ar2_t) in prev_calc:
return prev_calc[(ar1_t,ar2_t)]
#some somewhat, but not too expensive function
res = magicCalc(ar1,ar2)

prev_calc[(ar1_t,ar2_t)] = res

return res
``````

ar1 and ar2 are arrays of 3 floats each; for example: [1.1,1.2,2.2] res is also an array of 3 floats.

The problem is that the tuple conversion and dictionary lookup happen to be very close to the time the `magicCalc()` function takes. Since this is the major bottleneck in my code, optimizing this would solve alot. The function is passed the two arrays, so I can't have them as an array already.

Is there a fast way to store past results of a function and return them?

This seems pretty quick...

``````d = dict()
l1 = [1.1,21.1,31.1,41.1,51.1]
l2 = [12.1,21.1,31.1,41.1,51.1]

def do(a1):
cacheKey = str(a1)
if cacheKey in d: