python元类编程_Python 元类编程

一切皆对象

函数是对象

在Python中，一切皆为对象。我们之前常用的函数，本身也是一个实例化对象。

#==== 函数也是对象 ====

deffunc():pass

print(func.__class__)#==== 我们还可以为函数对象进行增加属性的操作：虽然没人这样做 ====

func.x= "随便写的: x"func.y= "随便写的: y"

print(func.x)print(func.y)#==== 执行结果 ==== Ps:可以看到，函数是类function的实例对象。这充分验证了Python中一切皆对象的概念。

"""

随便写的: x

随便写的: y"""

类也是对象

我们使用class定义出的类，本身也是某一个类的实例对象... 我知道这可能很颠覆三观。但是事实如此...

type类是所有类的元类，即metaclass...

#==== 类也是对象 ====

classFoo(object):pass

print(Foo.__class__)print(object.__class__)print(dict.__class__)print(list.__class__)#==== 执行结果 ==== Ps:可以看见，不管是自定义的类，还是Python自带的类，甚至是object类，都是type类的实例对象。

"""

"""

什么是元类

经过上面的例子，我们可以看到所有类都是由type类进行实例化而得到的，因此。元类即是对类进行实例化的类。

元类的作用：

1.用于生产出类对象

2.用于生产出类对象的实例对象

浅析class内部机制

一个类定义后发生的4件事

我们使用class定义一个类，实际底层都是由type类进行实例化的。那么对于一个类定义后发生的事情总体有以下四步：

1.拿到类名。

2.拿到类的基类。

3.执行类体代码，创建类的局部命名空间。

4.调用元类，默认为type类，得到实例化出的类对象。

#==== 常规定义类 ====

classPeople(object):def __init__(self, name, age):

self.name=name

self.age=agedefsay(self):print("{0}:{1}".format(self.name, self.age))#==== 测试 ====

print(People.__dict__)

p1= People("Yunya",18)

p1.say()#==== 执行结果 ====

"""{'__module__': '__main__', '__init__': , 'say': , '__dict__': , '__weakref__': , '__doc__': None}

Yunya:18"""

常规定义类

#==== 一个类定义后发生的4件事 ====

#类有三大特征：

#1、类名

class_name = "People"

#2、类的基类

class_bases = (object,) #

#3、执行类体代码拿到类的命名空间

class_dic = {} #

class_body = """def __init__(self,name,age):

self.name = name

self.age = age

def say(self):

print("{0}:{1}".format(self.name,self.age))"""

exec(class_body,{},class_dic) #位置1：执行的代码，位置2：全局命名空间，位置3，执行代码期间出现的局部命名空间的变量全部存放于此

print(class_dic) #该字典中存放了类中的变量名对应的内存地址。

#4、调用元类

People =type(class_name,class_bases,class_dic)#==== 测试 ====

p1= People("Yunya",18)

p1.say()#可以成功执行！

#==== 执行结果 ==== Ps：虽然可以用这种方式来实例化出类对象，但是我们并不推荐这样做。相比于直接使用class机制，这样做法显得复杂并且对比class_dic与People.__dict__来看明显使用class机制会完善的多。

"""{'__init__': , 'say': }

Yunya:18"""

一个类定义后发生的4件事

#exec：三个参数

#参数一：包含一系列python代码的字符串

#参数二：全局作用域(字典形式)，如果不指定，默认为globals()

#参数三：局部作用域(字典形式)，如果不指定，默认为locals()

#可以把exec命令的执行当成是一个函数的执行，会将执行期间产生的名字存放于局部名称空间中

g={'x':1,'y':2}

l={}exec('''global x,z

x=100

z=200

m=300''',g,l)print(g) #{'x': 100, 'y': 2,'z':200,......}

print(l) #{'m': 300}

exec参数补充

自定义元类

元类如何生产出类对象

我们继续探讨关于上节标黄的地方。元类如何生产出类对象。

元类生产出类对象会经过两个步骤：

1.调用 元类自己的__new__方法(创建出空的对象)

2.调用 元类自己的__init__方法(将空对象构造为类对象，可以理解为为其__dict__填充数据)

注意：

__new__方法其实是在__init__方法之前执行的。因为我们之前在学习__init__方法中可以看到参数self是一个空对象，

这个空对象实际上就是__new__制造出的。

#==== 元类如何生产出类对象 ====

class MetaClass(type): #

"""自定义元类"""

def __new__(cls, *args, **kwargs):"""cls ---> 类本身(空的)

args ---> ("类名"，(类的继承关系,),{类的局部命名空间})

kwargs ---> 空"""

print("MetaClass.__new__ --> cls \n",cls)print("MetaClass.__new__ --> args \n",args)print("MetaClass.__new__ --> kwargs \n",kwargs)#return super().__new__(cls,*args,**kwargs) # 注意，此时必须将属性全部传入。因为现在的对象是个空对象，或者可以采取下面的方式

return type.__new__(cls,*args,**kwargs) #让父类 type 为我们造出空对象

