flask--Wtform

class MyType(type):
    def __init__(self,*args,**kwargs):
        print('xxxx')
        super(MyType,self).__init__(*args,**kwargs)

    def __call__(cls, *args, **kwargs):
        obj = cls.__new__(cls,*args, **kwargs)
        cls.__init__(obj,*args, **kwargs) # Foo.__init__(obj)
        return obj

def with_metaclass(base):
    return MyType("MyType",(base,),{})

class Foo(with_metaclass(object)):
    def __init__(self,name):
        self.name = name

class Form(with_metaclass(FormMeta, BaseForm)):   #相当于给这个form类定义了一个makeclass,这个类在刚创建时，先执行makeclass,这行makeclass的__init__方法
        pass


def with_metaclass(meta, base=object):
     #meta=FormMeta(("NewBase", (BaseForm,), {}))    #实例化了这个类
     #base=BaseForm   (base继承了BaseForm)
    return meta("NewBase", (base,), {})

class LoginForm(Form):    #当执行到这一句是，他在formdata这个类中，LoginForm这个类中 里边有（LoginForm._unbound_fields = None
        LoginForm._wtforms_meta = None这两个字段）
    name=simple.StringField(           #name实例化一个StringField(如果这个name中有makeclass这个类先要执行makeclass这个类，一个类在实例化__init__之前 有__new__,__call__,type,这几个方法，
                                       对一个类来说整个请求进来先执行type的__init__方法，实例化的时候先执行type的__call__方法，有type的__call__方法调用类的 __new__方法，然后在执行类的__init__方法，这才叫实例化完成。对与这个StringField类方法，
                                       如果有__new__方法，先执行__new__方法，点击进去找到它的new方法，最开始写的是StringField但正真的最开始是name=UnboundField(cls, *args, **kwargs)
                                        (name对应的是UnboundField)在这个UnboundField中封装creation_counter，它就等于当前creation_counter自加1)
        label='用户名',
        validators=[
            validators.DataRequired(message='用户名不能为空'),
            validators.Length(min=5,max=15,message='用户名的长度必须大于5且小于15')
        ],
        widget=widgets.TextInput(),
        render_kw={'class':'form-control'}
    )
    pwd=simple.PasswordField(      #（在执行这个是pwd=UnboundField(cls, *args, **kwargs)但是当他执行时UnboundField中的creation_counter这个静态字段已经被更新，
                                      用creation_counter这个来计数是因为跟你以后在页面上显示的次序有关系）
        label='密码',
        validators=[
            validators.DataRequired(message='密码不能为空'),
            validators.Length(min=6,max=15,message='密码的长度必须大于6且小于15')
        ],
        widget=widgets.TextInput(),
        render_kw={'class':'form-control'}
    )

from wtforms import Form

from wtforms.fields import html5
from wtforms.fields import simple

from wtforms import widgets

from wtforms import validators

from flask import Flask,request,render_template,redirect

from wtforms import Form
from wtforms import widgets
from wtforms import validators

from wtforms.fields import core
from wtforms.fields import simple
from wtforms.fields import html5

app = Flask(__name__)

class LoginForm(Form):
    name=simple.StringField(
        label='用户名',
        validators=[
            validators.DataRequired(message='用户名不能为空'),
            validators.Length(min=5,max=15,message='用户名的长度必须大于5且小于15')
        ],
        widget=widgets.TextInput(),
        render_kw={'class':'form-control'}
    )
    pwd=simple.PasswordField(
        label='密码',
        validators=[
            validators.DataRequired(message='密码不能为空'),
            validators.Length(min=6,max=15,message='密码的长度必须大于6且小于15')
        ],
        widget=widgets.TextInput(),
        render_kw={'class':'form-control'}
    )


@app.route('/login',methods=['GET','POST'])
def login():
    #程序刚进来是get请求，对
    if request.method=='GET':
    #程序刚进来是get请求先实例化form=LoginForm(),先执行type的__call__方法（有__call__就执行，没有就跳过不执行，它的内部执行了接下来执行LoginForm
     的__new__方法，再走LoginForm de __init__方法）
       
      #页面标签数据初始化：data=字典,obj=对象.字段，formdata有getlist方法 
        form=LoginForm()
        return render_template('login.html',form=form)
    else:
        form=LoginForm(formdata=request.form)
        if form.validate():
            print('用户提交的数据通过格式验证，提交的值为：',form.data)
        else:
            print(form.errors)
        return render_template('login.html',form=form)


