zmienne leniwy Pythona? lub, opóźnione kosztowne obliczenia

Question

Mam zestaw tablic, które są bardzo duże i kosztowne do obliczenia, i nie wszystkie będą koniecznie potrzebne moim kodem w danym uruchomieniu. Chciałbym, aby ich deklaracja była opcjonalna, ale idealnie, bez konieczności przepisywania całego mojego kodu.

Przykład jak to jest teraz:

x = function_that_generates_huge_array_slowly(0) 
y = function_that_generates_huge_array_slowly(1) 

Przykład tego, co chciałbym zrobić:

x = lambda: function_that_generates_huge_array_slowly(0) 
y = lambda: function_that_generates_huge_array_slowly(1) 
z = x * 5 # this doesn't work because lambda is a function 
     # is there something that would make this line behave like 
     # z = x() * 5? 
g = x * 6 

Podczas korzystania lambda jak wyżej osiąga jeden z pożądanych efektów - wyliczenia tablica jest opóźniona, dopóki nie jest potrzebna - jeśli użyjesz zmiennej "x" więcej niż raz, musisz ją wyliczyć za każdym razem. Chciałbym to obliczyć tylko raz.

EDYCJA: EDYCJA: Po kilku dodatkowych poszukiwaniach wygląda na to, że można zrobić to, co chcę (w przybliżeniu) za pomocą "leniwych" atrybutów w klasie (np. http://code.activestate.com/recipes/131495-lazy-attributes/). Nie sądzę, że jest jakiś sposób na zrobienie czegoś podobnego bez stworzenia oddzielnej klasy?

EDIT2: Próbuję zaimplementować niektóre z rozwiązań, ale biegnę do problemu, bo nie rozumieją różnicy między:

class sample(object): 
    def __init__(self): 
     class one(object): 
      def __get__(self, obj, type=None): 
       print "computing ..." 
       obj.one = 1 
       return 1 
     self.one = one() 

i

class sample(object): 
    class one(object): 
     def __get__(self, obj, type=None): 
      print "computing ... " 
      obj.one = 1 
      return 1 
    one = one() 

Myślę, że niektóre warianty na tych jest to, czego szukam, ponieważ drogie zmienne mają być częścią klasy.

Answer 1

Pierwsza połowa problemu (Ponowne użycie wartości) można łatwo rozwiązać:

class LazyWrapper(object): 
    def __init__(self, func): 
     self.func = func 
     self.value = None 
    def __call__(self): 
     if self.value is None: 
      self.value = self.func() 
     return self.value 

lazy_wrapper = LazyWrapper(lambda: function_that_generates_huge_array_slowly(0)) 

ale nadal trzeba używać go jako lazy_wrapper() nie lasy_wrapper.

Jeśli masz zamiar zostać dostępu do niektórych zmiennych wiele razy, może być szybsze w użyciu:

class LazyWrapper(object): 
    def __init__(self, func): 
     self.func = func 
    def __call__(self): 
     try: 
      return self.value 
     except AttributeError: 
      self.value = self.func() 
      return self.value 

które uczynią pierwsze wywołanie wolniejsze i późniejsze zastosowania szybciej.

Edytuj: Widzę, że znalazłeś podobne rozwiązanie, które wymaga użycia atrybutów na zajęciach. W obu przypadkach musisz przepisać każdy dostęp do zmiennej, więc po prostu wybierz, co chcesz.

Edit 2: Można również zrobić:

class YourClass(object) 
    def __init__(self, func): 
     self.func = func 
    @property 
    def x(self): 
     try: 
      return self.value 
     except AttributeError: 
      self.value = self.func() 
      return self.value 

jeśli chcesz uzyskać dostęp do x jako atrybut instancji. Żadna dodatkowa klasa nie jest potrzebna. Jeśli nie chcesz zmieniać podpisu klasy (wymagając func, możesz zakodować połączenie funkcji do właściwości.

Answer 2

Pisanie klasa jest bardziej wytrzymałe, ale optymalizacja dla uproszczenia (co moim zdaniem prosicie), wymyśliłem następujące rozwiązanie:

cache = {} 

def expensive_calc(factor): 
    print 'calculating...' 
    return [1, 2, 3] * factor 

def lookup(name): 
    return (cache[name] if name in cache 
     else cache.setdefault(name, expensive_calc(2))) 

print 'run one' 
print lookup('x') * 2 

print 'run two' 
print lookup('x') * 2 

Answer 3

nie można dokonać prostego imię, jak x, aby naprawdę ocenić leniwie. Nazwa jest po prostu wpisem w tablicy mieszającej (na przykład w tym, co zwraca locals() lub). Dopóki nie podłączysz metod dostępu do tych tabel systemowych, nie możesz dołączyć wykonywania kodu do prostego rozpoznawania nazw.

Ale można owijać funkcje w owijarki buforujące na różne sposoby. Jest to sposób OO:

class CachedSlowCalculation(object): 
    cache = {} # our results 

    def __init__(self, func): 
     self.func = func 

    def __call__(self, param): 
     already_known = self.cache.get(param, None) 
     if already_known: 
      return already_known 
     value = self.func(param) 
     self.cache[param] = value 
     return value 

calc = CachedSlowCalculation(function_that_generates_huge_array_slowly) 

z = calc(1) + calc(1)**2 # only calculates things once 

To bezklasowe sposób:

def cached(func): 
    func.__cache = {} # we can attach attrs to objects, functions are objects 
    def wrapped(param): 
     cache = func.__cache 
     already_known = cache.get(param, None) 
     if already_known: 
      return already_known 
     value = func(param) 
     cache[param] = value 
     return value 
    return wrapped 

@cached 
def f(x): 
    print "I'm being called with %r" % x 
    return x + 1 

z = f(9) + f(9)**2 # see f called only once 

W realnym świecie dodasz jakąś logikę, aby zachować pamięć podręczną do rozsądnej wielkości, ewentualnie stosując algorytm LRU .