Eu tenho um conjunto de matrizes muito grandes e caras para calcular, e nem todas serão necessariamente necessárias para o meu código em uma determinada execução. Gostaria de tornar a declaração opcional, mas idealmente sem precisar reescrever todo o meu código.

Exemplo de como é agora:

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

Exemplo do que eu gostaria de fazer:

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

Enquanto o uso do lambda como acima alcança um dos efeitos desejados - o cálculo da matriz é adiado até que seja necessário - se você usar a variável "x" mais de uma vez, ela deve ser calculada a cada vez. Eu gostaria de calcular apenas uma vez.

EDIT: após algumas pesquisas adicionais, parece possível fazer o que eu quero (aproximadamente) com atributos "preguiçosos" em uma classe (por exemplo,http: //code.activestate.com/recipes/131495-lazy-attributes). Suponho que não haja maneira de fazer algo semelhante sem fazer uma aula separad

EDIT2: Estou tentando implementar algumas das soluções, mas estou enfrentando um problema porque não entendo a diferença entre:

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

Acho que é uma variação disso que estou procurando, uma vez que as variáveis caras devem fazer parte de uma class