元类是类的类对象，换言之类是元类的实例，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()