if __name__ == '__main__':
    app.run()

“先执行__call__方法” 

   def __call__(cls, *args, **kwargs):
        """
        Construct a new `Form` instance.

        Creates the `_unbound_fields` list and the internal `_wtforms_meta`
        subclass of the class Meta in order to allow a proper inheritance
        hierarchy.
        """
        if cls._unbound_fields is None:
            fields = []
            for name in dir(cls):   #（cls是LoginForm这个类，dir把这个类的所有字段都拿到）
                if not name.startswith('_'):   #（判断如果以'_'开头）
                  #获取静态字段的值：Unbound_Field对象
                    unbound_field = getattr(cls, name)   #（拿到Unbound_Field的对象）
                    if hasattr(unbound_field, '_formfield'): 
                        fields.append((name, unbound_field))#(fields这个列表里面是一个元组，元组里面一个是它的名称，一个是它的Unbound_field对象,每个
                                                               Unbound_field对象有creation_counter用来计数)

# We keep the name as the second element of the sort 
                  # to ensure a stable sort. 
            fields.sort(key=lambda x: (x[1].creation_counter, x[0]))  #优先按照Unbound_field的count数来排序 ，fieldsshi 排序过后的字段
            cls._unbound_fields = fields 
# Create a subclass of the 'class Meta' using all the ancestors.
           if cls._wtforms_meta is None: bases = [] 
                 for mro_class in cls.__mro__:     #找到所有的继承关系，相当于继承所有的类
                     if 'Meta' in mro_class.__dict__:    #mro_class.dict__ 就是；类中的所有成员
                           bases.append(mro_class.Meta) 
                           cls._wtforms_meta = type('Meta', tuple(bases), {})   #type('Meta')表示。自己创建一个Meta类继承bases

           return type.__call__(cls, *args, **kwargs)

'执行login的__new__方法，没有__new__方法执行它的__init__方法'

def __init__(self, formdata=None, obj=None, prefix='', data=None, meta=None, **kwargs):
   
    meta_obj = self._wtforms_meta()   #原来创建的Meta类（实例化meta）
    if meta is not None and isinstance(meta, dict):
        meta_obj.update_values(meta)
    super(Form, self).__init__(self._unbound_fields, meta=meta_obj, prefix=prefix)

    for name, field in iteritems(self._fields):
        # Set all the fields to attributes so that they obscure the class
        # attributes with the same names.
        setattr(self, name, field)
    self.process(formdata, obj, data=data, **kwargs)

class BaseForm(object):
    """
    Base Form Class.  Provides core behaviour like field construction,
    validation, and data and error proxying.
    """

    def __init__(self, fields, prefix='', meta=DefaultMeta()):
        """
        :param fields:
            A dict or sequence of 2-tuples of partially-constructed fields.
        :param prefix:
            If provided, all fields will have their name prefixed with the
            value.
        :param meta:
            A meta instance which is used for configuration and customization
            of WTForms behaviors.
        """
        if prefix and prefix[-1] not in '-_;:/.':
            prefix += '-'

        self.meta = meta
        self._prefix = prefix
        self._errors = None
        self._fields = OrderedDict()

        if hasattr(fields, 'items'):
            fields = fields.items()

        translations = self._get_translations()
        extra_fields = []
        if meta.csrf:
            self._csrf = meta.build_csrf(self)
            extra_fields.extend(self._csrf.setup_form(self))

        for name, unbound_field in itertools.chain(fields, extra_fields):
            options = dict(name=name, prefix=prefix, translations=translations)
            #对每一个UNbound中的字段进行实例化
            field = meta.bind_field(self, unbound_field, options)
            self._fields[name] = field

get执行完现在开始校验    
def validate(self):
        """
        Validates the form by calling `validate` on each field, passing any
        extra `Form.validate_<fieldname>` validators to the field validator.
        """
        extra = {}
        for name in self._fields:   #_fields是所有的字段
            inline = getattr(self.__class__, 'validate_%s' % name, None)
            if inline is not None:
                extra[name] = [inline]

        return super(Form, self).validate(extra)   #调用父类的validate