python中__init__()、__new__()、__call__()、__del__()幾個魔法方法的用法

關於__new__()的用法參考：

http://www.myhack58.com/Article/68/2014/48183.htm

 

正文：

1、__new__()的用法：

__new__()是在新式類中新出現的方法，它做用在構造方法建造實例以前，能夠這麼理解，在Python 中 存在於類裏面的構造方法__init__()負責將類的實例化，而在__init__()啓動以前，__new__()決定是否 要使用該__init__()方法，由於__new__()能夠調用其餘類的構造方法或者直接返回別的對象來做爲本類 的實例。

若是將類比喻爲工廠，那麼__init__()方法則是該工廠的生產工人，__init__()方法接受的初始化參 數則是生產所需原料，__init__()方法會按照方法中的語句負責將原料加工成實例以供工廠出貨。而 __new__()則是生產部經理，__new__()方法能夠決定是否將原料提供給該生產部工人，同時它還決定着出 貨產品是否爲該生產部的產品，由於這名經理能夠借該工廠的名義向客戶出售徹底不是該工廠的產品。

# encoding:utf-8

class A(object):
    def __new__(cls, x):
        print 'this is in A.__new__, and x is ', x
        return super(A, cls).__new__(cls)

    def __init__(self, y):
        print 'this is in A.__init__, and y is ', y

class C(object):
    def __new__(cls, n):
        print 'this is in C.__new__, and n is ', n
        return super(C, cls).__new__(cls)

    def __init__(self, a):
        print 'this is in C.__init__, and a is ', a


class B(A):
    def __new__(cls, z):
        print 'this is in B.__new__, and z is ', z
        return A.__new__(cls, z)

    def __init__(self, m):
        print 'this is in B.__init__, and m is ', m

# class B(A):
#     def __new__(cls, z):
#         print 'this is in B.__new__, and z is ', z
#         return object.__new__(cls)
#     def __init__(self, m):
#         print 'this is ni B.__init__, and m is ', m

if __name__ == '__main__':
    a = A(100)
    print '=' * 20
    b = B(200)
    print type(b)

執行的結果爲：

this is in A.__new__, and x is  100
this is in A.__init__, and y is  100
====================
this is in B.__new__, and z is  200
this is in A.__new__, and x is  200
this is in B.__init__, and m is  200
<class '__main__.B'>

說明：

1.定義A類做爲下面類的父類，A類繼承object類，由於須要重寫A類的__new__()函數，因此須要繼承object基類，成爲新式類，經典類沒有__new__()函數；

2.子類在重寫__new__()函數時，寫return時必須返回有繼承關係的類的__new__()函數調用，即上面代碼中的B類繼承自A類，則重寫B類的__new__()函數，寫return時，只能返回A.__new__(cls)或者object.__new__(cls)，不能返回C類的;

3.由註釋掉的代碼執行結果能夠看出，B類雖然繼承自A類，可是若是沒有重寫B類的__new__()函數，則默認繼承的還是object基類的__new__()，而不是A的；

4.B類的__new__()函數會在B類實例化時被調用，自動執行其中的代碼語句，可是重寫__new__()函數不會影響類的實例化結果，也就是說無論寫return時返回的是A的仍是object的，B類的實例化對象就是B類的，而不會成爲A類的實例化對象；只是在實例化時，若是返回的是A.__new__(cls)，則會執行A類中定義的__new__()函數；

5.__new__()函數肯定了類的參數的個數，object類默認定義的__new__()函數的參數爲(cls, *more)，但若是在子類中重寫了__new__(cls, x)， 則實例化類時，須要傳入一個x參數，而__init__()函數接受到的有兩個參數，一個是實例化生成的實例對象self代替，一個是傳入的實參x的值；

 

__new__()方法的特性：

   __new__()方法是在類準備將自身實例化時調用。

   __new__()方法始終都是類的靜態方法，即便沒有被加上靜態方法裝飾器。是由於不管怎樣重寫類的__new__()函數，追溯到源頭都是繼承自object的__new__()函數，而object類中定義的__new__()函數就被定義成了靜態函數，被@stacitmethod修飾

 

   類的實例化和它的構造方法一般都是這個樣子：

class MyClass(object):

   def __init__(self, *args, **kwargs):

       ...

# 實例化

myclass = MyClass(*args, **kwargs)

正如以上所示，一個類能夠有多個位置參數和多個命名參數，而在實例化開始以後，在調用 __init__()方法以前，Python首先調用__new__()方法：

def __new__(cls, *args, **kwargs):

   ...

第一個參數cls是當前正在實例化的類。

   若是要獲得當前類的實例，應當在當前類中的__new__()方法語句中調用當前類的父類 的__new__()方法。

例如，若是當前類是直接繼承自object，那當前類的__new__()方法返回的對象應該爲：

def __new__(cls, *args, **kwargs):

   ...

   return object.__new__(cls)

注意：

事實上若是（新式）類中沒有重寫__new__()方法，即在定義新式類時沒有從新定義__new__()時 ，Python默認是調用該類的直接父類的__new__()方法來構造該類的實例，若是該類的父類也沒有重寫 __new__()，那麼將一直按此規矩追溯至object的__new__()方法，由於object是全部新式類的基類。

而若是新式類中重寫了__new__()方法，那麼你能夠自由選擇任意一個的其餘的新式類（一定要是 新式類，只有新式類一定都有__new__()，由於全部新式類都是object的後代，而經典類則沒有__new__() 方法）的__new__()方法來製造實例，包括這個新式類的全部前代類和後代類，只要它們不會形成遞歸死 循環。具體看如下代碼解釋：

