python 内置属性__setattr___python 自定义属性访问 __setattr__, __getattr__,__getattribute__, __call__...

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)

如果类自定义了`__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