def __init__(self,*args,**kwargs):"""cls ---> 类本身(空的)

args ---> ("类名"，(类的继承关系,),{类的局部命名空间})

kwargs ---> 空"""

print("MetaClass.__init__ --> self \n",self)print("MetaClass.__init__ --> args \n",args)print("MetaClass.__init__ --> kwargs \n",kwargs)

super(MetaClass, self).__init__(*args,**kwargs) #让父类 __init__ 为我们将空对象转换为类对象

class People(object,metaclass=MetaClass):def __init__(self, name, age):

self.name=name

self.age=agedefsay(self):print("{0}:{1}".format(self.name, self.age))#==== 执行结果 ====

"""MetaClass.__new__ --> cls

MetaClass.__new__ --> args

('People', (,), {'__module__': '__main__', '__qualname__': 'People', '__init__': , 'say': })

MetaClass.__new__ --> kwargs

{}

MetaClass.__init__ --> self

MetaClass.__init__ --> args

('People', (,), {'__module__': '__main__', '__qualname__': 'People', '__init__': , 'say': })

MetaClass.__init__ --> kwargs

{}"""

类如何生产出类对象

元类如何生产出类对象的实例对象

当造好的类对象试图使用 类名() 的方式进行实例化，会发生以下几件事。

1.类对象调用元类下的 __call__方法。

2.元类下的__call__方法会去调用类对象下的__new__方法创建空对象

3.元类下的__call__方法会去调用类对象下的__init__方法将空对象转换为类对象的实例对象

4.元类下的__call__方法将返回造好的类对象的实例对象。

关于__call__方法，试图使用 名字()的方式将触发其实例化出自己类中的 __call__方法，有则执行，没有则抛出异常。

比如我们定义的一个函数，使用函数名()的方式就代表是去调用元类type中的__call__方法，然后再到function类中去执行其__new__方法以及__init__方法。

#==== 有__call__方法 ====

classPeople(object):def __init__(self, name, age):

self.name=name

self.age=agedefsay(self):print("{0}:{1}".format(self.name, self.age))def __call__(self, *args, **kwargs):print("调用了__call__")#==== 测试 ====

p1= People("Yunya",18)

p1()#==== 执行结果 ==== Ps：没有抛出异常了。

"""调用了__call__"""

有__call__方法

#==== 无__call__方法 ====

classPeople(object):def __init__(self, name, age):

self.name=name

self.age=agedefsay(self):print("{0}:{1}".format(self.name, self.age))#==== 测试 ====

p1= People("Yunya",18)

p1()#==== 执行结果 ==== Ps:由于People类中没有定义__call__方法，则其实例化对象不能使用 名字() 的方式进行调用

"""Traceback (most recent call last):

File "C:/Users/Administrator/PycharmProjects/learn/反射与自省.py", line 15, in

p1()

TypeError: 'People' object is not callable"""

无__call__方法

#==== 元类如何生产出类对象的实例对象 ====

class MetaClass(type): #

"""自定义元类"""

def __call__(self, *args, **kwargs):"""self --> 类对象本身(空的)

args --> 传入的参数。 ('Yunya', 18)

kwargs --> 空的，{}"""

## 构造出空对象

obj = self.__new__(self, *args, **kwargs)print(obj) #<__main__.people object at>

print("__new__过后的对象的__dict__",obj.__dict__)#将空对象转换为类对象People的实例对象

self.__init__(obj,*args,**kwargs)print("__init__过后的对象的__dict__",obj.__dict__)#将类对象People的实例对象进行返回

returnobjclass People(object,metaclass=MetaClass):def __new__(cls, *args, **kwargs):return object.__new__(cls)def __init__(self, name, age):

self.name=name

self.age=agedefsay(self):print("{0}:{1}".format(self.name, self.age))

p1= People("Yunya",18) #相当于调用元类下的 __call__

print(p1.name)print(p1.age)#==== 执行结果 ====

"""<__main__.people object at>

__new__过后的对象的__dict__ {}

__init__过后的对象的__dict__ {'name': 'Yunya', 'age': 18}

Yunya

18"""

元类如何生产出类对象的实例对象

实例对象与类对象的查找顺序

类对象的属性查找顺序

现在该介绍终极版的属性查找顺序了。

细心的朋友应该发现，为什么类对象可以调用元类的 __call__, 而类对象的实例对象却不能？这里其实是有区别的。这里先介绍类对象的属性查找顺序。

类本身 --> 父类 --> object类 --> 元类

#==== 类对象的属性查找顺序 ====

class MetaClass(type): #

"""自定义元类"""name= "MetaClass"

classA(object):#name = "A"

pass

classB(A):#name = "B"

pass

class C(B,metaclass=MetaClass):pass

print(C.name)#==== 执行结果 ====

"""MetaClass"""

类对象的属性查找顺序

实例对象的属性查找顺序

实例对象还是通过MRO列表进行找。但是并不会找到元类中去

实例对象本身 --> 实例化出自己的类 --> 父类 --> object类

