Python-元编程

1、元编程：

　　元编程 概念来自 LISP 和 smalltalk

　　我们写程序 是直接写代码，是否能够用代码来生成未来我们需要的代码，这就是元编程。

　　用阿里生成代码的程序称为元程序，metaprogram，编写这种程序就称为元编程。

　　Python 语言能够通过反射实现 元编程

　　

　　python 中；

　　　　所有非object 类都继承自object 类

　　　　所有类的类型包括 type类 都是type

　　　　type类 继承自object 类，object类的类型也是type类

2、type类

　　type构建类：　

class type(object):
    """
    type(object_or_name, bases, dict)
    type(object) -> the object's type  ----> 返回对象的类型，例如 type(10)
    type(name, bases, dict) -> a new type ----> 返回一个新的类型
    """

　　测试：

XClass = type('mycalss', (object,), {'a':100, 'b':'string'})

print(XClass)
print(XClass.__dict__)
print(XClass.__name__)
print(XClass.__bases__)
print(XClass.mro())

　　结果：

<class '__main__.mycalss'>
{'a': 100, 'b': 'string', '__module__': '__main__', '__dict__': <attribute '__dict__' of 'mycalss' objects>, '__weakref__': <attribute '__weakref__' of 'mycalss' objects>, '__doc__': None}
mycalss
(<class 'object'>,)
[<class '__main__.mycalss'>, <class 'object'>]

　　 mycalss 是创建类的 标识符

　　(objects,): 基类

　　类似命名元组

　　

　　测试：

def __init__(self):
    self.x = 100

def show(self):
    print(self.__dict__)
    print(self.x)

XClass = type('myclass', (object,), {'a':100,'b':111, 'show':show, '__init__':__init__})

print(XClass)
print(XClass.__name__)
print(XClass.__dict__)
print(XClass.mro())

print('-' * 40)
XClass().show()

　　结果：

<class '__main__.myclass'>
myclass
{'a': 100, 'b': 111, 'show': <function show at 0x00000000023322F0>, '__init__': <function __init__ at 0x00000000004BC1E0>, '__module__': '__main__', '__dict__': <attribute '__dict__' of 'myclass' objects>, '__weakref__': <attribute '__weakref__' of 'myclass' objects>, '__doc__': None}
[<class '__main__.myclass'>, <class 'object'>]
----------------------------------------
{'x': 100}
100

　　可以借助type 构造 任何类，用代码来生成代码，这就是元 编程

3、构造元类：

　　一个类可以继承自type 类，注意不是继承自 object 类了。

class ModelMeta(type):
    def __new__(cls, *args, **kwargs):
        print(cls)
        print(args) # 就是 type（name，bases， dict）的参数
        print(kwargs)
        print('------------------------------')
        return super().__new__(cls, *args, **kwargs)
# 此处的 ModelMeta 就是元类，继承自type，它可以创建出其他类

# 第一种 使用metaclass 关键字 参数指定元类
class A(metaclass=ModelMeta):
    id = 100

    def __init__(self):
        print(' ==== A ====')
print(A.__class__)
print(A.mro())
print('~~~~~~~~~~~~~~====~~~~~~~~~~')
# 第二种 B继承自 A 后，依然是从ModelMeata的类型
class B(A):
    def __init__(self):
        print('==== B ====')

print(B.__class__)
print(B.mro())
print('~~~~~~~~~~~~====~~~~~~~~~~~~')
# 第三种 元类就可以使用下面的方式创建新的类
C = ModelMeta('C', (), {})
print(C.__class__)
print(C.mro())
print('~~~~~~~~~~~~====~~~~~~~~~~~~')

# D,E 是type的 实例, 没有使用自定义的元类，所以默认使用type
class D:pass
E = type('E', (), {})

class F(ModelMeta):pass # 和A  不一样，没有使用关键字 metaclass

print('=============================')
print(type(A), A.__bases__)
print(type(B), B.__bases__)
print(type(C))
print(type(D))
print(type(E))
print(type(F), F.__bases__)

　　结果：

