1. self 和 cls
首先来简要介绍一下类中的self和cls，如下栗：
class A(object):
def foo1(self):
print("Hello", self)
@classmethod
def foo2(cls):
print("Hello", cls)
调用foo1:
>>>a = A()
>>>a.foo1()
Hello <__main__.A object at 0x1040263c8>
>>>print(a)
Hello <__main__.A object at 0x1040263c8>
可以发现self和实例a指向了同一个对象，再调用类方法foo2：
>>>A.foo2()
Hello <class '__main__.A'>
发现此时指向的就是A类本身，从这个栗子我们可以得出，self指向了实例化对象而cls指向了类本身。
2. __init__和__new__
我们再来看一下__init__，相信大家对__init__已经很熟悉了，__init__通常用于初始化一个类实例，如下例：
class A(object):
def __init__(self, x, y):
self.x = x
self.y = y
由于它是初始化一个类实例的，所有需要传入self。
那么__new__方法又是做什么用的呢？看下面的栗子：
class A(object):
def __init__(self, x, y):
print('__init__ has been called')
self.__x = x
self.__y = y
def __new__(cls, *args, **kwargs):
print('__new__ has been called')
return super(A, cls).__new__(cls, *args, **kwargs)
def __str__(self):
return 'A : x is {}, y is {}'.format(self.__x, self.__y)
这里有个小插曲，当我尝试实例化A类，并将其传入参数x,y时，报了以下错误：
>>>tt=A('xxx','yyy')
in __new__
return super(A, cls).__new__(cls, *args, **kwargs)
TypeError: object() takes no parameters
仔细阅读报的错，发现是由于__new__返回的是父类实例化后的对象的—__new__方法，而父类object的__new__方法不接受任何参数，可我却对其传了参。解决方法就是不对父类实例化的对象的__new__方法传参，将上述__new__方法改成如下：
def __new__(cls, *args, **kwargs):
print('__new__ has been called')
return super(A, cls).__new__(cls)
再次运行
>>>tt=A('xxx','yyy')
>>>print(tt)
__new__ has been called
__init__ has been called
A : x is xxx, y is yyy
一切都平静了，可以看到，当实例化对象时，先是调用了__new__，然后才调用了__init__进行了初始化。其中__new__方法中可以return父类__new__出来的实例，也可以直接将其他类__new__出来的实例返回（但这就意义不大了）。
那可不可以调用自身的__new__来制造实例呢？当然不行，因为这会造成死循环（一定要避免return cls.__new__(cls))。
新式类(最终继承到object)开始实例化时，__new__会返回一个实例，然后该类的__init__方法作为构造方法回接收这个实例(即self)作为自己的第一个参数，然后依次传入__new__方法中接收的其它参数。
如果 __new__并未返回实例，那么当前类的__init__方法是不会被调用的。
3. 使用__new__构造单例模式
说了那么多，__new__方法到底有什么作用呢？接下来介绍一下如何使用它来创建单例模式。
单例模式简单来说就是即一个类只有一个实例，看下面的栗子：
class A(object):
_a = {}
def __new__(cls, *args, **kwargs):
ob = super(A, cls).__new__(cls)
ob.__dict__ = cls._a
return ob
实例化A，赋给a，并向_a添加新的键值对：
>>>a = A()
>>>a._a['a'] = 1
再次实例化A，赋给b，查看b的__dict__：
>>>b = A()
>>>print(b.__dict__)
{'a':1}
>>>print(b.a)
1
居然有先前实例a的属性，而且居然还可以直接调用！
我们将实例b也赋予一些属性，并尝试通过实例a去调用：
>>>b.b=2
>>>print(a.b)
2
仿佛实例a与实例b成了同一个实例，只是有了两个名字！这就实现了单例模式。
我们来看一下上面的代码，__dict__是用来存储对象属性的一个字典，在A类中我们创建了一个空字典_a并将其传入__dict__，由于字典恰好是可变对象，所以当我们对任何A的实例添加属性进入__dict__时，_a也进行了更新，可以说_a中保存了最新的所有的A对象的属性键值对。将_a赋给实例的__dict__，每个实例也就拥有了同一个__dict__，真是神奇。
于此类似的，利用__new__构建单例模式还有一种方法，如下栗：
class Singleton(object):
def __new__(cls, *args, **kw):
if not hasattr(cls, '_instance'):
orig = super(Singleton, cls)
cls._instance = orig.__new__(cls, *args, **kw)
return cls._instance
class MyClass(Singleton):
a = 1
具体的实现原理就不做赘述啦，相信读到这里你一定可以理解～
