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__
都会被调用,实例对象会被修改;
网友评论