Python-元编程

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

1 XClass = type(‘mycalss‘, (object,), {‘a‘:100, ‘b‘:‘string‘})
2 
3 print(XClass)
4 print(XClass.__dict__)
5 print(XClass.__name__)
6 print(XClass.__bases__)
7 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‘>]

 1 def __init__(self):
 2     self.x = 100
 3 
 4 def show(self):
 5     print(self.__dict__)
 6     print(self.x)
 7 
 8 XClass = type(‘myclass‘, (object,), {‘a‘:100,‘b‘:111, ‘show‘:show, ‘__init__‘:__init__})
 9 
10 print(XClass)
11 print(XClass.__name__)
12 print(XClass.__dict__)
13 print(XClass.mro())
14 
15 print(‘-‘ * 40)
16 XClass().show()

1 <class ‘__main__.myclass‘>
2 myclass
3 {‘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}
4 [<class ‘__main__.myclass‘>, <class ‘object‘>]
5 ----------------------------------------
6 {‘x‘: 100}
7 100

 1 class ModelMeta(type):
 2     def __new__(cls, *args, **kwargs):
 3         print(cls)
 4         print(args) # 就是 type（name，bases， dict）的参数
 5         print(kwargs)
 6         print(‘------------------------------‘)
 7         return super().__new__(cls, *args, **kwargs)
 8 # 此处的 ModelMeta 就是元类，继承自type，它可以创建出其他类
 9 
10 # 第一种 使用metaclass 关键字 参数指定元类
11 class A(metaclass=ModelMeta):
12     id = 100
13 
14     def __init__(self):
15         print(‘ ==== A ====‘)
16 print(A.__class__)
17 print(A.mro())
18 print(‘~~~~~~~~~~~~~~====~~~~~~~~~~‘)
19 # 第二种 B继承自 A 后，依然是从ModelMeata的类型
20 class B(A):
21     def __init__(self):
22         print(‘==== B ====‘)
23 
24 print(B.__class__)
25 print(B.mro())
26 print(‘~~~~~~~~~~~~====~~~~~~~~~~~~‘)
27 # 第三种 元类就可以使用下面的方式创建新的类
28 C = ModelMeta(‘C‘, (), {})
29 print(C.__class__)
30 print(C.mro())
31 print(‘~~~~~~~~~~~~====~~~~~~~~~~~~‘)
32 
33 # D,E 是type的 实例, 没有使用自定义的元类，所以默认使用type
34 class D:pass
35 E = type(‘E‘, (), {})
36 
37 class F(ModelMeta):pass # 和A  不一样，没有使用关键字 metaclass
38 
39 print(‘=============================‘)
40 print(type(A), A.__bases__)
41 print(type(B), B.__bases__)
42 print(type(C))
43 print(type(D))
44 print(type(E))
45 print(type(F), F.__bases__)

 1 D:\python3.7\python.exe E:/code_pycharm/test_in_class/tt14.py
 2 <class ‘__main__.ModelMeta‘>
 3 (‘A‘, (), {‘__module__‘: ‘__main__‘, ‘__qualname__‘: ‘A‘, ‘id‘: 100, ‘__init__‘: <function A.__init__ at 0x00000000029422F0>})
 4 {}
 5 ------------------------------
 6 <class ‘__main__.ModelMeta‘>
 7 [<class ‘__main__.A‘>, <class ‘object‘>]
 8 ~~~~~~~~~~~~~~====~~~~~~~~~~
 9 <class ‘__main__.ModelMeta‘>
10 (‘B‘, (<class ‘__main__.A‘>,), {‘__module__‘: ‘__main__‘, ‘__qualname__‘: ‘B‘, ‘__init__‘: <function B.__init__ at 0x0000000002942378>})
11 {}
12 ------------------------------
13 <class ‘__main__.ModelMeta‘>
14 [<class ‘__main__.B‘>, <class ‘__main__.A‘>, <class ‘object‘>]
15 ~~~~~~~~~~~~====~~~~~~~~~~~~
16 <class ‘__main__.ModelMeta‘>
17 (‘C‘, (), {})
18 {}
19 ------------------------------
20 <class ‘__main__.ModelMeta‘>
21 [<class ‘__main__.C‘>, <class ‘object‘>]
22 ~~~~~~~~~~~~====~~~~~~~~~~~~
23 =============================
24 <class ‘__main__.ModelMeta‘> (<class ‘object‘>,)
25 <class ‘__main__.ModelMeta‘> (<class ‘__main__.A‘>,)
26 <class ‘__main__.ModelMeta‘>
27 <class ‘type‘>
28 <class ‘type‘>
29 <class ‘type‘> (<class ‘__main__.ModelMeta‘>,)
30 
31 Process finished with exit code 0

 1 class ModelMeta(type):
 2     def __new__(cls, name, bases, dict):
 3         print(cls)
 4         print(name)
 5         print(dict)
 6         print(‘------------------------------‘)
 7         return super().__new__(cls, name, bases, dict)
 8 # 此处的 ModelMeta 就是元类，继承自type，它可以创建出其他类
 9 
10 # 第一种 使用metaclass 关键字 参数指定元类
11 class A(metaclass=ModelMeta):
12     id = 100
13 
14     def __init__(self):
15         print(‘ ==== A ====‘)

 1 class Field:# 定义字段的属性类
 2     def __init__(self, fieldname=None,pk=False, nullable=True):
 3         self.fieldname= fieldname
 4         self.pk = pk
 5         self.nullable = nullable
 6 
 7     def __repr__(self):
 8         return ‘<Field {}‘.format(self.fieldname)
 9 
10 class ModelMeta(type):
11     def __new__(cls, name, bases, attrs:dict):
12         print(cls)
13         print(name)
14         print(bases)
15         print(‘=====‘, attrs,‘=====‘)
16 
17         if ‘__tablename__‘ not in attrs.keys():
18             attrs[‘__tablename__‘] = name
19 
20         primarykey = []
21         for k, v in attrs.items():
22             if isinstance(v, Field):
23                 if v.fieldname is None:
24                     v.fieldname = k
25                 if v.pk:
26                     primarykey.append(v)
27         attrs[‘__primarykey__‘] = primarykey
28 
29         return super().__new__(cls, name, bases, attrs)
30 
31 class ModelBase(metaclass=ModelMeta):
32     ‘‘‘ 从 ModelBases 继承的类的类型都是ModelMeta ‘‘‘
33     pass
34 
35 class Students(ModelBase):
36     id = Field(pk=True, nullable = False)
37     name = Field(‘username‘, nullable=False)
38     age = Field()
39 
40 print(‘====================================‘)
41 print(Students.__dict__)