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')
<br/>
### 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)
{}
<br/>
### 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.
<br/>
### object.\__dir__(self)
dir()作用在一個實例對象上時，`__dir__`會被調用。返回值必須是序列。dir()將返回的序列轉換成列表並排序。
----------
<br/>
### 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