python高级之元类的用法总结_Python

一、type创建类

class a(object):

    def __init__(self, name):
        self.name = name

    def __new__(cls, *args, **kwargs):
        data = object.__new__(cls)
        return data

根据类创建对象

obj=a(‘kobe’)

1、执行类的new方法，创建对象（空对象）,【构造方法】 {}

2、执行类的init方法，初始化对象 ,【初始化方法】 {‘name’:‘kobe’}

对象是基于类创建出来的；问题：类是由谁创建的？

类默认是由type创建的

1、传统方式创建类

class a(object):
    v1 = 123

    def func(self):
        return 666


print(a)			#<class '__main__.a'>

2、非传统方式

类名
继承类
成员

a1 = type('a', (object,), {"v1": 123, "func": lambda self: 666})
print(a1)        #<class '__main__.a'>

# 根据类创建对象
obj1 = a1()			#<__main__.a object at 0x0000017049d035e0>
print(obj1)


# 调用对象中的func方法 
print(obj1.func())  #666

类默认由type创建，怎么让一个类的创建改为其他的东西呢？元类。

二、元类

元类：指定类由谁来创建

1、foo类由mytype创建，代码如下

class mytype(type):
    pass

# foo类由mytype创建
class foo(object, metaclass=mytype):
    pass

2、假设foo是一个对象，它是由mytype类创建。

class mytype(type):

    def __init__(self, *args, **kwargs):
        print('init')
        super().__init__(*args, **kwargs)

    def __new__(cls, *args, **kwargs):
        # 创建类
        print('new')
        new_cls = super().__new__(cls, *args, **kwargs)
        print(new_cls)
        return new_cls

# 假设foo是一个对象，由mytype类创建。
class foo(object, metaclass=mytype):
    pass

执行结果

new
<class '__main__.foo'>
init

3、类加括号得到的是对象，执行的是__init__()和__new__()方法，对象加括号执行__call__()方法

class f1(object):
    def __init__(self):
        print('init')

    # def __new__(cls, *args, **kwargs):
    #     print('new')

    def __call__(self, *args, **kwargs):
        print(111)

# 类加括号得到的是对象，执行的是__init__和__new__方法
obj = f1()

# 对象加括号执行call方法
obj()

执行结果

init
111

4、假设foo是一个对象，由mytype创建。

foo类其实是mytype的一个对象。

foo() 加括号执行的是——》mytype类中的__call__()方法

__call__()方法实现的功能是：

1、调用自己那个类的__new__方法创建对象

empty_object=self.__new__(self)

2、调用你自己那个类__init__方法去初始化对象

self.__init__(empty_object,*args,**kwargs)3、将创建的对象返回：return empty_object

class mytype(type):

    def __init__(self, *args, **kwargs):
        print('init')
        super().__init__(*args, **kwargs)

    def __new__(cls, *args, **kwargs):
        # 创建类
        print('new')
        new_cls = super().__new__(cls, *args, **kwargs)
        print(new_cls)
        return new_cls

    def __call__(self, *args, **kwargs):
        # 1、调用自己哪个类的__new__方法创建对象
        empty_object=self.__new__(self)
        #2、调用你自己那个类 __init__方法去初始化
        self.__init__(empty_object,*args,**kwargs)

        return empty_object

# 假设foo是一个对象，由mytype创建。
#  foo类其实是mytype的一个对象。
# foo()  ——》mytype对象()
class foo(object, metaclass=mytype):

    def __init__(self,name):
        self.name=name

v1=foo('666')

print(v1)
print(v1.name)