所以！实例对象是拿不到元类中的 __call__的，故不能进行 名字()的使用！

#==== 实例对象属性查找顺序 ====

class MetaClass(type): #

"""自定义元类"""name= "MetaClass"

classA(object):#name = "A"

pass

classB(A):#name = "B"

pass

class C(B,metaclass=MetaClass):passc1=C()print(c1.name)#==== 执行结果 ====

"""Traceback (most recent call last):

File "C:/Users/Administrator/PycharmProjects/learn/反射与自省.py", line 19, in

print(c1.name)

AttributeError: 'C' object has no attribute 'name'"""

实例对象属性查找顺序

练习题

类的命名规则检测

class MetaClass(type): #

"""自定义元类"""

def __init__(self,*args,**kwargs):if notargs[0].istitle():raise NameError("类名必须是大写！")

super(MetaClass,self).__init__(*args,**kwargs)class student(object,metaclass=MetaClass):pass

#==== 执行结果 ====

"""Traceback (most recent call last):

File "C:/Users/Administrator/PycharmProjects/learn/元类编程.py", line 11, in

class student(object,metaclass=MetaClass):

File "C:/Users/Administrator/PycharmProjects/learn/元类编程.py", line 6, in __init__

raise NameError("类名必须是大写！")

NameError: 类名必须是大写！"""

类的命名规则检测

类的文档信息检测

class MetaClass(type): #

"""自定义元类"""

def __init__(self,*args,**kwargs):if "__doc__" not in args[2]:raise SyntaxError("{0}类必须要有文档注释".format(args[0])) #SyntaxError 语法错误

super(MetaClass,self).__init__(*args,**kwargs)class student(object,metaclass=MetaClass):pass

#==== 执行结果 ====

"""Traceback (most recent call last):

File "C:/Users/Administrator/PycharmProjects/learn/元类编程.py", line 11, in

class student(object,metaclass=MetaClass):

File "C:/Users/Administrator/PycharmProjects/learn/元类编程.py", line 6, in __init__

raise SyntaxError("{0}类必须要有文档注释".format(args[0])) # SyntaxError 语法错误

SyntaxError: student类必须要有文档注释"""

类的文档信息检测

基于元类实现单例模式

#单例：即单个实例，指的是同一个类实例化多次的结果指向同一个对象，用于节省内存空间#如果我们从配置文件中读取配置来进行实例化，在配置相同的情况下，就没必要重复产生对象浪费内存了#settings.py文件内容如下#HOST='1.1.1.1'#PORT=3306

#方式一:定义一个类方法实现单例模式

importsettingsclassMysql:__instance=Nonedef __init__(self,host,port):

self.host=host

self.port=port

@classmethoddefsingleton(cls):if not cls.__instance: #如果没有就实例化出一个，如果有就直接返回

cls.__instance=cls(settings.HOST,settings.PORT) #进行 Mysql.__init__(settings.HOST,settings.PORT)) 并赋值

return cls.__instanceobj1=Mysql('1.1.1.2',3306)

obj2=Mysql('1.1.1.2',3306)print(obj1 is obj2) #False

obj3=Mysql.singleton()

obj4=Mysql.singleton()print(obj3 is obj4) #True

#方式二：定制元类实现单例模式

importsettingsclassMymeta(type):def __init__(self,name,bases,dic): #定义类Mysql时就触发

#事先先从配置文件中取配置来造一个Mysql的实例出来

self.__instance = object.__new__(self) #产生对象

self.__init__(self.__instance, settings.HOST, settings.PORT) #初始化对象

#上述两步可以合成下面一步

#self.__instance=super().__call__(*args,**kwargs)

super().__init__(name,bases,dic)def __call__(self, *args, **kwargs): #Mysql(...)时触发

if args or kwargs: #args或kwargs内有值

obj=object.__new__(self)

self.__init__(obj,*args,**kwargs)returnobjreturn self.__instance

class Mysql(metaclass=Mymeta):def __init__(self,host,port):

self.host=host

self.port=port

obj1=Mysql() #没有传值则默认从配置文件中读配置来实例化，所有的实例应该指向一个内存地址

obj2=Mysql()

obj3=Mysql()print(obj1 is obj2 isobj3)

obj4=Mysql('1.1.1.4',3307)#方式三:定义一个装饰器实现单例模式

importsettingsdef singleton(cls): #cls=Mysql

_instance=cls(settings.HOST,settings.PORT)def wrapper(*args,**kwargs):if args orkwargs:

obj=cls(*args,**kwargs)returnobjreturn_instancereturnwrapper

@singleton#Mysql=singleton(Mysql)

classMysql:def __init__(self,host,port):

self.host=host

self.port=port

obj1=Mysql()

obj2=Mysql()

obj3=Mysql()print(obj1 is obj2 is obj3) #True

obj4=Mysql('1.1.1.3',3307)

obj5=Mysql('1.1.1.4',3308)print(obj3 is obj4) #False

基于元类实现单例模式