简单一句话，当一个类实现__call__方法时，这个类的实例就会变成可调用对象。
直接上测试代码
class ClassA:
def __call__(self, *args, **kwargs):
print('call ClassA instance')
if __name__ == '__main__':
# ClassA实现了__call__方法
a = ClassA()
'''
这个时候，ClassA的实例a，就变成可调用对象
调用a()，输出call ClassA instance，说明是调用了
__call__函数
'''
a()
# 其实a()等同于a.__call__()，它本质上就是后者的缩写
a.__call__()
# 判断是否可调用，输出True
print(callable(a))
注意，是这个类的实例变成可调用对象，类的实例变成可调用对象，类的实例变成可调用对象，而不是改变这个类的实例化行为。
那么，如果要改变一个类的被实例化行为呢？
当然要用上黑魔法元类了，因为类本身就是元类的实例，当我们在元类中定义__call__的函数时，会改变类的实例化行为（或者说被调用的行为？感觉类和函数的界限有些模糊了）。
利用元类和__call__，可以在不使用工厂函数的情况，轻松实现单例模式，同时保持不错的可读性。
（以下代码来自《Python Cookbook》，进行部分修改，同时注释部分为个人理解）。
完整源码：https://github.com/blackmatrix7/python-learning/blob/master/class_/singleton.py
先定义一个名为Singleton的元类，实现如下
class Singleton(type):
def __init__(cls, *args, **kwargs):
cls.__instance = None
super().__init__(*args, **kwargs)
# __call__ 是对于类实例有效，比如说Spam类，是type类的实例
def __call__(cls, *args, **kwargs):
print('Singleton __call__ running')
if cls.__instance is None:
'''
元类定义__call__方法，可以抢在类运行 __new__ 和 __init__ 之前执行，
也就是创建单例模式的前提，在类实例化前拦截掉。
type的__call__实际上是调用了type的__new__和__init__
'''
cls.__instance = super().__call__(*args, **kwargs)
return cls.__instance
else:
return cls.__instance
使用元类创建类Spam
class Spam(metaclass=Singleton):
def __new__(cls):
print('Spam __new__ running')
return super().__new__(cls)
def __init__(self):
print('Spam __init__ running')
解释下上面的代码，在元类Singleton的__init__函数中，给类增加了一个叫__instance的类属性。
需要注意的是，__init__的第一个参数是cls，其实等同于我们平时在类中定义__init__的self，因为对于元类来说，类是它的实例。
之所以写成cls，是便于理解 cls.__instance = None 是给类属性 __instance 赋值为 None。
接着在元类Singleton中重写__call__方法，__call__会抢在类（元类的实例）执行__new__和__init__之前执行，也就为拦截类的实例化提供了可能。
在元类Singleton的__call__方法对类属性__instance进行判断，如果__instance为None，说明类还未进行实例化，那么调用元类的父类（元类是type的子类）type的__call__方法，同时赋值给 cls.__instance。如果 cls.__instance 不为None，说明类已经进行过实例化，直接返回之前存储在类属性cls.__instance 中的类实例，即实现单例模式。
测试代码:
if __name__ == '__main__':
a = Spam()
b = Spam()
print(a is b)
c = Spam()
print(a is c)
执行结果：
Singleton __call__ running
Spam __new__ running
Spam __init__ running
Singleton __call__ running
True
Singleton __call__ running
True
从运行结果上可以看出，每次尝试实例化Spam时，会被__call__函数拦截，所以会打印出：Singleton __call__ running
接着判断实例是否存在，在第一次运行时，实例不存在，创建类实例，并赋值给类属性__instance。
后续的几次尝试实例化Spam，因为Spam已经有实例存在，不在创建实例，实现了单例模式。
一个错误的例子
如果，我们把Spam的__new__改成下面这样，不返回任何结果，会有什么问题？？
class Spam(metaclass=Singleton):
def __new__(cls):
print('Spam __new__ running')
def __init__(self):
print('Spam __init__ running')
还是执行之前的测试代码，得到下面的运行结果
Singleton __call__ running
Spam __new__ running
Singleton __call__ running
Spam __new__ running
True
Singleton __call__ running
Spam __new__ running
True
初看似乎没有什么问题，print(a is b) 和 print(a is c)都返回了True。
细心的话，会发现上面的输出结果有个很奇怪的问题，__init__方法是从未被执行！！！
对于此，官方文档是如此说明的
If
__new__()does not return an instance of cls, then the new instance’s__init__()method will not be invoked.
当__new__函数没有返回这个类的实例时，__init__函数不会被调用。上面的示例函数，只是打印了文字，没有返回任何结果，所以不会执行__init__。
其实也容易理解，__init__需要类实例self参数，而__new__没有返回一个类实例，这样的话__init__自然无法运行。
但是，还有个问题，为什么每次Spam的__new__方法都会被运行？？
因为 __new__ 不返回任何结果，那么__init__方法不会执行，实例从头到尾都没有被创建过（cls.__instance永远是None）。
在 执行 a = Spam() b = Spam() c = Spam()的过程中，每次cls.__instance为None，就调用type.__call__试图创建实例。
而每次执行到Spam的__new__方法时，会没有创建出任何实例，这样每次都不能成功创建实例。
所以，会有每次都执行Spam __new__ running的情况。
最后，因为 a、b、c 三个实例都是None，所以在做比较时，永远的True。