用模块、框架实现业务功能，作为扩展的知识点。
创建类

  1. # 定义类
  2. class Foo(object):
  3.     def __init__(self, name):
  4.         self.name = name
  5.     def __new__(cls, *args, **kwargs):
  6.         return object.__new__(cls)
  8. # 根据类创建对象
  9. # 1 执行类的new方法，创建空对象     【构造方法】 {}
  10. # 2 执行类的init方法，初始化对象 【初始化方法】{name:"luffy"}
  11. obj = Foo("luffy")

对象是基础类创建的。
问题：类是谁创建的？
答案：类是由type创建。

  1. # 传统方式创建类
  2. class Foo(object):
  3.     v1 = 123
  4.     def func(self):
  5.         return 666
  6. # 非传统方式创建类
  7. Foo = type("Foo", (object,),{"v1": 123, "func":lambda self:666})
  8. # 非传统方式创建对象
  9. obj = Foo()
  10. # 非传统方式调用v1的变量
  11. print(obj.v1)
  1. # 传统方式创建类(直观)
  2. """
  3. class Foo(object):
  4.     v1 = 123
  6.     def func(self):
  7.         return 666
  8. print(Foo)
  9. """
  10. # 非传统方式（一行）
  11. # 1 创建类型
  12. #    - 类名
  13. #    - 继承类
  14. #    - 成员
  15. Fa = type("Foo", (object,), {"v1":123, "func": lambda self:666, "do":do})
  16. # 2 根据类创建对象
  17. obj = Fa()
  18. # 3 调用对象中的v1变量
  19. print(obj.v1)
  20. # 4 执行对象中的func方法
  21. result = obj.func()

类默认是以type创建，怎么让伊特类的创建改成其他的东西（元类）。

  1. # type 创建Foo类
  2. class Foo(object):
  3.     pass
  4. # 其他的东西创建类
  5. class Foo(object, metaclass=其他的东西)
  6.     pass
  1. class MyType(type):
  2.     pass
  4. class Foo(object, metaclass=MyType):
  5.     pass
  6. # Foo类由MyType创建
  1. class MyType(type):
  2.     def __init__(self, *args, **kwargs):
  3.         super().__init__(*args, **kwargs)
  5.     def __new__(cls, *args, **kwargs):
  6.         new_cls = super().__new__(cls, *args, **kwargs)
  7.         return new_cls
  9.     def __call__(self, *args, **kwargs):
  10.         # 调用自己的那个类 __new__ 方法去创建对象
  11.         empty_object = self.__new__(self)
  12.         # 调用你自己的__init__ 方法取初始化
  13.         self.__init__(empty_object, *args, **kwargs)
  14.         return empty_object
  16. class Foo(object, metaclass=MyType):
  17.     def __init__(self, name):
  18.         self.name = name
  20. # 假设Foo是一个对象 由MyType创建
  21. # Foo其实是MyType的一个对象
  22. # Foo() -> MyType对象()
  23. v1 = Foo("alex")
  24. print(v1)
  25. print(v1.name)

wtforms源码

  1. from wtforms import Form
  2. from wtforms.fields import simple
  3. class LoginForm(Form) :
  4.     name = simple.StringField(label='用户名', render_kw={'class': 'form-control'})
  5.     pwd = simple.PasswordField(label= '密码', render_kw={'class':'form-control'})
  7. form = LoginForm( )
  8. print(form.name) #类变量
  9. print(form.pwd) #类变量
  1. from wtforms import Form
  2. from wtforms.fields import simple
  4. class FormMeta(type):
  5.     def __init__(cls, name, bases, attrs):
  6.         type.__init__(cls, name, bases, attrs)
  7.         cls._unbound_fields = None
  8.         cls._Wtforms_meta = None
  10.     def __call__(cls, *args, **kwargs):
  11.         """
  12.         Construct a new Form instance .
  13.         Creates the unbound_ fields list and the internal wtforms_ meta
  14.         subclass of the class Meta in order to allow a proper inher itance
  15.         hierarchy.
  16.         """
  17.         if cls._unbound_fields is None:
  18.             fields = []
  19.             for name in dir(cls):
  20.                 if not name.startswith('_'):
  21.                     unbound_field = getattr(cls, name)
  22.                     if hasattr (unbound_field, '_formfield'):
  23.                         fields. append( (name, unbound_field))
  24.             # We keep the name as the. second element of the sort
  25.             # to ensure a stable sort.
  26.             fields .sort (key=lambda x:(x[1].creation_ounter, x[0]))
  27.             cls._unbound_fields = fields
  28.         # Create a subclass of the 'class Meta' using all the ancestors .
  29.         if cls._wtforms_meta is None:
  30.             bases=[]
  31.             for mro_class in cls.__mro__:
  32.                 if 'Meta' in mro_class.__dict__:
  33.                     bases.append(mro_class.Meta)
  34.             cls._wtforms_meta = type('Meta' , tuple(bases), {})
  35.         return type.__call__(cls, *args, **kwargs)
  37. def with_metaclass(meta, base=object):
  38.     # FormMeta("NewBase". (BaseForm,), {} )
  39.     # type( "NewBase", ( BaseForm,), {} )
  40.     return meta("NewBase", (base,), {})
  41. """
  42. class NewBase ( BaseForm, metaclass=FormMeta):
  43.     pass
  44. class Form( NewBase):
  45. """
  47. class Form(with_metaclass(FormMeta, BaseForm)):
  48.     pass
  49. # LoginForm其实是由FormMeta 创建的。
  50. # 1.创建类时，会执行FormMeta 的__new__ 和__init__，内部在类中添加了两个类变量 _unbound_fields 和_wtforms_meta
  51. class LoginForm(Form):
  52.     name = simple.StringField(label='用户名', render_kw={'class': ' form-control' })
  53.     pwd = simple.PasswordField(labe1='密码', render_kw={'class': 'form-control'})
  54. # 2.根据LoginForm类去创建对象。FormMeta._ call___ 方法 -> LoginForm中的new去创建对象，init去初始化对象。
  55. form = LoginForm( )
  56. print( form.name) # 类变量
  57. print(form.pwd) # 类变量
  58. #  问题1:此时LoginForm是由 type or FormMeta创建?
  59. """
  60. 类中metaclass,自己类由于metaclass定义的类来创建。
  61. 类继承某个类，父类metaclass, 自己类由于metaclass定义的类来创建。
  62. """

在学习元类之后，在：

  • 类创建，自定义功能

  • 对象的创建前后，自定义功能

    单例模式

    元类的方式 ```python class MyType(type): def init(self, name, bases, attrs):

    1.   super().__init__(name, bases, attrs)
    2.   self.instance = None

    def call(self, args, *kwargs):

    1.   # 1判断是否有对象， 有不穿件
    2.   if not self.instance:
    3.       self.__init__(self.instance, *args, **kwargs)
    4.   return self.instance

class Singleton(object, metaclass=MyType): pass

class Foo1(Singleton, metaclass=MyType): pass

class Foo2(Singleton): pass

v1 = Foo1() v2 = Foo1()

print(v1) print(v2) ```