How can I efficiently access a function's return value repeatedly without repeating expensive work?

I would like to access a Python function's return value multiple times without repeating the computationally expensive parts.

Example:

def expensive_function():
    print('do expensive work')
    return 'output of expensive work'
def get_output_twice():
    output = expensive_function()  # This does the expensive work
    print(output)  # This does not do expensive work
    print(output)  # This does not do expensive work
def get_output_again():
    output = expensive_function()  # This does the expensive work again
    print(output)  # This does not do expensive work
get_output_twice()
print('\n')
get_output_again()

This produces:

do expensive work
output of expensive work
output of expensive work
do expensive work
output of expensive work

This example demonstrates:

1. Assigning the return value to a variable allows that variable to be accessed multiple times without calling the function again, as demonstrated in get_output_twice().
2. Assigning the return value to a variable in another function forces the expensive function to be called again.

Is it possible to access a function's return value via calls from multiple other functions without repeating expensive work and without the use of global?

Yes, you can use function caching to achieve this. Function caching is a technique where the result of an expensive function call is stored in memory and reused later when the function is called again with the same input.

from functools import lru_cache
@lru_cache(maxsize=None)
def expensive_function():
    print('do expensive work')
    return 'output of expensive work'

(maxsize=None indicates that the cache can grow indefinitely and cache all possible input-output pairs of the function).