Pythonの遅延変数？または、高価な計算が遅れる

Question

私は計算に非常に大規模で高価な配列を持っています。私はその宣言をオプションにしたいと思っていますが、理想的には私のコード全体を書き直す必要はありません。それが今であるかの

例：私がやりたいものの

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

例：

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 

、上記のようにラムダを使用して所望の効果の一つを達成するが - の計算配列は必要になるまで遅延されます。変数 "x"を複数回使用する場合は、毎回計算する必要があります。私は一度だけ計算したいと思う。

EDIT： さらに検索した後、クラス内に「遅延」属性（例：http://code.activestate.com/recipes/131495-lazy-attributes/）を入れたいと思うように見えます。別のクラスを作ることなく、何か似たようなことをする方法はないと思いますか？

EDIT2：私は解決策の一部を実装しようとしているが、私は違いを理解していないので、私が問題に実行しています：

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() 

と

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

を

高価な変数はクラスの一部であることが意図されているので、これらのバリエーションが私が探しているものだと思います。

Answer 1

あなたの問題の最初の半分（値を再利用する）は簡単に解決されています

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)) 

それでもlazy_wrapper()ないlasy_wrapperとしてそれを使用する必要があります。

あなたはいくつかの変数を何度もアクセスするつもりなら、それを使用する方が速いことがあります

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 

をより速く、より遅い最初の呼び出しとその後の用途を作るであろう。

編集：私はあなたがクラスの属性を使用する必要がある同様のソリューションを見つけました。どちらの方法でも、遅延アクセスのたびに書き直す必要があるので、好きなものを選んでください。

編集2：また、行うことができます。

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 

あなたは、インスタンスの属性としてxにアクセスしたい場合。追加のクラスは必要ありません。クラスシグネチャを変更したくない場合は（funcが必要になるため、関数呼び出しをプロパティにハードコードすることができます）。クラスを書く

Answer 2

がより堅牢ですが、（私はあなたが求めていると思われた）簡単にするために最適化し、私は次の解決策を考え出した：

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

あなたは、単純な名前を作ることができない、などのx、実際に遅延的に評価する。名前はハッシュテーブル内のエントリに過ぎません（例：locals()またはglobals()が返されます）。これらのシステムテーブルのアクセス方法にパッチを適用しない限り、単純な名前解決にコードの実行をアタッチすることはできません。

しかし、さまざまな方法でラッパーをキャッシュする機能をラップすることができます。 これは、オブジェクト指向の方法です：これはクラスレスな方法です

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 

：現実の世界では

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 

あなたはおそらくLRUアルゴリズムを使用して、適切なサイズにキャッシュを維持するためにいくつかのロジックを追加します。