object._getattr_(self, name)
拦截点号运算。当对未定义的属性名称和实例进行点号运算时,就会用属性名作为字符串调用这个方法。如果继承树可以找到该属性,则不调用此方法
实例instance
通过instance.name
访问属性name
,只有当属性name
没有在实例的__dict__
或它构造类的__dict__
或基类的__dict__
中没有找到,才会调用__getattr__
。当属性name
可以通过正常机制追溯到时,__getattr__
是不会被调用的。如果在__getattr__(self, attr)
存在通过self.attr
访问属性,会出现无限递归错误。
class ClassA(object): def __init__(self, classname): self.classname = classname def __getattr__(self, attr): return('invoke __getattr__', attr) insA = ClassA('ClassA') print(insA.__dict__) # 实例insA已经有classname属性了 # {'classname': 'ClassA'} print(insA.classname) # 不会调用__getattr__ # ClassA print(insA.grade) # grade属性没有找到,调用__getattr__ # ('invoke __getattr__', 'grade')
object.__getattribute__(self, name)
实例instance
通过instance.name
访问属性name
,__getattribute__
方法一直会被调用,无论属性name
是否追溯到。如果类还定义了__getattr__
方法,除非通过__getattribute__
显式的调用它,或者__getattribute__
方法出现AttributeError
错误,否则__getattr__
方法不会被调用了。如果在__getattribute__(self, attr)
方法下存在通过self.attr
访问属性,会出现无限递归错误。如下所示,ClassA
中定义了__getattribute__
方法,实例insA
获取属性时,都会调用__getattribute__
返回结果,即使是访问__dict__
属性。
class ClassA(object): def __init__(self, classname): self.classname = classname def __getattr__(self, attr): return('invoke __getattr__', attr) def __getattribute__(self, attr): return('invoke __getattribute__', attr) insA = ClassA('ClassA') print(insA.__dict__) # ('invoke __getattribute__', '__dict__') print(insA.classname) # ('invoke __getattribute__', 'classname') print(insA.grade) # ('invoke __getattribute__', 'grade')
object.__setattr__(self, name, value)
会拦截所有属性的的赋值语句。如果定义了这个方法,self.arrt = value 就会变成self.__setattr__("attr", value).这个需要注意。当在__setattr__方法内对属性进行赋值时,不可使用self.attr = value,因为他会再次调用self.__setattr__("attr", value),则会形成无穷递归循环,最后导致堆栈溢出异常。应该通过对属性字典做索引运算来赋值任何实例属性,也就是使用self.__dict__['name'] = value.
如果类自定义了__setattr__
方法,当通过实例获取属性尝试赋值时,就会调用__setattr__
。常规的对实例属性赋值,被赋值的属性和值会存入实例属性字典__dict__
中。
class ClassA(object): def __init__(self, classname): self.classname = classname insA = ClassA('ClassA') print(insA.__dict__) # {'classname': 'ClassA'} insA.tag = 'insA' print(insA.__dict__) # {'tag': 'insA', 'classname': 'ClassA'}
如果类自定义了__setattr__
,对实例属性的赋值就会调用它。类定义中的self.attr
也同样,所以在__setattr__
下还有self.attr
的赋值操作就会出现无线递归的调用__setattr__
的情况。自己实现__setattr__
有很大风险,一般情况都还是继承object
类的__setattr__
方法。
class ClassA(object): def __init__(self, classname): self.classname = classname def __setattr__(self, name, value): # self.name = value # 如果还这样调用会出现无限递归的情况 print('invoke __setattr__') insA = ClassA('ClassA') # __init__中的self.classname调用__setattr__。 # invoke __setattr__ print(insA.__dict__) # {} insA.tag = 'insA' # invoke __setattr__ print(insA.__dict__) # {}
object.__delattr__(self, name)
Like __setattr__() but for attribute deletion instead of assignment. This should only be implemented if del obj.name is meaningful for the object.
object.__dir__(self)
dir()作用在一个实例对象上时,__dir__
会被调用。返回值必须是序列。dir()将返回的序列转换成列表并排序。
object.__call__(self[, args...])
Called when the instance is “called” as a function; if this method is defined, x(arg1, arg2, ...) is a shorthand for x.__call__(arg1, arg2, ...).
Python中有一个有趣的语法,只要定义类型的时候,实现__call__
函数,这个类型就成为可调用的。换句话说,我们可以把这个类的对象当作函数来使用,相当于重载了括号运算符。
class Student(object): def __init__(self, name): self.name = name def __call__(self): print('My name is %s.' % self.name) s = Student('Michael') s() # My name is Michael.
通过使用__setattr__
, __getattr__
, __delattr__
可以重写dict,使之通过“.”调用键值。
class Dict(dict):
'''
通过使用__setattr__,__getattr__,__delattr__
可以重写dict,使之通过“.”调用
'''
def __setattr__(self, key, value):
print("In '__setattr__")
self[key] = value
def __getattr__(self, key):
try:
print("In '__getattr__")
return self[key]
except KeyError as k:
return None
def __delattr__(self, key):
try:
del self[key]
except KeyError as k:
return None
# __call__方法用于实例自身的调用,达到()调用的效果
def __call__(self, key): # 带参数key的__call__方法
try:
print("In '__call__'")
return self[key]
except KeyError as k:
return "In '__call__' error"
s = Dict()
print(s.__dict__)
# {}
s.name = "hello" # 调用__setattr__
# In '__setattr__
print(s.__dict__) # 由于调用的'__setattr__', name属性没有加入实例属性字典中。
# {}
print(s("name")) # 调用__call__
# In '__call__'
# hello
print(s["name"]) # dict默认行为
# hello
# print(s)
print(s.name) # 调用__getattr__
# In '__getattr__
# hello
del s.name # 调用__delattr__
print(s("name")) # 调用__call__
# None