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__()方法的执行结果；