Python 魔術方法

_del_

類的析構方法，它在對象被回收時執行，主要的作用時用來釋放資源（記憶體 文件 進程等）

因為Python記憶體回收機制，使得Python的del方法的執行時間是不確定的，因此不推薦在Python中使用析構方法。

class Bar(object):
    def __del__(self):
        print("被回收了！ ～")


a = Bar()

a.__del__()  # 主動調用是沒用的，因為引用計數不為零，並不會回收資源 gc
print("已經刪除a了")
print(a)

del a
# print(a)

_dict_

• 是一個綁定對象屬性的字典 存儲的是屬性的 鍵值對應關係
• 可以直接通過修改這個字典來為對象添加屬性（但是不推薦這樣做！會使得程式的可讀性降低 破壞程式的結構 充分理解 後使用 但是也要慎重）甚至 你可以通過修改 dict 來為對象添加方法 例如 func

_slots_

• 限定類的對象只能擁有某些屬性，防止寫錯屬性名，也可以實現不允許動態添加其他屬性。
• 形式：一個元組或 列表
• 需要註意 一旦類指定了 slots 那就意味著 類的屬性鍵值綁定關係 由__slots__來維護 也就是說 對象將沒有 __dict__方法
• __slots__只能約束本類，不能約束繼承它的子類，如果子類也定義了slots 方法，那麼對子類的約束將會成為兩者的並集。

class Bar(object):
    __slots__ = ('name', 'gender')

    def __init__(self, name='monkey'):
        self.name = name
        self.gender = 'male'


a = Bar()
a.age = 18   # 動態添加屬性是會報錯的。
print(a.name)

_str_

必須返回一個str 類型 在列印對象的時候將會 列印返回的 str 而不是預設的 self.str
:return: <main.... object at 0x1084b7208>

class Bar(object):

    def __str__(self):
        return "Bar"


a = Bar()
print(a)  # Bar

_repr_

將對象轉化成對解釋器友好的形式，它跟eval()方法聯繫緊密，通常repr()調用 對象的__repr__方法，該方法返回以字元串格式的 對解釋器友好的 對象描述，eval() 可以將repr()的返回值 轉化為原對象。

這玩意很強大，它是最直接的多態體現，幾乎任何類對象都實現了它，但是每個返回的結果都是不一樣的。

_class_

_class_ 允許通過對象調用類的方法和操作類的屬性即 object.__class__ 可以拿到這個對象的類
拿到類後可以進行新的實例化 操作類的屬性 調用類的方法等.

class Bar(object):
    name = 'monkey'


a = Bar()
print(a.__class__.name)   # 允許通過實例化對象訪問類

_doc_

列印對象或類或方法的文檔字元串

class Bar(object):
    """
    A simple show class!
    """
    name = 'monkey'

    def get_name(self):
        """
        get class argument name
        """
        return self.__class__.name


a = Bar()
print(a.__class__.__doc__)
print(a.__class__.get_name.__doc__)

#    A simple show class!
#    
#
#        get class argument name

_base_

用來返回類的父類

_bases_

用來返回類的繼承列表

class Lady(object):
    """ """

class Small(object):
    """ """

class SmallLady(Small, Lady):
    """"""


print(Lady.__base__)   # <class 'object'>
print(SmallLady.__bases__)   # (<class '__main__.Small'>, <class '__main__.Lady'>)

_iter_

必須返回可迭代對象

這個對象需要實現__next__方法。

_next_

每次返回迭代器的下一個值或一個迭代異常來終止迭代。

_len_

每次返回迭代器的下一個值或一個迭代異常來終止迭代。

class ListMeta(type):
    def __call__(self, data, *args, **kwargs):   # 使得self 也就是實例化出的類 是可調用的 List() 這裡的self指的是 將要 實例化出來的類 本身
        self.__init__(self,data)
        return self

    def __str__(self):
        result = self.clean_data(self)  # 是 List 可以返回期望的列表格式 將對象轉化為對人友好的字元串
        result = '[{}]'.format(result[:-1])
        return result

    def __repr__(self):
        return 'List({})'.format(self.__str__())   # 轉化為對解釋器友好的字元串

    def __iter__(self):		# 返回實現了迭代器協議的對象
        return self  # 它本身實現了 __next__

    def __next__(self):		# 實現迭代器協議，每次返回下一個值 或 一個迭代異常終止迭代
        if self.index >= len(self.data):   
            raise StopIteration
        else:
            value = self.data[self.index]
            self.index += 1
            return value

    def __len__(self):   # 返回對象的長度，len()函數會執行對象的 __len__方法
        return self.len


class List(metaclass=ListMeta):

    def __init__(self, data):
        self.data = data
        self.index = 0
        self.len = len(self.data)
        

l = List([1,2,3,4,5,6,7])

print(l)
print(len(l))

for i in l:
   print(i)

_hash_

必須返回一個int類型的數據，並且可以唯一的表示這個對象。這點很重要。

_getattribute_

• 此方法在每次訪問對象的屬性之前都會被調用，它容易使你陷入無限的遞歸中。

• 如果需要對對象屬性的訪問做一些限制 譬如 以"block_" 開頭的屬性不允許訪問可以這樣來實現，這時候她是非常有用的。

• 如果該方法找到了對象的屬性，那麼直接返回其屬性值，如果找不到或報錯了，無論如何沒有達到預期的結果，那就調用 _getattr_ 方法。

_getattr_

• 當以 點 屬性名的形式訪問屬性時，如果屬性不存在，則會執行對象的 _getattr_ 方法 該方法接受一個變數，item，即訪問的屬性名。返回值為本次獲取的屬性值，但是這個值並沒有寫入 對象的屬性字典里。
• 也就是說如果屬性在__getattribute__中找到是不會執行這個方法的。
• 這個方法也容易陷入無限的遞歸當中。

_setattr_

以點屬性名的形式設置屬性時，會調用 _setattr_ 方法，此方法需要將屬性名和屬性值的對應關係寫入關係字典__dict__里。如果重寫了該方法，一定不要忘記手動的更新 對象屬性字典。

class Storage(object):

    def __init__(self, name):
        self.name = name    # 調用__setattr__方法

    def __getattribute__(self, item):   # 每個屬性訪問前都先調用該方法
        print('getattribute: %s' % item)
        ret = True
        if item == 'error':
            raise AttributeError(r'Error ~ "error"')   # 報錯了依然執行～ 
        else:
            ret = object.__getattribute__(self, item)
        return ret

    def __getattr__(self, item):
        print('getattr: %s' % item)
        try:
            return self.__dict__[item]
        except (IndexError, KeyError)as e:
            print('No attribute %s ' % e)
        return '%s is error' % item

    def __setattr__(self, key, value):
        print('setattr: %s ' % key)
        self.__dict__.update({key:value})


file = Storage('file')
name = file.error    # 調用 __getattr__ 方法
# setattr: name 
# getattribute: __dict__
# getattribute: error
# getattr: error
# getattribute: __dict__
# No attribute 'error'