1 python类对象与实例对象
python中一切皆对象(广义上的对象)，类也不例外，我们可以称类为类对象。python中内建函数type()可以返回对象的类型，例如type(int)会得到返回值，而int为类型工厂函数，是内置的类对象。如果对自定义的类使用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': , '__init__': , 'display': , '__call__': , '__dict__': , '__weakref__': , '__doc__': None}
{'name': 'h', 'address': 'china', 'fn': }
运行结果同时也验证了上述说法，类中定义的绑定方法：__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>
调用对象的init
call return <__main__.foo object at>
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__都会被调用，实例对象会被修改；
实现)1)
