记忆到磁盘 - 蟒蛇 - 永久记忆

Question

有没有办法将一个函数的输出记忆到磁盘？

我有一个函数

def getHtmlOfUrl(url): 
    ... # expensive computation 

，很想做一些事情，如：

def getHtmlMemoized(url) = memoizeToFile(getHtmlOfUrl, "file.dat") 

，然后调用getHtmlMemoized（URL），以便为每个URL做昂贵的计算只有一次。

Answer 1

Python提供了一个非常优雅的方式来做到这一点s - 装饰者。基本上，装饰器是一种函数，它包装另一个函数以提供附加功能而不更改函数源代码。你的装饰可以这样写：

import json 

def persist_to_file(file_name): 

    def decorator(original_func): 

     try: 
      cache = json.load(open(file_name, 'r')) 
     except (IOError, ValueError): 
      cache = {} 

     def new_func(param): 
      if param not in cache: 
       cache[param] = original_func(param) 
       json.dump(cache, open(file_name, 'w')) 
      return cache[param] 

     return new_func 

    return decorator 

一旦你得到了，用@ -syntax“装饰”的功能，你准备好了。

@persist_to_file('cache.dat') 
def html_of_url(url): 
    your function code... 

注意，该装饰被有意简化，可能不适用于所有情况，例如，当源函数接受或返回不能JSON序列化的数据。

更多关于装饰：How to make a chain of function decorators?

下面是如何使装饰保存缓存只有一次，在退出时间：

import json, atexit 

def persist_to_file(file_name): 

    try: 
     cache = json.load(open(file_name, 'r')) 
    except (IOError, ValueError): 
     cache = {} 

    atexit.register(lambda: json.dump(cache, open(file_name, 'w'))) 

    def decorator(func): 
     def new_func(param): 
      if param not in cache: 
       cache[param] = func(param) 
      return cache[param] 
     return new_func 

    return decorator 

Answer 2

这样的事情应该做的事：

import json 

class Memoize(object): 
    def __init__(self, func): 
     self.func = func 
     self.memo = {} 

    def load_memo(filename): 
     with open(filename) as f: 
      self.memo.update(json.load(f)) 

    def save_memo(filename): 
     with open(filename, 'w') as f: 
      json.dump(self.memo, f) 

    def __call__(self, *args): 
     if not args in self.memo: 
      self.memo[args] = self.func(*args) 
     return self.memo[args] 

基本用法：

your_mem_func = Memoize(your_func) 
your_mem_func.load_memo('yourdata.json') 
# do your stuff with your_mem_func 

如果你想使用它后写你“缓存”到一个文件 - 需要重新加载在未来：

your_mem_func.save_memo('yournewdata.json') 

Answer 3

退房joblib.Memory。这是一个完全做到这一点的图书馆。

Answer 4

Artemis library有一个这个模块。 （你需要pip install artemis-ml）

你装饰你的函数：

from artemis.fileman.disk_memoize import memoize_to_disk 

@memoize_to_disk 
def fcn(a, b, c = None): 
    results = ... 
    return results 

在内部，它通过这个哈希使哈希出的输入参数和保存备忘文件。

Answer 5

假设你的数据JSON序列化，这个代码应工作

import os, json 

def json_file(fname): 
    def decorator(function): 
     def wrapper(*args, **kwargs): 
      if os.path.isfile(fname): 
       with open(fname, 'r') as f: 
        ret = json.load(f) 
      else: 
       with open(fname, 'w') as f: 
        ret = function(*args, **kwargs) 
        json.dump(ret, f) 
      return ret 
     return wrapper 
    return decorator 

装饰getHtmlOfUrl，然后简单地调用它，如果它之前已经运行，你会得到你的缓存数据。

经过与Python 2.x和蟒3.x的

Answer 6

一个清洁溶液搭载Python的搁置模块。优点是缓存实时更新，这是例外证明。

import shelve 
def shelve_it(file_name): 
    d = shelve.open(file_name) 

    def decorator(func): 
     def new_func(param): 
      if param not in d: 
       d[param] = func(param) 
      return d[param] 

     return new_func 

    return decorator 

@shelve_it('cache.shelve') 
def expensive_funcion(param): 
    pass 

这将有助于函数被计算一次。接下来的后续调用相同的参数将返回存储的结果。