元类是类的类对象,换言之类是元类的实例,Python中默认的元类为type,可以通过自定义元类的方式实现对类创建的控制。

class Base:
    a = 1
    b = 2

    print('class defined')

    def __new__(cls, *args, **kwargs):
        print(cls.__name__, 'class instance created')
        return super().__new__(cls)

    def __init__(self):
        print(type(self).__name__, 'class instance inited')

    def hello(self):
        pass


b = Base()

当调用print(type(b)),得到,可知b是Base类的实例。Python是纯面向对象语言,因此类也是对象,当调用print(type(Base))时得到,可知类Base是type的实例,type就是Python中的原生元类,用来控制、生成类这个对象。 一般地,在定义类时,默认的此类的元类是type,因此,如果我们想控制类的创建,需要将类的元类指为我们自定义的元类,这个自定义的元类需要继承type元类。

使用背景,就是我们经常用的orm

类的类,orm,让类动态化,继承type

组合就是多个类,或者若干类联合起来完成一个任务 为了降低代码的耦合度,我们一般不会在一个类里实例化另外一个类,都是将一个类在外面实例化后传参到另外一个来 这样就带来了一个问题,如果有很多类相互继承,我们就需要在外面实例化很多类 最好能动态实例化类并传参(依赖注入)


class mysql:
    def __init__(self,host):
        self.host = host
    def connect(self):
        print("连接数据库{host}".format(host=self.host))

class operator:
    def __init__(self,db):
        self.db = db
    def query(self,user):
        self.db.connect()
        print("用户{user}查询成功!".format(user=user))

db = mysql('127.0.0.1')
op = operator(db)
op.query('admin')



class MyType(type):
    print('执行__call__')
    def __call__(cls, *args, **kwargs):
        print('执行__new__')
        obj = cls.__new__(cls,*args,**kwargs)

        print('执行__init__')
        obj.__init__('127.0.0.1')

        return obj

class mysql(metaclass=MyType):
    def __init__(self,host):
        self.host = host

    def connect(self):
        print('连接数据库{host}'.format(host=self.host))

db = mysql('127.0.0.1')
db.connect()

results matching ""

    No results matching ""