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)

會攔截所有屬性的的賦值語句。如果定義了這個方法，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