D:python3.7python.exe E:/code_pycharm/test_in_class/tt14.py
<class '__main__.ModelMeta'>
('A', (), {'__module__': '__main__', '__qualname__': 'A', 'id': 100, '__init__': <function A.__init__ at 0x00000000029422F0>})
{}
------------------------------
<class '__main__.ModelMeta'>
[<class '__main__.A'>, <class 'object'>]
~~~~~~~~~~~~~~====~~~~~~~~~~
<class '__main__.ModelMeta'>
('B', (<class '__main__.A'>,), {'__module__': '__main__', '__qualname__': 'B', '__init__': <function B.__init__ at 0x0000000002942378>})
{}
------------------------------
<class '__main__.ModelMeta'>
[<class '__main__.B'>, <class '__main__.A'>, <class 'object'>]
~~~~~~~~~~~~====~~~~~~~~~~~~
<class '__main__.ModelMeta'>
('C', (), {})
{}
------------------------------
<class '__main__.ModelMeta'>
[<class '__main__.C'>, <class 'object'>]
~~~~~~~~~~~~====~~~~~~~~~~~~
=============================
<class '__main__.ModelMeta'> (<class 'object'>,)
<class '__main__.ModelMeta'> (<class '__main__.A'>,)
<class '__main__.ModelMeta'>
<class 'type'>
<class 'type'>
<class 'type'> (<class '__main__.ModelMeta'>,)

Process finished with exit code 0

　　修改代码如下：

class ModelMeta(type):
    def __new__(cls, name, bases, dict):
        print(cls)
        print(name)
        print(dict)
        print('------------------------------')
        return super().__new__(cls, name, bases, dict)
# 此处的 ModelMeta 就是元类，继承自type，它可以创建出其他类

# 第一种 使用metaclass 关键字 参数指定元类
class A(metaclass=ModelMeta):
    id = 100

    def __init__(self):
        print(' ==== A ====')

 　　从结果看出，只要元类是ModelMeta，创建类对象时，就会调用MoelMeta的 __new__方法

元类的应用：

　　模拟创建表格式

class Field:# 定义字段的属性类
    def __init__(self, fieldname=None,pk=False, nullable=True):
        self.fieldname= fieldname
        self.pk = pk
        self.nullable = nullable

    def __repr__(self):
        return '<Field {}'.format(self.fieldname)

class ModelMeta(type):
    def __new__(cls, name, bases, attrs:dict):
        print(cls)
        print(name)
        print(bases)
        print('=====', attrs,'=====')

        if '__tablename__' not in attrs.keys():
            attrs['__tablename__'] = name

        primarykey = []
        for k, v in attrs.items():
            if isinstance(v, Field):
                if v.fieldname is None:
                    v.fieldname = k
                if v.pk:
                    primarykey.append(v)
        attrs['__primarykey__'] = primarykey

        return super().__new__(cls, name, bases, attrs)

class ModelBase(metaclass=ModelMeta):
    ''' 从 ModelBases 继承的类的类型都是ModelMeta '''
    pass

class Students(ModelBase):
    id = Field(pk=True, nullable = False)
    name = Field('username', nullable=False)
    age = Field()

print('====================================')
print(Students.__dict__)

　　结果：

D:python3.7python.exe E:/code_pycharm/test_in_class/tt14.py
<class '__main__.ModelMeta'>
ModelBase
()
===== {'__module__': '__main__', '__qualname__': 'ModelBase', '__doc__': ' 从 ModelBases 继承的类的类型都是ModelMeta '} =====
<class '__main__.ModelMeta'>
Students
(<class '__main__.ModelBase'>,)
===== {'__module__': '__main__', '__qualname__': 'Students', 'id': <Field None, 'name': <Field username, 'age': <Field None} =====
====================================
{'__module__': '__main__', 'id': <Field id, 'name': <Field username, 'age': <Field age, '__tablename__': 'Students', '__primarykey__': [<Field id], '__doc__': None}

Process finished with exit code 0

元编程总结：

　　元类是制造类的工厂，是生成类的类

　　构造好元类，就可以在类定义的时候，使用关键字参数 metaclass 指定元类，可以使用最原始的metatype(name,base,dict)的方式 构造一个类

　　元类的__new__（）方法中，可以获取元类的信息，当前类，基类，类属性字典

　　

　　元编程一般用于框架开发中，Django SQLAlchemy 都使用了 元类。