深入了解python中元类的相关知识

2023-08-15 16:32:05 170

类也是对象

在大多数编程语言中，类就是一组用来描述如何生成一个对象的代码段，在python中也是成立的。

classObjectCreator:
pass
my_object=ObjectCreator()
print(my_object)
"""
输出结果：
<__main__.ObjectCreatorobjectat0x037DACD0>
"""

但是，python的类不止于此，类同样也是一种对象。

classObjectCreator:
pass

上面的代码段将在内存中创建一个对象，名字就叫做ObjectCreator。这个对象（类对象ObjectCreator）拥有创建对象（实例对象）的能力，但它本质上仍然还是一个对象，于是你就可以对它做如下的操作：

给它复制一个变量
拷贝它
给它增加属性
将它作为函数参数传递

示例代码：

classObjectCreator:
pass
#把它赋值给一个变量
a=ObjectCreator
print(a)#
#作为函数参数传递
defecho(o):
print(o)

echo(ObjectCreator)#

动态的创建类

因为类也是对象，所以可以在运行时动态的创建它们，使用class关键字即可。

defchoose_class(name):
ifname=='foo':
classFoo(object):
pass
returnFoo#返回的是类，不是类的实例
else:
classBar(object):
pass
returnBar
MyClass=choose_class("foo")
print(MyClass)#打印类对象
#输出结果
.Foo'>
print(MyClass())#打印实例对象
#输出结果
<__main__.choose_class..Fooobjectat0x0368CFD0>

使用type创建类

我们知道通过type()可以知道这个对象的类型是什么，他还有一个完全不同的功能，动态的创建类。
type可以接受一个类的描述作为参数，然后返回一个类。

语法：

type(类名，由父类名称构成的元组（针对继承的情况可以为空），包含属性的字典)

MyClass=type("MyClass",(),{})
print(MyClass)
#输出结果：

使用type创建带属性的类

type接受一个字典来为类定义属性，如下所示：

Foo=type("Foo",(),{'bar':True})

等价于

classFoo:
bar=True

使用type创建继承的子类

接着上面的代码，我们已经创建了一个Foo类，现在来创建一个它的子类。

FooChild=type("FooChild",(Foo,),{})
print(FooChild.bar)##bar属性是由Foo继承而来
#输出结果：
True

注意：

type的第二个参数，元组中是父类的名字，不是字符串。
添加的属性是类属性，不是实例属性。

使用type创建带有方法的类

最终你会希望为你的类增加方法。只需要定义一个有着恰当签名的函数并将其作为属性赋值就可以了。

添加实例方法

deftest_f(self):
print("添加的实例方法")
Foo=type("Foo",(),{"test_f":test_f})
f=Foo()
f.test_f()
#输出结果：
添加的实例方法

添加静态方法

@staticmethod
deftest_static():
print("添加的静态方法")
Foo=type("Foo",(),{"test_static":test_static})
Foo.test_static()
Foo.test_static()
#输出结果：
添加的静态方法

添加类方法

@classmethod
deftest_class(cls):
print("添加的类方法")
Foo=type("Foo",(),{"test_class":test_class})
Foo.test_class()
#输出的结果：
添加的类方法

什么是元类

元类就是用来创建类的“东西”。元类就是就是用来创建类对象的，元类就是类的类。
可以这样理解：

MyClass=MetaClass()#使用元类创建类对象
MyObject=MyClass()#使用类对象创建实例对象

type函数其实就是元类。type就是在Python在背后创建所有类的元类，可以通过__class__属性来查看,__class__的功能是查看对象所在的类，它可以嵌套使用。

classA:
pass
print(A.__class__)
a=A()
print(a.__class__)
print(a.__class__.__class__)
#输出结果：

可以看出，最后对象的类都是type元类。

Python中所有的东西，注意，我是指所有的东西——都是对象。这包括整数、字符串、函数以及类。它们全部都是对象，而且它们都是从一个类创建而来，这个类就是type。

整数：

age=18
print(age.__class__)
print(age.__class__.__class__)
#输出结果：

字符串：

name="张三"
print(name.__class__)
print(name.__class__.__class__)
#输出结果：

函数：

deff():
pass
print(f.__class__)
print(f.__class__.__class__)
#输出结果：

自定义元类

首先的了解一下metaclass属性，用它来指定一个元类，python会在定义的类中寻找metaclass属性，如果没找到，就到它的父类找以此类推。如果找到了，python就会用它来创建类对象，如果实在没有找到就会用内建的type来创建这个类。
metaclass中可以放type或者任何使用到type或者子类化type的东东都可以。

自定义类的主要目的：

拦截类的创建
修改类

使用函数实现一个自定义的元类

功能：把不是__开头的类属性名字变为大写

defupper_attr(future_class_name:str,future_class_parents:tuple,future_class_attr:dict):
newAttr={}
forkey,valueinfuture_class_attr.items():
ifnotkey.startswith("__"):
newAttr[key.upper()]=value
returntype(future_class_name,future_class_parents,newAttr)
classFoo(metaclass=upper_attr):
name="张三"
age=18

hasattr(Foo,"name")#判断是否有该类属性False
hasattr(Foo,"NAME")#True
hasattr(Foo,"age")#False
hasattr(Foo,"AGE")#True

继承type实现一个自定义元类

功能：同上

classMyMetaClass(type):
def__new__(cls,class_name:str,class_parents:tuple,class_attr:dict):
newAttr={}
forkey,valueinclass_attr.items():
ifnotkey.startswith("__"):
newAttr[key.upper()]=value
#方法1：通过'type'来做类对象的创建
#returntype(class_name,class_parents,newAttr)
#方法2：复用type.__new__方法
#这就是基本的OOP编程，没什么魔法
#returntype.__new__(cls,class_name,class_parents,newAttr)
#方法3：使用super方法
returnsuper(MyMetaClass,cls).__new__(cls,class_name,class_parents,newAttr)
classFoo(metaclass=MyMetaClass):
name="张三"
age=18
hasattr(Foo,"name")#判断是否有该类属性False
hasattr(Foo,"NAME")#True
hasattr(Foo,"age")#False
hasattr(Foo,"AGE")#True

效果和上面是一样的。

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持毛票票。

深入了解python中元类的相关知识

热门推荐

随机推荐