如何在Python中无需重复执行昂贵函数、不用global，跨函数复用返回值？

要在多个函数里复用昂贵函数的计算结果，同时避免使用global变量，下面是几种实用方案：

1. 使用functools.lru_cache装饰器（最简单方案） #

Python标准库的functools.lru_cache可以直接给函数添加缓存功能，第一次调用后会自动保存结果，后续调用直接返回缓存值，无需手动处理状态。

from functools import lru_cache

@lru_cache(maxsize=None)  # maxsize=None表示不限制缓存容量
def expensive_function():
    print('do expensive work')
    return 'output of expensive work'

def get_output_twice():
    output = expensive_function()
    print(output)
    print(output)

def get_output_again():
    output = expensive_function()
    print(output)

get_output_twice()
print('\n')
get_output_again()

运行结果：

do expensive work
output of expensive work
output of expensive work

output of expensive work

说明：装饰器会基于函数参数缓存结果（无参数时只缓存一次），不管在哪个函数里调用，都不会重复执行昂贵操作。如果函数有参数，缓存会自动根据参数值区分，灵活性很高。

2. 闭包保存缓存状态 #

用闭包封装缓存结果，返回一个获取结果的函数，其他函数通过调用这个函数拿到值，不会污染全局命名空间。

def make_expensive_getter():
    _cached_result = None  # 闭包内的私有变量，用于保存缓存结果
    def getter():
        nonlocal _cached_result
        if _cached_result is None:
            print('do expensive work')
            _cached_result = 'output of expensive work'
        return _cached_result
    return getter

# 创建一个共享的getter实例
get_expensive_output = make_expensive_getter()

def get_output_twice():
    output = get_expensive_output()
    print(output)
    print(output)

def get_output_again():
    output = get_expensive_output()
    print(output)

get_output_twice()
print('\n')
get_output_again()

运行结果和上述方案一致。闭包里的_cached_result仅在getter函数内可见，不会与全局变量冲突，多个函数共用同一个get_expensive_output即可复用结果。

3. 类封装状态 #

用类的实例属性保存缓存结果，通过实例访问结果，适合需要更复杂状态管理的场景。

class ExpensiveResult:
    def __init__(self):
        self._result = None

    def get(self):
        if self._result is None:
            print('do expensive work')
            self._result = 'output of expensive work'
        return self._result

# 创建一个共享实例
result_provider = ExpensiveResult()

def get_output_twice():
    output = result_provider.get()
    print(output)
    print(output)

def get_output_again():
    output = result_provider.get()
    print(output)

get_output_twice()
print('\n')
get_output_again()

说明：实例的_result属性仅在第一次调用get()时执行昂贵计算，之后直接返回缓存值，多个函数共用同一个实例就能复用结果。

4. 依赖注入（显式传递结果） #

在顶层先计算一次昂贵函数的结果，再把结果作为参数传递给需要它的函数，这种方式完全没有隐藏状态，直观易懂。

def expensive_function():
    print('do expensive work')
    return 'output of expensive work'

def get_output_twice(output):
    print(output)
    print(output)

def get_output_again(output):
    print(output)

# 顶层一次性计算结果
cached_output = expensive_function()

# 将结果传递给各个函数
get_output_twice(cached_output)
print('\n')
get_output_again(cached_output)

运行结果符合预期，这种方式适合简单场景，或者需要明确控制结果生命周期的情况。

内容的提问来源于stack exchange，提问作者IslandPatrol