修改函数时散列python函数以重新生成输出

Question

我有一个具有确定性结果的 python 函数。运行时间长，输出量大：

def time_consuming_function():
    # lots_of_computing_time to come up with the_result
    return the_result

我不时修改time_consuming_function，但我想避免它在未更改时再次运行。 [time_consuming_function 仅依赖于对于此处考虑的目的不可变的函数；即它可能具有来自 Python 库的函数，但没有来自我要更改的其他代码片段。] 向我建议的解决方案是缓存输出并缓存函数的一些“散列”。如果哈希值发生变化，则函数将被修改，我们必须重新生成输出。

这是可能的还是荒谬的？

---

更新：根据答案，看起来我想做的是“记忆”time_consuming_function，除了不是（或除了）传递给不变函数的参数之外，我想说明一个本身会发生变化的函数。

Answer 1

如果我理解你的问题，我想我会这样解决它。这有点邪恶，但我认为它比我在这里看到的其他解决方案更可靠、更准确。

import inspect
import functools
import json

def memoize_zeroadic_function_to_disk(memo_filename):
    def decorator(f):
        try:
            with open(memo_filename, 'r') as fp:
                cache = json.load(fp)
        except IOError:
            # file doesn't exist yet
            cache = {}

        source = inspect.getsource(f)

        @functools.wraps(f)
        def wrapper():
            if source not in cache:
                cache[source] = f()
                with open(memo_filename, 'w') as fp:
                    json.dump(cache, fp)

            return cache[source]
        return wrapper
    return decorator

@memoize_zeroadic_function_to_disk(...SOME PATH HERE...)
def time_consuming_function():
    # lots_of_computing_time to come up with the_result
    return the_result

Answer 2

我不会将函数放在字符串中，而是将函数放在自己的文件中。例如，将其称为 time_sumption.py。它看起来像这样：

def time_consuming_method():
   # your existing method here

# Is the cached data older than this file?
if (not os.path.exists(data_file_name) 
    or os.stat(data_file_name).st_mtime < os.stat(__file__).st_mtime):
    data = time_consuming_method()
    save_data(data_file_name, data)
else:
    data = load_data(data_file_name)

# redefine method
def time_consuming_method():
    return data

在测试基础架构以使其正常工作时，我会注释掉速度较慢的部分。制作一个只返回 0 的简单函数，让所有的保存/加载内容都能让您满意，然后将慢速部分放回原处。

Answer 3

第一部分是查找表的记忆和序列化。基于一些 python 序列化库，这应该足够简单。第二部分是您想在源代码更改时删除您的序列化查找表。也许这被过度考虑到了一些奇特的解决方案中。大概当您更改代码时，您会在某处检查它？为什么不在您的签入例程中添加一个挂钩来删除您的序列化表？或者，如果这不是研究数据并且正在生产中，则将其作为发布过程的一部分，如果您的文件的修订号（将此函数放在它自己的文件中）已更改，则您的发布脚本会删除序列化查找表。

Answer 4

所以，这里有一个非常巧妙的使用装饰器的技巧：

定义记忆（f）： 缓存={}; 定义结果（*args）： 如果 args 不在缓存中： 缓存[args]=f(*args); 返回缓存[args]； 返回结果；

有了以上内容，你就可以使用了：

@memoize def myfunc(x,y,z): # 一些真正长时间运行的计算

当您调用 myfunc 时，您实际上将调用它的记忆版本。很整洁吧？每当你想重新定义你的函数时，只需再次使用“@memoize”，或者显式编写：

myfunc = memoize(new_definition_for_myfunc);

编辑
我没有意识到您想在多次运行之间进行缓存。在这种情况下，您可以执行以下操作：

导入操作系统； 导入 os.path； 进口cPickle； 类 MemoizedFunction（对象）： def __init__(self,f): self.function=f; self.filename=str(hash(f))+".cache"; self.cache={}; 如果 os.path.exists(self.filename): 使用 open(filename,'rb') 作为文件： self.cache=cPickle.load(文件); def __call__(self,*args): 如果 args 不在 self.cache 中： self.cache[args]=self.function(*args); 返回 self.cache[args]; def __del__(self): 使用 open(self.filename,'wb') 作为文件： cPickle.dump(self.cache,file,cPickle.HIGHEST_PROTOCOL); 定义记忆（f）： 返回 MemoizedFunction(f);

Answer 5

你描述的实际上是memoization。最常见的功能可以通过定义一个装饰器来记忆。

一个（过度简化的）例子：

def memoized(f):
    cache={}
    def memo(*args):
        if args in cache:
            return cache[args]
        else:
            ret=f(*args)
            cache[args]=ret
            return ret
    return memo

@memoized
def time_consuming_method():
    # lots_of_computing_time to come up with the_result
    return the_result

编辑：

从 Mike Graham 的评论和 OP 的更新来看，现在很明显需要在程序的不同运行中缓存值。这可以通过为缓存使用一些持久存储来完成（例如，使用Pickle 或简单的文本文件，或者可能使用完整的数据库，或介于两者之间的任何东西）。选择使用哪种方法取决于 OP 需要什么。其他几个答案已经给出了一些解决方案，所以我不会在这里重复。