Carga diferida de los atributos

Question

¿Cómo implementaría la carga diferida de los atributos del objeto, es decir, si se accede a los atributos pero aún no existen, se llama a algún método de objeto que supuestamente los carga?

Mi primer intento es

def lazyload(cls): 
    def _getattr(obj, attr): 
     if "_loaded" not in obj.__dict__: 
      obj._loaded=True 
      try: 
       obj.load() 
      except Exception as e: 
       raise Exception("Load method failed when trying to access attribute '{}' of object\n{}".format(attr, e)) 
      if attr not in obj.__dict__: 
       AttributeError("No attribute '{}' in '{}' (after loading)".format(attr, type(obj))) # TODO: infinite recursion if obj fails 
      return getattr(obj, attr) 
     else: 
      raise AttributeError("No attribute '{}' in '{}' (already loaded)".format(attr, type(obj))) 

    cls.__getattr__=_getattr 
    return cls 

@lazyload 
class Test: 
    def load(self): 
     self.x=1 

t=Test()  # not loaded yet 
print(t.x) # will load as x isnt known yet 

haré lazyload específica a ciertos nombres de los atributos únicos. Como todavía no he hecho mucho metaclasificación, no estoy seguro de si ese es el enfoque correcto. ¿Qué sugerirías?

Answer 1

parece como un simple property que hacer el truco mejor:

@property 
def my_attribute(): 
    if not hasattr(self, '_my_attribute'): 
     do_expensive_operation_to_get_attribute() 
    return self._my_attribute