python面向对象和元类的理解

1 python类对象与实例对象

python中一切皆对象（广义上的对象），类也不例外，我们可以称类为类对象。python中内建函数type()可以返回对象的类型，例如type(int)会得到返回值<class 'type'>，而int为类型工厂函数，是内置的类对象。如果对自定义的类使用type()也会返回相同的值<class 'type'>。
从上述我们可以总结出：python中type为一般类对象的类（除非子类化type，用type子类创建类对象），即type类可以实例化得到类对象，再由类对象实例化得到实例对象。创建类的类被称为元类

1.1 类属性&实例属性

1.1.1 类属性

类属性是一个类对象的数据或函数元素，类属性包括数据属性和方法。
数据属性 是仅属于类的变量，与任何实例无关，这与C++和Java中静态成员变量相似。
方法是定义在类中的函数，根据用法，可以分为绑定方法与非绑定方法。绑定方法必须实例化后才能调用，需要与实例绑定；非绑定方法则可以分为静态方法和类方法，可以使用装饰器@staticmethod和@classmethod实现。虽然绑定方法需要实例化后才能调用，但其定义在类中，因此其也属于类的属性。

class P():
    version = 1.0 #类的静态数据

    @classmethod
    def show(cls): #类方法
        print(cls.version)
 
    def __init__(self, name, address): #绑定方法，self代表实例
        self.name = name
        self.address = address
    
    def display(self):
        print(self.name)
        print(self.address)

    def __call__(self):
        print(self.name)

def fn():
    print('hello,python')

if __name__ == '__main__':
    p = P('jay','american')
    p1 = P('h','china')
    p1.fn = fn
    print(P.__dict__)
    print(p1.__dict__)

以上是创建类对象的一个例子，__dict__为对象的特殊属性，其值为对象属性构成的字典（并非所有类或实例都有该属性，若定义了__slots__属性则会取代__dict__属性），
运行结果如下：

>>
{'__module__': '__main__', 'version': '1.0',
'show': <classmethod object at 0x000002A48351EB70>, '__init__': <function P.__init__ at 0x000002A4835137B8>, 'display': <function P.display at 0x000002A483513840>, '__call__': <function P.__call__ at 0x000002A4835138C8>, '__dict__': <attribute '__dict__' of 'P' objects>, '__weakref__': <attribute '__weakref__' of 'P' objects>, '__doc__': None}
{'name': 'h', 'address': 'china', 'fn': <function fn at 0x000002A4816B1E18>}

运行结果同时也验证了上述说法，类中定义的绑定方法：__init__, display, __call__，和非绑定方法：show，都是属于类的属性；而fn,name,address则属于实例属性。

1.1.2 实例属性

实例属性是只属于实例对象的方法和数据属性。不同于静态语言，python能动态地创建实例属性，上述代码中的fn即为动态创建的实例属性。
但这样特性的缺陷是如果实例属性在条件语句中创建，若该条件语句并未执行，该属性也就不存在，而后面的代码试着访问这些属性，就会发生错误。
解决办法是避免中途创建实例属性，尽量在__init__方法中初始化实例属性。

1.1.3 类属性VS实例属性

类属性也能通过实例访问，但前提是该实例中没有同名的属性。任何对实例属性的赋值都会新建一个实例属性并对其赋值，但如果类属性中存在同名的属性，则不会对类属性产生影响，若要改变类属性需要使用类名，而不是实例名。

class P():
    version = 1
>>p1 = P()
>>p1.version
1
>>p1.version = 2
>>p1.version
2
>>P.version
1
>>P.version = 2
>>P.version
2

1.2 类的特殊方法（魔术方法）

__init__：初始化方法，属于类的绑定方法，第一个参数必须为self（代表实例对象），且无返回值，在__new__返回实例对象后才能调用。
__new__：真正的构造方法，用于创建实例对象，属于静态方法，第一个参数为cls（代表类对象），其返回值为实例对象。
__call__：将对象设置为可调用对象（可以向函数一样用()调用），元类type中实现了该函数，因此类对象为可调用对象，实例化时就是通过调用类来创建实例对象的，覆盖时需要调用父类方法，即super().__call__()

