python中的元类介绍
类也是对象
在大多数编程语言中,类就是一组用来描述如何生成一个对象的代码段,在python中也是成立的。
class objectcreator: pass my_object = objectcreator() print(my_object) """ 输出结果: <__main__.objectcreator object at 0x037dacd0> """
但是,python的类不止于此,类同样也是一种对象。
class objectcreator: pass
上面的代码段将在内存中创建一个对象,名字就叫做objectcreator。这个对象(类对象objectcreator)拥有创建对象(实例对象)的能力,但它本质上仍然还是一个对象,于是你就可以对它做如下的操作:
- 给它复制一个变量
- 拷贝它
- 给它增加属性
- 将它作为函数参数传递
示例代码:
class objectcreator: pass # 把它赋值给一个变量 a = objectcreator print(a) # <class '__main__.objectcreator'> # 作为函数参数传递 def echo(o): print(o) echo(objectcreator) # <class '__main__.objectcreator'>
动态的创建类
因为类也是对象,所以可以在运行时动态的创建它们,使用class关键字即可。
def choose_class(name): if name == 'foo': class foo(object): pass return foo # 返回的是类,不是类的实例 else: class bar(object): pass return bar myclass = choose_class("foo") print(myclass) # 打印类对象 # 输出结果 <class '__main__.choose_class.<locals>.foo'> print(myclass()) # 打印实例对象 # 输出结果 <__main__.choose_class.<locals>.foo object at 0x0368cfd0>
使用type创建类
我们知道通过type()可以知道这个对象的类型是什么,他还有一个完全不同的功能,动态的创建类。
type可以接受一个类的描述作为参数,然后返回一个类。
语法:
type(类名,由父类名称构成的元组(针对继承的情况可以为空),包含属性的字典)
myclass = type("myclass",(),{}) print(myclass) # 输出结果: <class '__main__.myclass'>
使用type创建带属性的类
type 接受一个字典来为类定义属性,如下所示:
foo = type("foo",(),{'bar':true})
等价于
class foo: bar = true
使用type创建继承的子类
接着上面的代码,我们已经创建了一个foo类,现在来创建一个它的子类。
foochild = type("foochild",(foo,),{}) print(foochild.bar) # # bar属性是由foo继承而来 # 输出结果: true
注意:
- type的第二个参数,元组中是父类的名字,不是字符串。
- 添加的属性是类属性,不是实例属性。
使用type创建带有方法的类
最终你会希望为你的类增加方法。只需要定义一个有着恰当签名的函数并将其作为属性赋值就可以了。
添加实例方法
def test_f(self): print("添加的实例方法") foo = type("foo",(),{"test_f":test_f}) f = foo() f.test_f() # 输出结果: 添加的实例方法
添加静态方法
@staticmethod def test_static(): print("添加的静态方法") foo = type("foo",(),{"test_static":test_static}) foo.test_static() foo.test_static() # 输出结果: 添加的静态方法
添加类方法
@classmethod def test_class(cls): print("添加的类方法") foo = type("foo",(),{"test_class":test_class}) foo.test_class() # 输出的结果: 添加的类方法
什么是元类
元类就是用来创建类的“东西”。元类就是就是用来创建类对象的,元类就是类的类。
可以这样理解:
myclass = metaclass() # 使用元类创建类对象 myobject = myclass() # 使用类对象创建实例对象
type函数其实就是元类。type就是在python在背后创建所有类的元类,可以通过__class __属性来查看,__class __的功能是查看对象所在的类,它可以嵌套使用。
class a: pass print(a.__class__) a = a() print(a.__class__) print(a.__class__.__class__) # 输出结果: <class 'type'> <class '__main__.a'> <class 'type'>
可以看出,最后对象的类都是type元类。
python中所有的东西,注意,我是指所有的东西——都是对象。这包括整数、字符串、函数以及类。它们全部都是对象,而且它们都是从一个类创建而来,这个类就是type。
整数:
age = 18 print(age.__class__) print(age.__class__.__class__) # 输出结果: <class 'int'> <class 'type'>
字符串:
name = "张三" print(name .__class__) print(name .__class__.__class__) # 输出结果: <class 'str'> <class 'type'>
函数:
def f(): pass print(f.__class__) print(f.__class__.__class__) # 输出结果: <class 'function'> <class 'type'>
自定义元类
首先的了解一下metaclass属性,用它来指定一个元类,python会在定义的类中寻找metaclass属性,如果没找到,就到它的父类找以此类推。如果找到了,python就会用它来创建类对象,如果实在没有找到就会用内建的type来创建这个类。
metaclass中可以放type或者任何使用到type或者子类化type的东东都可以。
自定义类的主要目的:
- 拦截类的创建
-
修改类
使用函数实现一个自定义的元类
功能:把不是__开头的类属性名字变为大写
def upper_attr(future_class_name: str,future_class_parents: tuple,future_class_attr: dict): newattr = {} for key,value in future_class_attr.items(): if not key.startswith("__"): newattr[key.upper()] = value return type(future_class_name,future_class_parents,newattr) class foo(metaclass=upper_attr): name = "张三" age = 18 hasattr(foo,"name") # 判断是否有该类属性 false hasattr(foo,"name") # true hasattr(foo,"age") # false hasattr(foo,"age") # true
继承type实现一个自定义元类
功能:同上
class mymetaclass(type): def __new__(cls, class_name: str, class_parents: tuple, class_attr: dict): newattr = {} for key, value in class_attr.items(): if not key.startswith("__"): newattr[key.upper()] = value # 方法1:通过'type'来做类对象的创建 # return type(class_name, class_parents, newattr) # 方法2:复用type.__new__方法 # 这就是基本的oop编程,没什么魔法 # return type.__new__(cls, class_name, class_parents, newattr) # 方法3:使用super方法 return super(mymetaclass, cls).__new__(cls, class_name, class_parents, newattr) class foo(metaclass=mymetaclass): name = "张三" age = 18 hasattr(foo,"name") # 判断是否有该类属性 false hasattr(foo,"name") # true hasattr(foo,"age") # false hasattr(foo,"age") # true
效果和上面是一样的。