自定义form表单验证
一、自定义Form的原理
1.1 各种form表单验证比较
只有python提供了form表单验证，其他的都没有提供。django提供的功能还不够强大。最强大的是微软的ASP.NET！我们可以自己写一个来实现。
1.2 【不推荐】通过request.post获取用户输入内容
用户输入表单==>用户输入的检测
1）我们之前是创建一个form类
2）用户提交表单，我们通过request.post拿到数据，然后封装到Form（数据）里面
3）obj.is_valid方法，来检查用户输入的内容，跟Form（）定义的，是否匹配。
问题：
request.post 获取用户输入的内容，它知道用户输入了几个吗？
1.3 【推荐】通过自定义Form类，通过类对象来获取
1.3.1如何获取类的所有静态字段：
所以，通过request.post取数据不好，所以我们可以用form类。
如：
Form类：
u = xxxx
p = xxxx
我们先创建一个Form对象：
obj = Form()
for i in Form类中的所有东西：
问题：
Form类：这些都是静态字段,静态字段属于类。
如何获取一个类的所有静态字段？
'''
这些静态属性是属于类的
这就是通过打印类的字典，来获取类的静态属性
'''
class Foo(object):
p=123
u=456
print Foo.__dict__
# 如果要循环就是循环类的所有东西：
# for k,v in Foo类的所有东西:
'''
打印结果：
{'__module__': '__main__', 'p': 123, 'u': 456, '__dict__':
<attribute '__dict__' of 'Foo' objects>, '__weakref__': <attribute '__weakref__' of 'Foo' objects>, '__doc__': None}
'''
1.3.2 通过类对象来获取所有实例属性
'''
如果把属性写到初始化里，我们要找这些属性的话，就要找类的对象的字典了（这些属性属于类的实例）
'''
class Foo2(object):
def __init__(self):
self.u='wang'
self.p=123
# 如果要循环就是循环类的对象所有东西：
# for k,v in Foo2对象所有东西:
obj=Foo2()
print obj.__dict__
# 打印结果
# {'p': 123, 'u': wang}
# for k,v in 对象的所有东西:
1.3.3 自定义form验证原理（类对象获取对象属性）
'''
我们先定义一个类，类里面有多少字段，是我们程序员控制的。
我们可以根据Foo类来生成页面的标签！
用户提交数据的时候，我们先创建Foo类对象，然后再循环对象里所有的东西。
'''
#这里的obj为类的实例化对象
for k,v in obj.__dict__.iteritems():
print k,v # k代表属性名：如'p', v代表值：如：123
# request.POST[k] # 如果循环，来获取request.POST[k]，其实就是获取用户输入的数据
# 如果用户输入的是alex，request.POST[k]就等于alex
# 所以，我们通过循环自己的form来去前端取什么数据。是以我们在Form定义的项目为主，跟前端写多少没关系。
二、自定义Form实例1
2.1 获取用户输入的值
就是创建一个web程序，只要请求一进来，访问/index，其实就是访问MainHandler类的get方法或者post方法
目录结构如下：
运行：form_framework.py
浏览器访问：http://localhost:8888/index
这时，就执行了MainHandler类的get方法，就是渲染index.html页面
class MainHandler(tornado.web.RequestHandler): def get(self): self.render('index.html') def post(self, *args, **kwargs): host = self.get_argument('host') # 在Tornado里，获得用户的输入，都是用get_argument print host
重新运行：form_framework.py
然后输入：hostname内容,然后提交
此时python后台就打印：wang
2.2 自定义form类，打印对象的k,v
既然能获取单个属性，我们就可以循环form类对象来获取对象的所有属性（用户输入数据）
我们定义一个Form类，然后定义属性名（注意，跟form表单的name名要对应）
然后循环
class Form(object): def __init__(self): self.host = None self.ip = None self.port = None self.phone = None class MainHandler(tornado.web.RequestHandler): def get(self): self.render('index.html') def post(self, *args, **kwargs): # host = self.get_argument('host') # 在Tornado里，获得用户的输入，都是用get_argument # print host obj=Form() for k,v in obj.__dict__.iteritems(): print k,v
现在后台打印：
ip None
host None
port None
phone None
我们可以通过自定义的form来获取用户提交的数据，如果index.html，多了一个地址栏，
<p>address: <input type="text" name="address" /> </p>
但是form类里没定义，我们也不管它。
也就是我们只收集form类定义的对象属性
加上：self.get_argument(k)
def post(self, *args, **kwargs): # host = self.get_argument('host') # 在Tornado里，获得用户的输入，都是用get_argument # print host obj=Form() for k,v in obj.__dict__.iteritems(): print k,v,self.get_argument(k) # 对象的k和值，用户输入的值（通过跟form表单里的name名对应）
此时再从浏览器输入表单内容，提交
python后台打印结果：
ip None 10.0.0.1
host None wang
port None 22
phone None 123456
没有address，因为我们不管它。这样就做到了，我们在Form类里写了哪些字段，就取用户输入的哪些数据。
2.3 用正则来验证用户输入数据
我们为啥要写Form类呢?因为要做验证！
k是字段，v是form对象的值，self.get_argument(k)是用户输入的值。
我们把v改成正则表达式，我们用正则来验证用户输入的值，如果验证成功，就代表合法的，不成功就不合法。
1）我们先改写Form类，把值改成正则表达式：
class Form(object): def __init__(self): self.host = "(.*)" self.ip = "^(25[0-5]|2[0-4]\d|[0-1]?\d?\d)(\.(25[0-5]|2[0-4]\d|[0-1]?\d?\d)){3}$" self.port = '(\d+)' self.phone = '^1[3|4|5|8][0-9]\d{8}$'
然后我们，通过正则验证，如果循环过程，有一个验证不成功，flag=False，打印错误：
def post(self, *args, **kwargs):
# 在请求的时候，默认是验证成功的
flag= True
# host = self.get_argument('host') # 在Tornado里，获得用户的输入，都是用get_argument
# print host
obj=Form()
for k,v in obj.__dict__.iteritems():
# k,对象的字典
# v,对象中字段对应的值，正则
# self.get_argument(k),用户输入的值（通过跟form表单里的name名对应）
# 我们用正则来验证用户输入的值，如果验证成功，就代表合法的，不成功就不合法。
# print k,v,self.get_argument(k)
import re
if re.match(v,self.get_argument(k)): # 如果符合，则返回一个对象，如果不符合就返回一个None
pass
else:
flag = False # 在循环的过程中，一旦有一个不满足，就是false了。
if flag:
self.write('ok')
else:
self.write('error')
重启：form_framework.py
然后在表单输入错误的格式，提交后就返回error：
输入格式错误，返回：error
2.4 把验证写到form类里
因为必须从Form类里获取正则表达式，再做验证，所以，我们直接把验证写到Form类里，把MainHandler类的post只做主函数就行了。
1）首先把：or k,v in obj.__dict__.iteritems(): 移动到Form里，
这里的obj，就是Form的实例化对象，在Form里就是指self
class MainHandler(tornado.web.RequestHandler): def get(self): self.render('index.html') def post(self, *args, **kwargs): # 在请求的时候，默认是验证成功的 flag= True obj=Form() #for k,v in obj.__dict__.iteritems(): #移动到Form类里 import re if re.match(v,self.get_argument(k)): pass else: flag = False # 在循环的过程中，一旦有一个不满足，就是false了。 if flag: self.write('ok') else: self.write('error') class Form(object): def __init__(self): self.host = "(.*)" self.ip = "^(25[0-5]|2[0-4]\d|[0-1]?\d?\d)(\.(25[0-5]|2[0-4]\d|[0-1]?\d?\d)){3}$" self.port = '(\d+)' self.phone = '^1[3|4|5|8][0-9]\d{8}$' def is_valid(self): for k,v in self.__dict__.iteritems(): # 移动到这里，obj改成self import re
2）传代码：if re.match(v,self.get_argument(k)):
看上面代码
if re.match(v,self.get_argument(k)):
post函数里的self，指的是MainHandler这个类的对象，
我们把is_valid函数传个参数，request，
在is_valid函数里改写代码为：if re.match(v,request.get_argument(k)):
其实这里的request就是：MainHandler对象，
is_valid函数在MainHandler里被调用，把自己的对象self传进去。
3）把flag=True,分别定义在两个函数里
改写后的代码如下：
class Form(object): def __init__(self): self.host = "(.*)" self.ip = "^(25[0-5]|2[0-4]\d|[0-1]?\d?\d)(\.(25[0-5]|2[0-4]\d|[0-1]?\d?\d)){3}$" self.port = '(\d+)' self.phone = '^1[3|4|5|8][0-9]\d{8}$' def is_valid(self): # 在请求的时候，默认是验证成功的 flag= True for k,v in self.__dict__.iteritems(): import re import re if re.match(v,self.get_argument(k)): # 如果符合，则返回一个对象，如果不符合就返回一个None pass else: flag = False # 在循环的过程中，一旦有一个不满足，就是false了。 class MainHandler(tornado.web.RequestHandler): def get(self): self.render('index.html') def post(self, *args, **kwargs): # host = self.get_argument('host') # 在Tornado里，获得用户的输入，都是用get_argument # print host flag= True obj=Form() obj.is_valid(self) # 把自己的类对象self传到MainHandler里。 if flag: self.write('ok') else: self.write('error')
三、Form类优化
3.1 把is_valid放到基类里
在django里，每一个表单就是一个form，例如LoginForm，AssetForm。。。
在你创建很多form的时候，但是is_valid都一样。你需要在每个Form类里都写一遍吗？
不需要，你可以用基类。
class BaseForm(object): def is_valid(self): # 在请求的时候，默认是验证成功的 flag= True for k,v in self.__dict__.iteritems(): import re import re if re.match(v,self.get_argument(k)): # 如果符合，则返回一个对象，如果不符合就返回一个None pass else: flag = False # 在循环的过程中，一旦有一个不满足，就是false了。 class Form(BaseForm): def __init__(self): self.host = "(.*)" self.ip = "^(25[0-5]|2[0-4]\d|[0-1]?\d?\d)(\.(25[0-5]|2[0-4]\d|[0-1]?\d?\d)){3}$" self.port = '(\d+)' self.phone = '^1[3|4|5|8][0-9]\d{8}$' class LoginForm(object): def __init__(self): self.name= "(.*)"
3.2 正则表达式分门别类
如果多个表单有同一个正则，例如ip地址，就会重复写同样正则了。
我们可以针对每个类型的验证，单独写正则表达式类。
调用的时候，调用这个字段的正则类的对象就行了。这样就提高重用性了。
class ValidateIpv4(object):
ipv4_re = re.compile(r'^(25[0-5]|2[0-4]\d|[0-1]?\d?\d)(\.(25[0-5]|2[0-4]\d|[0-1]?\d?\d)){3}$')
class ValidatePhone(object):
phone_re = re.compile(r'^1[3|4|5|8][0-9]\d{8}$')
class Form(BaseForm):
def __init__(self):
self.host = "(.*)"
self.ip = ValidateIpv4.ipv4_re
self.port = '(\d+)'
self.phone = ValidatePhone.phone_re
3.3 验证后返回成功或失败信息
在django里，验证无论成功或者失败，都返回信息
对于IP来说，如果IP错误的话，也会有IP格式错误的提示。
在django中是这么做的：
from django import forms import re from django.core.exceptions import ValidationError def validate_ipv4(value): # ip地址 验证例如：10.1.6.10 ipv4_re = re.compile(r'^(25[0-5]|2[0-4]\d|[0-1]?\d?\d)(\.(25[0-5]|2[0-4]\d|[0-1]?\d?\d)){3}$') if not ipv4_re.match(value): # 这里做了验证，如果不成功，则报错 raise ValidationError('IP段格式错误.') # ValidationError是django的方法 class AddressPoolForm(forms.Form): getway = forms.CharField(validators=[validate_ipv4, ], # 验证ip地址 error_messages={'required': u'网关不能为空', 'invalid': u'网关格式错误'}, widget=forms.TextInput(attrs={'class': "form-control", 'placeholder': '网关'}))
那在自定义的Form里怎么做呢？
那在自定义的Form里怎么做呢？
required的值是传进来的：
required：True 表示：字段必须要填，并且验证
required：False 表示：字段可填可不填，不做验证
假如，required是False，则不做验证，直接返回值。
如果required=True：则判断：如果没有自定义'required'和'valid'错误信息，则用默认的（Field提供）
如果验证成功，则返回正则匹配的内容。
import tornado.ioloop import tornado.web import re class Field(object): def __init__(self, error_msg_dict, required): self.id_valid = False self.value = None self.error = None self.name = None self.error_msg = error_msg_dict self.required = required def match(self, name, value): self.name = name if not self.required: # 假如，required是False，则不做验证，直接返回值。 self.id_valid = True self.value = value else: if not value: # 假如用户没传值，则给出require报错信息： if self.error_msg.get('required', None): # 先看有没有自定义的'required'错误信息，有就用自定义的，没有则用默认的。 self.error = self.error_msg['required'] else: self.error = "%s is required" % name else: # 如果用户传来值，则做验证，如果验证成功，则返回匹配结果，没成功，则返回自定义（优先级高）或默认信息 ret = re.match(self.REGULAR, value) if ret: self.id_valid = True # 是正则验证成功的标识 self.value = ret.group() else: # 先看有没有自定义的'valid'错误信息，有就用自定义的，没有则用默认的。 if self.error_msg.get('valid', None): self.error = self.error_msg['valid'] else: self.error = "%s is invalid" % name # 如果required=True：则判断：如果有自定义了'required'和'valid'错误，则用自定义的 class IPField(Field): REGULAR = "^(25[0-5]|2[0-4]\d|[0-1]?\d?\d)(\.(25[0-5]|2[0-4]\d|[0-1]?\d?\d)){3}$" def __init__(self, error_msg_dict=None, required=True): error_msg = {} # {'required': 'IP不能为空', 'valid': 'IP格式错误'} if error_msg_dict: error_msg.update(error_msg_dict) # 继承基类的__init__方法,同时，把参数(error_msg,required)传给基类__init__ super(IPField, self).__init__(error_msg_dict=error_msg, required=required)
说明：
class IPField(Field):里的： # 外面传参：error_msg_dict 可以定制化错误信息！这里required默认值是True def __init__(self, error_msg_dict=None, required=True): error_msg = {} # {'required': 'IP不能为空', 'valid': 'IP格式错误'} if error_msg_dict: error_msg.update(error_msg_dict) # 把定制化的错误信息来更新error_msg这个字典（也就是定制化错误优先级最高！）
# 这时候调用IPField，就可以随意传自定义的错误信息了！required=True是默认值，可以不用传
class Form(BaseForm): def __init__(self): # required=True是默认值，可以不用传 self.ip = IPField(error_msg_dict={'required': '我的IP不能为空', 'valid': '我的IP格式错误'})