关键知识：覆盖上述特殊函数时，需要特别注意，元类中自定义__call__(self, *args, **kwargs)，类对象中若自定义__init__(self, *args, **kwargs)，则自定义__new__(cls, *args, **kwargs)，原因如下：

p1 = P(*args, **kwargs) 
'''执行顺序：'''
P.__call__(*args, **kwargs):
    super().__call__(*args, **kwargs)
    goto↓
        p1 = object().__new__(P)
        p1.__init__(*args, **kwargs)
    return p1

2 Metaclass元类

2.1 自定义元类

元类是用来创建其他的类，它的实例就是其他的类。
执行类定义时，解释器会先寻找类属性__metaclass__，如果此属性中未定义，则向上查找其父类中的__metaclass__
type的__init__函数有三个位置参数，分别为：类名称，父类名称元祖，类属性字典；可直接使用type()快速创建类对象：
People = type('People',(object,),dict(show = fn, setage = fn1, age = None))
也可子类化type类后，创建元类，再创建类对象：

from time import ctime

class MetaC(type):
    def __init__(self, *args):
        super().__init__(*args)
        print('调用类的init')
    
    def __call__(self, *args, **kwargs):
        print('调用类的call')
        _instance = super().__call__(*args, **kwargs)
        print('call return %s' %_instance)
        return _instance

class Foo(metaclass=MetaC):
    # __metaclass__ = MetaC

    def __init__(self, version=None):
        print('调用对象的init')

    def __new__(cls, *args, **kwargs):
        print('调用对象的new')
        _instance = super().__new__(cls)
        print('new return %s' %_instance)
        return _instance
    
foo = Foo('hello')

运行结果：

>>
调用类的init
调用类的call
调用对象的new
new return <__main__.Foo object at 0x0000018D2F57EF98>
调用对象的init
call return <__main__.Foo object at 0x0000018D2F57EF98>

2.2 单例模式的实现

下面是几种单例模式的实现方法，有些会用到上述的元类知识。

2.2.1 装饰器实现单例

import weakref

def single_obj(cls):
#实例缓存为弱引用，实例不被使用时会释放该实例
    _spam_cache = weakref.WeakValueDictionary()
    @wraps(cls)
    def wrapper(*args, **kwargs):
        if cls not in _spam_cache :
            _instance = cls(*args, **kwargs)
            _spam_cache [cls] = _instance
            return _instance
        else:
            return _spam_cache [cls]
    return wrapper

@single_obj
class A():
    def __init__(self, version):
        self.version = version
        print(self.version)

a1 = A(1.3)
a2 = A(1.2)
print('a1 id:',id(a1))
print('a2 id:',id(a2))

2.2.2 利用元类，类的`call`方法实现单例

class Singleton(type):
    def __init__(self, *args, **kwargs):
        self._instance = None
        super().__init__(*args, **kwargs)
    
    def __call__(self, *args, **kwargs):
        if self._instance is None:
            self._instance = super().__call__(*args, **kwargs)
            return self._instance
        else:
            return self._instance

class B(metaclass=Singleton):
    def __init__(self, name):
        self.name = name
        print(name)

b1 = B('what')
b2 = B('hell')
print(b2.name)
print('b1 id:',id(b1))
print('b2 id:',id(b2))

2.2.3 通过`new`实现单例（此方法不可行）

class C(object):
    _instance = None

    def __init__(self, name):
        self.name = name
        print(name)

    def __new__(cls, *args, **kwargs):
        if cls._instance is None:
            cls._instance = super().__new__(cls)
        return cls._instance

c1 = C('dsfsfd')
c2 = C('java')

print('c1 id:',id(c1))
print('c2 id:',id(c2))

若采用上述方法，无论类是否实例化，__init__都会被调用，实例对象会被修改；