class Foo(object):

    def __init__(self, *args, **kwargs):

        ...

    def __new__(cls, *args, **kwargs):

        return object.__new__(cls, *args, **kwargs)    

    

# 以上return等同於 

# return object.__new__(Foo, *args, **kwargs)

    

class Child(Foo):

    def __new__(cls, *args, **kwargs):

        return object.__new__(cls, *args, **kwargs)

# 若是Child中沒有定義__new__()方法，那麼會自動調用其父類的__new__()方法來製造實例，即Foo.__new__(cls, *args, **kwargs)。

# 在任何新式類的__new__()方法，不能調用自身的__new__()來製造實例，由於這會形成死循環。所以必須避免相似如下的寫法：

# 在Foo中避免：return Foo.__new__(cls, *args, **kwargs)或return cls.__new__(cls, *args, **kwargs)。Child同理。

# 使用object或者沒有血緣關係的新式類的__new__()是安全的，可是若是是在有繼承關係的兩個類之間，應避免互調形成死循環，例如:(Foo)return Child.__new__(cls), (Child)return Foo.__new__(cls)。

class Stranger(object):

    ...

# 在製造Stranger實例時，會自動調用 object.__new__(cls)

一般來講，新式類開始實例化時，__new__()方法會返回cls（cls指代當前類）的實例，而後該類的 __init__()方法做爲構造方法會接收這個實例（即self）做爲本身的第一個參數，而後依次傳入__new__ ()方法中接收的位置參數和命名參數。

注意：若是__new__()沒有返回cls（即當前類）的實例，那麼當前類的__init__()方法是不會被調用 的。若是__new__()返回其餘類（新式類或經典類都可）的實例，那麼只會調用被返回的那個類的構造方 法。

class Foo(object):

    def __init__(self, *args, **kwargs):

        ...

    def __new__(cls, *args, **kwargs):

        return object.__new__(Stranger, *args, **kwargs)  

    

class Stranger(object):

    ...

    

foo = Foo()

print type(foo)    

    

# 打印的結果顯示foo實際上是Stranger類的實例。

# 所以能夠這麼描述__new__()和__ini__()的區別，在新式類中__new__()纔是真正的實例化方法，爲類提供外殼製造出實例框架，而後調用該框架內的構造方法__init__()使其豐滿。

# 若是以建房子作比喻，__new__()方法負責開發地皮，打下地基，並將原料存放在工地。而__init__()方法負責從工地取材料建造出地皮開發招標書中規定的大樓，__init__()負責大樓的細節設計，建造，裝修使其可交付給客戶；

 

2、__init__()的用法

　　__init__()是python的一個構造方法，在定義類時，用於初始化的一些操做；它能實現的功能及原理相對來說也是比較簡單一點，就是在實例化該類時，自動執行__init__()方法定義的內容；可是注意__init__()通常不用戶返回return；

>>> 
>>> class A(object):
    def __init__(self, x):
        self.x = x
        print '__init__ called.'
    def foo(self):
        print self.x

        
>>> 
>>> a = A('123')
__init__ called.
>>> 
>>> a.foo()
123
>>> 

 　　在A('123')實例化類時，自動調用__init__()方法定義的self.x = x和print '__init__ called.'，咱們能看到‘__init__ called.’被打印，看不到self.x = x的執行，可是在調用a.foo()時，能執行成功，就是拜self.x = x的功能所賜；由於若是沒有__init__()方法中的self.x = x，實例對象將沒法追溯到foo()函數中的self.x是從哪裏來的，從而會報錯；也就是在__init__()函數中將外部傳入的參數x賦值給self.x，從而是self.x在類A中暢行無阻；

 

三.__call__()的用法

　　__call__()方法可以讓類的實例對象，像函數同樣被調用；

>>> 
>>> class A(object):
    def __call__(self, x):
        print '__call__ called, print x: ', x

        
>>> 
>>> a = A()
>>> a('123')
__call__ called, print x:  123
>>> 

　　看a('123')這是函數的調用方法，這裏a其實是類對象A的實例對象，實例對象能想函數同樣傳參並被調用，就是__call__()方法的功能；

 

4、__del__()的用法

　　若是__new__()和__init__()函數時類的構造函數(即在類實例化時自動執行函數中定義的內容)，那麼__del__()是類的析構函數，是python垃圾回收機制的實際應用，當類的全部引用都被刪除後，該類就會被系統從內存中刪除，注意是全部的引用都被刪除哦，而不是每一次刪除；

>>> class D(object):
    def __init__(self):
        print 'this is D.__init__()'
    def __del__(self):
        print 'this is D.__del__()'

        
>>> 
>>> d = D()
this is D.__init__()
>>> 
>>> d2 = d
>>> d3 = d
>>> 
>>> del d
>>> del d2
>>> del d3
this is D.__del__()
>>> 

將D()實例化對象賦值給d，後d2,d3都是指向D()的此次實例化對象，刪除d和d2的引用都不會觸發__del__()函數，最後一個d3的引用被刪除，就會觸發__del__()，此時D()的這一次實例化的對象就被清除；

 

最後：

用一段簡單的代碼，來整體感覺一下三個方法的用法和區別：

>>> 
>>> class A(object):
    def __init__(self, x):
        print 'x in __init__', x
    def __new__(cls, y):
        print 'y in __new__', y
        return super(A, cls).__new__(cls)
    def __call__(self, z):
        print 'z in __call__', z
    def __del__(self):
        print 'this is in A.__del__()'

        
>>> 
>>> A('123')('abc')
y in __new__ 123
x in __init__ 123
z in __call__ abc
this is in A.__del__()
>>> 

　　由執行結果能夠看出，雖然__init__()方法定義在__new__()方法以前，可是結果中先展現了__new__()方法的執行結果；