新式类__new__()方法

概述

　　__new__() 是在新式类中新出现的方法，在 Python 中类实例化时，__new__()方法用在 __init__() 启动之前，决定是否要使用该 __init__() 方法，因为__new__() 可以调用其他类的构造方法或者直接返回别的对象来作为本类的实例。
特性总结：

1. __new__()方法是类在准备实例化时调用，也就是实例化之前。
2. __new__()方法始终都是类的静态方法，即使没有加上静态方法装饰器。

示例1：

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

注意：

　　事实上如果（新式）类中没有重写__new__()方法，即在定义新式类时没有重新定义__new__()时，Python默认是调用该类的直接父类的__new__()方法来构造该类的实例，如果该类的父类也没有重写__new__()，那么将一直按此规矩追溯至object的__new__()方法，因为object是所有新式类的基类。

强化进阶

　　网上有个很赞的比喻：如果将类比喻为工厂，那么__init__()方法则是该工厂的生产工人，__init__()方法接受的初始化参数则是生产所需原料，__init__()方法会按照方法中的语句负责将原料加工成实例以供工厂出货。而__new__()则是生产部经理，__new__()方法可以决定是否将原料提供给该生产部工人，同时它还决定着出货产品是否为该生产部的产品，因为这名经理可以借该工厂的名义向客户出售完全不是该工厂的产品。

示例2：

 #!/usr/bin/env python
 #-*- coding:utf-8 -*-

 class A(object):
     static_var = "withClass"

     def __init__(self):
         self.hostname = "MySql"
         self.user = "root"

     def mod_user(self,name):
         self.user = name

     def putongMethed(self):
         print "普通方法：putongMethod"

     @property
     def property_var(self):
         return "property_var"

     @staticmethod
     def static_method():
         print "静态方法：StaticMethod"

     @classmethod
     def class_method(cls):
         print "类方法：ClassMethod"

 class B(A):
     def __new__(cls, *args, **kwargs):
         print "实例化前的类对象：%s"%cls
         print "实例化前的类参数：%s"%cls.__dict__
         #在这里，B为A的派生类，A为B的基类，调用基类A的__new__()方法，并指向A的__init__()构造函数。
         return A.__new__(A,*args,**kwargs)

 if __name__=="__main__":
     obj = B()
     print "类对象的静态字段：%s"%B.static_var
     B.static_method()
     B.class_method()
     print "类属性：%s" % obj.property_var
     print "实例对象： %s"%obj
     obj.putongMethed()
     print "实例对象的参数：%s"%obj.__dict__
     #__new__()仅指定实例构造方法__init__(),并不执行该方法初始化实例
     obj.__init__()
     print "执行__init__()初始化的参数：%s"%obj.__dict__
     #调用A类中的方法
     obj.mod_user("mysql")
     print "调用A类方法修改普通字段： %s"%obj.__dict__

狸猫换太子

结果：

类对象：<class '__main__.B'>
实例化前的类参数：{'__module__': '__main__', '__new__': <staticmethod object at 0x022E7230>, '__doc__': None}
类对象的静态字段：withClass
静态方法：StaticMethod
类方法：ClassMethod
类属性：property_var
实例对象： <__main__.A object at 0x022E72D0>
普通方法：putongMethod
实例对象的参数：{}
执行__init__()初始化的参数：{'hostname': 'MySql', 'user': 'root'}
调用A类方法修改普通字段： {'hostname': 'MySql', 'user': 'mysql'}

示例解读：

1. 经理(__new__())借该工厂(B)的名义向客户(obj)出售完全不是该工厂的产品(A的__init__()以及A类指针)。
2. 我们可以看到A类的静态字段，静态方法，类方法都被B类完美继承，可以通过B.xxMethod获得。
3. obj=B()实例化时，得到的实例对象的指针却指向了A类，这就是__new__()狸猫换太子，借B工厂将他的父类A给打包出售了。
4. 因为obj的类指针指向了A，所以可以调用A的普通方法，这是如果调用B类中的普通方法或静态字段时，就会报错！！
5. obj.__dict__()查看实例对象中的参数，发现为空，没错，这里__new__()只是给了个地址（A和A.__init__()的地址），初始化需要手动执行。
6. 收到执行obj.__init__()函数后，读取实例对象参数，就得到了A类下的__init__()的数据结构。

类实例化过程

实例对象（独有的命名空间）= 指向类对象的指针 + 普通字段