首页 > 代码库 > python __getattr__
python __getattr__
在之前的文章有提到__getattr__函数的作用: 如果属性查找(attribute lookup)在实例以及对应的类中(通过__dict__)失败, 那么会调用到类的__getattr__函数, 如果没有定义这个函数,那么抛出AttributeError异常。由此可见,__getattr__一定是作用于属性查找的最后一步,兜底。
我们来看几个例子:
第一个例子,很简单但经典,可以像访问属性一样访问dict中的键值对。
1 class ObjectDict(dict): 2 def __init__(self, *args, **kwargs): 3 super(ObjectDict, self).__init__(*args, **kwargs) 4 5 def __getattr__(self, name): 6 value =http://www.mamicode.com/ self[name] 7 if isinstance(value, dict): 8 value =http://www.mamicode.com/ ObjectDict(value) 9 return value 10 11 if __name__ == ‘__main__‘: 12 od = ObjectDict(asf={‘a‘: 1}, d=True) 13 print od.asf, od.asf.a # {‘a‘: 1} 1 14 print od.d # True
第二个例子,对象属性的lazy initialize。
1 class WidgetShowLazyLoad(object): 2 def fetch_complex_attr(self, attrname): 3 ‘‘‘可能是比较耗时的操作, 比如从文件读取‘‘‘ 4 return attrname 5 6 def __getattr__(self, name): 7 if name not in self.__dict__: 8 self.__dict__[name] = self.fetch_complex_attr(name) 9 return self.__dict__[name] 10 11 if __name__ == ‘__main__‘: 12 w = WidgetShowLazyLoad() 13 print ‘before‘, w.__dict__ 14 w.lazy_loaded_attr 15 print ‘after‘, w.__dict__
输出:
before {}
after {‘lazy_loaded_attr‘: ‘lazy_loaded_attr‘}
可以看到,属性访问前对象中的__dict__没有任何元素,访问之后就有添加。
这个例子是类实例的属性的惰性初始化,bottle里面也有一个用descriptor实现类属性的惰性初始化。
import functools class lazy_attribute(object): """ A property that caches itself to the class object. """ def __init__(self, func): functools.update_wrapper(self, func, updated=[]) self.getter = func def __get__(self, obj, cls): value = self.getter(cls) setattr(cls, self.__name__, value) return value class Widget(object): @lazy_attribute def complex_attr_may_not_need(clz): print ‘complex_attr_may_not_need is needed now‘ return sum(i*i for i in range(1000)) if __name__ == ‘__main__‘: print Widget.__dict__.get(‘complex_attr_may_not_need‘) # <__main__.lazy_attribute object at 0x02B12450> Widget.complex_attr_may_not_need # complex_attr_may_not_need is needed now print Widget.__dict__.get(‘complex_attr_may_not_need‘) # 332833500
第三个例子,我觉的是最实用的,__getattr__使得实现adapter wrapper模式非常容易,我们都知道“组合优于继承”,__getattr__实现的adapter就是以组合的形式。
class adaptee(object): def foo(self): print ‘foo in adaptee‘ def bar(self): print ‘bar in adaptee‘ class adapter(object): def __init__(self): self.adaptee = adaptee() def foo(self): print ‘foo in adapter‘ self.adaptee.foo() def __getattr__(self, name): return getattr(self.adaptee, name) if __name__ == ‘__main__‘: a = adapter() a.foo() a.bar()
如果adapter需要修改adaptee的行为,那么定义一个同名的属性就行了,其他的想直接“继承”的属性,通通交给__getattr__就行了
最后一个例子,是笔者在工作中实际用到__getattr__的例子。本质上和第三个例子差不多
class AlgoImpA(object): def __init__(self): self.obj_attr = ‘obj_attr in AlgoImpA‘ def foo(self): print ‘foo in AlgoImpA‘ def bar(self): print ‘bar in AlgoImpA‘ class AlgoImpB(object): def __init__(self): self.obj_attr = ‘obj_attr in AlgoImpB‘ def foo(self): print ‘foo in AlgoImpB‘ def bar(self): print ‘bar in AlgoImpB‘ class Algo(object): def __init__(self): self.imp_a = AlgoImpA() self.imp_b = AlgoImpB() self.cur_imp = self.imp_a def switch_imp(self): if self.cur_imp == self.imp_a: self.cur_imp = self.imp_b else: self.cur_imp = self.imp_a def __str__(self): return ‘Algo with imp %s‘ % str(self.cur_imp) def __getattr__(self, name): return getattr(self.cur_imp, name) if __name__ == ‘__main__‘: algo = Algo() print algo print algo.obj_attr algo.foo() algo.switch_imp() print algo print algo.obj_attr algo.bar()
输出:
Algo with imp <__main__.AlgoImpA object at 0x02AA2270>
obj_attr in AlgoImpA
foo in AlgoImpA
Algo with imp <__main__.AlgoImpB object at 0x02AA22B0>
obj_attr in AlgoImpB
bar in AlgoImpB
首先,Algo提供给使用者的接口应该尽量简单,因此应该使用algo.func, 而不是algo.cur_imp.func。其次,AlgoImpA和AlgoImpB都有很多的属性(泛指函数和数据属性),使用__getattr__能大幅简化代码。Why we use python,life is short。
references:
http://stackoverflow.com/questions/10761779/when-to-use-getattr
http://western-skies.blogspot.fr/2008/02/complete-example-of-getattr-in-python.html
python __getattr__
声明:以上内容来自用户投稿及互联网公开渠道收集整理发布,本网站不拥有所有权,未作人工编辑处理,也不承担相关法律责任,若内容有误或涉及侵权可进行投诉: 投诉/举报 工作人员会在5个工作日内联系你,一经查实,本站将立刻删除涉嫌侵权内容。