python面向对象基础（四）内置方法 __xx__之new与init

__init__和__new__方法

__new__() 是在新式类中新出现的方法，它作用在构造方法建造实例之前，可以这么理解，在 Python 中存在于类里面的构造方法 __init__() 负责将类的实例化，而在 __init__() 启动之前，__new__() 决定是否要使用该 __init__() 方法，

因为__new__() 可以调用其他类的构造方法或者直接返回别的对象来作为本类的实例。

如果将类比喻为工厂，那么__init__()方法则是该工厂的生产工人，__init__()方法接受的初始化参数则是生产所需原料，__init__()方法会按照方法中的语句负责将原料加工成实例以供工厂出货。

而__new__()则是生产部经理，__new__()方法可以决定是否将原料提供给该生产部工人，同时它还决定着出货产品是否为该生产部的产品，因为这名经理可以借该工厂的名义向客户出售完全不是该工厂的产品。

_new__() 方法的特性：  __new__() 方法是在类准备将自身实例化时调用。 __new__() 方法始终都是类的静态方法，即使没有被加上静态方法装饰器。

class A:
    def __init__(self):
        self.x = 1
        print('in A init function')

    def __new__(cls, *args, **kwargs):
        print('in A new function')
        # return object.__new__(A)
        return super(A,cls).__new__(cls)

a = A()
print(a.x)

in A new function
in A init function
1

说明

1、继承自object的新式类才有__new__

2、__new__至少要有一个参数cls，代表当前类，此参数在实例化时由Python解释器自动识别

3、__new__必须要有返回值，返回实例化出来的实例。如果new方法不返回对象，则不会调用init方法。在自己实现__new__时要注意，可以return父类（通过super(当前类名, cls)）__new__出来的实例，或者直接是object的__new__出来的实例

4、__init__有一个参数self，就是这个__new__返回的实例，__init__在__new__的基础上可以完成一些其它初始化的动作，__init__不需要返回值

5、如果__new__创建的是当前类的实例，会自动调用__init__函数，通过return语句里面调用的__new__函数的第一个参数是cls来保证是当前类实例，如果是其他类的类名，

那么实际创建返回的就是其他类的实例，其实就不会调用当前类的__init__函数，也不会调用其他类的__init__函数。

class A:
    def __init__(self):
        self.x = 1
        print('in A init function')

    def __new__(cls, *args, **kwargs):
        print('in A new function')
        # return object.__new__(A)
        return super(A,cls).__new__(cls)

a = A()
print(a.x)

　　说明

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

2、而如果子类中重写了__new__()方法，那么你可以自由选择任意一个的其他的新式类（必定要是新式类，只有新式类必定都有__new__()，因为所有新式类都是object的后代，而经典类则没有__new__()方法）的__new__()方法来制造实例，包括这个新式类的所有前代类和后代类，只要它们不会造成递归死循环。反正肯定不能调用自己的__new__，这肯定是死循环。

3、对于子类的__init__，其调用规则跟__new__是一致的，当然如果子类和父类的__init__函数都想调用，可以在子类的__init__函数中加入对父类__init__函数的调用。

4、我们在使用时，尽量使用__init__函数，不要去自定义__new__函数，因为这两者在继承派生时的特性还是很不一样的。

__new__ 的作用

1、__new__方法主要是当你继承一些不可变的class时(比如int, str, tuple)， 提供给你一个自定义这些类的实例化过程的途径。

假如我们需要一个永远都是正数的整数类型，通过集成int，我们可能会写出这样的代码。

class PositiveInteger(int):
    def __init__(self, value):
        super(PositiveInteger, self).__init__(self, abs(value))

i = PositiveInteger(-3)
print(i)

然后报错了

这是因为对于int这种 不可变的对象，我们只有重载它的__new__方法才能起到自定义的作用。

class PositiveInteger(int):
    def __new__(cls, value):
        return super(PositiveInteger, cls).__new__(cls, abs(value))

i = PositiveInteger(-3)
print(i)

通过重载__new__方法，我们实现了需要的功能。

实现单例

class Singleton(object):
    def __new__(cls):
        # 关键在于这，每一次实例化的时候，我们都只会返回这同一个instance对象
        if not hasattr(cls, 'instance'):
            cls.instance = super(Singleton, cls).__new__(cls)
        return cls.instance

obj1 = Singleton()
obj2 = Singleton()

print(obj1 is obj2) #true

说obj1和obj2返回的一个对象，或者说两个变量指向一个空间。

那我们继续对__init__的作用进行研究：

class Singleton(object):
    def __new__(cls,*args):
        # 关键在于这，每一次实例化的时候，我们都只会返回这同一个instance对象
        if not hasattr(cls, 'instance'):
            cls.instance = super(Singleton, cls).__new__(cls)
        return cls.instance
    def __init__(self,name):
        self.name=name
        print("调用init")

obj1 = Singleton(1)
obj2 = Singleton(2)

print(obj1 is obj2) #true

print(obj1.name)
print(obj2.name)

这说明是__new__方法去开辟一个空间，单例情况下new方法给init的都是一个空间。

class Singleton(A):
    __instance = None

        #Call to __init__ of super class is missed
    def __init__(self, *args, **kwargs):
        print(2)

    def __new__(cls, *args, **kwargs):
        if not cls.__instance:
            # if not hasattr(cls, 'instance'):
            cls.__instance = super(Singleton, cls).__new__(cls, *args, **kwargs)
            cls.__instance.aa = args[0]
            print(type(cls), type(cls.__instance), type(cls.__instance.aa))
        return cls.__instance

obj1 = Singleton(1, 2, 3, b=2)
obj2 = Singleton(1, 2, 3, b=2)
print(obj1==obj2)

in A new function
<class 'type'> <class '__main__.Singleton'> <class 'int'>
2
2
True

===>有两个2看来即使是单例模式不实例化新的 __init__也会被触发