memoize auf der Festplatte - python - persistent memoization

Python bietet eine sehr elegante Möglichkeit, dies zu tun - Dekorateure. Im Grunde, ein decorator ist eine Funktion, die wraps eine weitere Funktion, um zusätzliche Funktionen bereitzustellen, ohne änderung der Funktion source-code. Der Dekorator kann wie folgt geschrieben werden:

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

Sobald Sie haben, dass "verzieren" die Funktion mit der @-syntax, und Sie sind bereit.

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

Beachten Sie, dass dieser decorator ist bewusst vereinfacht und funktioniert möglicherweise nicht für jede situation, zum Beispiel, wenn die Quell-Funktion akzeptiert oder gibt Daten zurück, die nicht json-serialisiert.

Mehr über Dekoratoren: Wie eine Kette von Funktion Dekoratoren?

Und hier ist, wie man das decorator speichern des cache nur einmal, bei der Ausfahrt Zeit:

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

Eine saubere Lösung powered by Python ' s Regal-Modul. Der Vorteil ist der cache wird aktualisiert in Echtzeit über bekannte dict syntax, auch ist es die Ausnahme Beweis(keine Notwendigkeit, Sie zu behandeln ärgerlich KeyError).

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

Dies erleichtert die Funktion berechnet werden, nur einmal. Neben nachfolgende Aufrufe wird wieder das gespeicherte Ergebnis.

Etwas soll dies gerne tun:

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]

Grundlegende Verwendung:

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

Wenn Sie wollen, schreiben Sie Ihre "cache" zu einer Datei, nachdem Sie es mit -- geladen werden, wieder in die Zukunft:

your_mem_func.save_memo('yournewdata.json')

Gibt es auch diskcache.

from diskcache import Cache

cache = Cache("cachedir")

@cache.memoize()
def f(x, y):
    print('Running f({}, {})'.format(x, y))
    return x, y