Store the function value to prevent it from being run again

Yes, it's called memory. The basic idea is f()to maintain some kind of data store based on incoming parameters. Then, if it is called with the same arguments , it just returns the stored value instead of recomputing it.

By removing parameter sets according to some rules, it may be necessary to limit the size of the datastore and optimize for your desired calling pattern. For example, if a number of subgroups parameters are used together to indicate the likelihood that they will be used in the future, you might want to remove the infrequently used patterns and keep those that are used more often.

For example, consider the following Python code for adding two numbers (let's pretend this is a very time-consuming operation):

import random

def addTwo(a, b):
    return a + b

for _ in range(100):
    x = random.randint(1, 5)
    y = random.randint(1, 5)
    z = addTwo(x, y)
    print(f"{x} + {y} = {z}")

You can, but of course it's less efficient if you use the same numbers you used before. You can add memos as follows.

The code will "remember" a certain number of computations (given the dictionary, possibly random, but I can't guarantee that). If it gets an already known pair, it just returns the cached value.

Otherwise, it computes the value, stores it in a cache, and ensures that said cache doesn't grow too large:

import random, time

# Cache, and the stats for it.

(pairToSumMap, cached, calculated) = ({}, 0, 0)

def addTwo(a, b):
    global pairToSumMap, cached, calculated

    # Attempt two different cache lookups first (a:b, b:a).

    sum = None
    try:
        sum = pairToSumMap[f"{a}:{b}"]
    except:
        try:
            sum = pairToSumMap[f"{b}:{a}"]
        except:
            pass

    # Found in cache, return.

    if sum is not None:
        print("Using cached value: ", end ="")
        cached += 1
        return sum

    # Not found, calculate and add to cache (with limited cache size).

    print("Calculating value: ", end="")
    calculated += 1

    time.sleep(1) ; sum = a + b # Make expensive.

    if len(pairToSumMap) > 10:
        del pairToSumMap[list(pairToSumMap.keys())[0]]
    pairToSumMap[f"{a}:{b}"] = sum
    return sum

for _ in range(100):
    x = random.randint(1, 5)
    y = random.randint(1, 5)
    z = addTwo(x, y)
    print(f"{x} + {y} = {z}")

print(f"Calculated {calculated}, cached {cached}")

You'll also see that I've also added cached/computed information, including the last stats line that shows the cache in action, for example:

Calculated 29, cached 71

I also made the computation an expensive operation so you can see it in action (in terms of output speed). The cached will be returned immediately, and computing the sum will take a second.