整理类的调用方式和构造方法

前言：简单版：类加括号执行__init__()对象加括号执行__call__()，

　　　　全版：类是type创建的，创建类的时候type的__init__()方法自动执行，类加括号的时候执行type的__call__()方法

执行流程，

第零步 ：编译一下类，将类加载到内存

　　执行type的__init__()方法，类是type的对象

第一步：执行type的__call__方法

　　　　调用创建的类的__new__方法，用于创建对象。

　　　　调用类的__init__方法，用于对对象初始化。

第二步：调用类的对象，即调用了类的call方法

执行流程

class SingletonType(type):
    def __init__(self, *args, **kwargs):
        super(SingletonType, self).__init__(*args, **kwargs)
    
    def __call__(cls, *args, **kwargs):
        obj = cls.__new__(cls, *args, **kwargs)
        cls.__init__(obj, *args, **kwargs)  # Foo.__init__(obj)
        return obj


class Foo(metaclass=SingletonType):
    def __init__(self, name):
        self.name = name
    
    def __new__(cls, *args, **kwargs):
        return object.__new__(cls)


obj = Foo('name')
print(obj)

多线程

import threading

class SingletonType(type):
    _instance_lock = threading.Lock()
    def __call__(cls, *args, **kwargs):
        if not hasattr(cls, "_instance"):
            with SingletonType._instance_lock:
                if not hasattr(cls, "_instance"):
                    cls._instance = super(SingletonType,cls).__call__(*args, **kwargs)
        return cls._instance

class Foo(metaclass=SingletonType):
    def __init__(self,name):
        self.name = name


obj1 = Foo('name')
obj2 = Foo('name')
print(obj1,obj2)

 单例模式三种

import time
import threading
class Singleton(object):
    '''
    约定使用Singleton.instance()获取单例
    '''
    _instance_lock = threading.Lock()


    def __init__(self, *args, **kwargs):
        time.sleep(1)

    @classmethod
    def instance(cls, *args, **kwargs):
        if not hasattr(Singleton, "_instance"):
            with Singleton._instance_lock:
                if not hasattr(Singleton, "_instance"):
                    Singleton._instance = Singleton(*args, **kwargs)
        return Singleton._instance


class Singleton1(object):
    '''
    基于new实现单例
    '''
    _instance_lock = threading.Lock()

    def __init__(self, *args, **kwargs):
        pass


    def __new__(cls, *args, **kwargs):
        if not hasattr(Singleton1, "_instance"):
            with Singleton1._instance_lock:
                if not hasattr(Singleton1, "_instance"):
                    Singleton1._instance = object.__new__(cls, *args, **kwargs)
        return Singleton1._instance

# obj1 = Singleton1()
# obj2 = Singleton1()
# print(obj1,obj2)


class SingletonType(type):
    '''
    基于mateclass实现单例
    '''
    _instance_lock = threading.Lock()
    def __call__(cls, *args, **kwargs):
        if not hasattr(cls, "_instance"):
            with SingletonType._instance_lock:
                if not hasattr(cls, "_instance"):
                    cls._instance = super(SingletonType,cls).__call__(*args, **kwargs)
        return cls._instance

class Foo(metaclass=SingletonType):
    def __init__(self,name):
        self.name = name

一. __init__()

　　__init__()是对象的构造方法

class Minal:
   pass

print(type(Minal))
print(Minal.__class__)
print(Minal.__class__.__bases__)


<class 'type'>
<class 'type'>
(<class 'object'>,)

二.__new__()

　　__new__(cls, *args, **kwargs)当创建对象时调用在init方法前调用，创建对象时调用，返回当前对象的一个实例;注意：这里的第一个参数是cls即class本身

三.__call__()

　　__call__(self,  *args, **kwargs) 如果类实现了这个方法，相当于把这个类型的对象当作函数来使用，相当于 重载了括号运算符

先来看看如下示例代码：
#call.py 一个class被载入的情况下。
class Next:
  List = []
  
  def __init__(self,low,high) :
    for Num in range(low,high) :
      self.List.append(Num ** 2)
  
  def __call__(self,Nu):
    return self.List[Nu]

如果 这样使用：
b = Next(1,7)
print b.List
print b(2)

那么回馈很正常：
[1, 4, 9, 16, 25, 36]
9

但如果这样使用：
b = Next
b(1,7)
print b.List
print b(2)
$python ./call.py
[1, 4, 9, 16, 25, 36]

Traceback (most recent call last):
 File "cal.py", line 17, in <module>
  print b(2) 
TypeError: __init__() takes exactly 3 arguments (2 given)

__init__是初始化函数，在生成类的实例时执行。
而__call__是模拟()的调用，需要在实例上应用，因此这个实例自然是已经执行过__init__了。
你所举的后面那个例子：
b = Next
这并不是创建实例，而是将class赋给一个变量。因此后面使用b进行的操作都是对Next类的操作，那么其实就是：
Next(1,7)
print Next.List
print Next(2)
希望本文所述对大家的Python程序设计有所帮助。

来自于脚本之家，详细请看脚本之家