zapamiętaj na dysku - python - trwałe zapamiętywanie

Question

Czy istnieje sposób na zapamiętanie danych wyjściowych funkcji na dysku?

Mam funkcji

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

i chciałbym zrobić coś takiego:

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

a następnie zadzwonić getHtmlMemoized (URL), tak aby zrobić drogiego obliczeń tylko raz dla każdego adresu URL .

Answer 1

Python oferuje bardzo elegancki sposób na zrobienie tego s - dekoratorzy. Zasadniczo dekorator jest funkcją, która owija inną funkcję w celu zapewnienia dodatkowej funkcjonalności bez zmiany kodu źródłowego funkcji. Twój dekorator można zapisać tak:

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 

Gdy masz, że „ozdobić” funkcję używając @ -syntax i jesteś gotowy.

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

Zauważ, że ten dekorator jest celowo uproszczone i nie mogą pracować w każdej sytuacji, na przykład, gdy funkcja zwraca źródło akceptuje lub dane, których nie można json-odcinkach.

Więcej na dekoratorów: How to make a chain of function decorators?

A oto jak zrobić dekorator zaoszczędzić pamięć podręczną tylko raz, w momencie wyjścia:

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

Coś jak to powinno zrobić:

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] 

Podstawowe użycie:

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

Jeśli chcesz napisać swój "cache" do pliku po użyciu go - być ponownie ładowane w przyszłości:

your_mem_func.save_memo('yournewdata.json') 

Answer 3

Wyjazd joblib.Memory. Jest to biblioteka do robienia właśnie tego.

Answer 4

Moduł Artemis library ma do tego moduł. (Musisz pip install artemis-ml)

udekorować swoją funkcję:

from artemis.fileman.disk_memoize import memoize_to_disk 

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

Wewnętrznie, to sprawia, że ​​hash z argumentów wejściowych i zapisuje pliki Memo przez tego skrótu.

Answer 5

Zakładając, że dane JSON serializacji, ten kod powinien działać

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 

ozdobić getHtmlOfUrl a następnie po prostu nazwać, gdyby został uruchomiony wcześniej, można uzyskać dostęp do danych w pamięci podręcznej.

sprawdzone z pytona 2.x i pytona 3.x

Answer 6

Czyszczenia roztwór zasilany przez moduł półek Pythona.Zaletą jest aktualizowanie pamięci podręcznej w czasie rzeczywistym, co stanowi wyjątek.

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 

Ułatwi to obliczenie funkcji tylko raz. Następne kolejne wywołania tego samego parametru zwrócą zapisany wynik.