第三百一十一节，Django框架，Form表单验证

表单提交

html

  1. <!DOCTYPE html>
  2. <html lang="en">
  3. <head>
  4.     <meta charset="UTF-8">
  5.     <title>Title</title>
  6.     <link rel="stylesheet" type="text/css" href="/static/css/tou.css">
  7. </head>
  8. <body>
  9. <form action="/bugarticles/" method="post">
  10.     <div>
  11.         <input type="text" name="user"/>
  12.     </div>
  13.     <div>
  14.         <input type="text" name="pwd"/>
  15.     </div>
  16.     <div>
  17.         <input type="submit" value="提交"/>
  18.     </div>
  19. </form>
  20. </body>
  21. </html>

路由映射

  1. urlpatterns = [
  2.     url(r'admin/', admin.site.urls),   #路由映射admin数据库管理
  3.     url(r'articles/', views.special)
  4. ]

逻辑处理

method属性获取用户请求方式，post或者get
使用方式：请求对象.method

POST获取用户post请求方式的信息
使用方式：请求对象.POST

POST.get()获取用户POST请求方式的表单name名称对应的值，参数是表单name名

  1. from django.shortcuts import render
  2. from app1.models import *    #导入数据库操作模块
  3.  
  4. #逻辑处理模块
  5. def special(request):  　　　　　　　　　　　　　 #自定义参数接收用户请求对象
  6.     if request.method == "POST":　　　　　　　　 #判断用户请求如果是post方式
  7.         print(request.POST.get('user',None))  #接收用户表单提交的name名称对应的值
  8.         print(request.POST.get('pwd', None))  #接收用户表单提交的name名称对应的值
  9.     return render(request, 'app1/index.html', locals())  # 打开页面

表单提交验证，获取数据与获取错误信息

1、创建表单验证模块，必须继承Django的表单验证forms.Form类

  1. #!/usr/bin/env python
  2. # -*- coding:utf-8 -*-
  3. #表单验证
  4. from django import forms        #导入Django的表单验证模块
  5.  
  6. class yhbd(forms.Form):         #自定义验证表单类，继承Django的表单验证类
  7.     user = forms.CharField()    #接收逻辑处理时，创建yhbd类时传进来的POST对象，里的表单name名对应的值进行验证
  8.     pwd = forms.CharField()     ##接收逻辑处理时，创建yhbd类时传进来的POST对象，里的表单name名对应的值进行验证

2、逻辑处理，创建表单验证模块里的验证类，并将用户请求的POST对象，传入验证类进行验证，验证后获取验证通过的提交信息，或者验证没通过的错误信息

如果出现错误，将错误信息对象以字典方式传到html页面

is_valid()返回验证是否通过的布尔值
使用方式：验证类.is_valid()

cleaned_data获取验证通过后的所有提交数据，返回字典
使用方式：验证类.cleaned_data

errors获取验证错误信息，返回所有表单的错误信息对象
使用方法：验证类.errors

  1. from django.shortcuts import render
  2. from app1.models import *    #导入数据库操作模块
  3. from app1.biaodan import *   #导入自定义表单验证模块
  4. #逻辑处理模块
  5. def special(request):
  6.     if request.method == 'GET':
  7.         return render(request, 'app1/index.html', locals())  # 打开页面
  8.  
  9.     if request.method == "POST":
  10.         # print(request.POST.get('user',None))          #接收用户表单提交的name名称对应的值
  11.         # print(request.POST.get('pwd', None))          #接收用户表单提交的name名称对应的值
  12.  
  13.         f = yhbd(request.POST)                          #创建验证表单类，将用户请求POST对象传进表单验证类进行验证
  14.  
  15.         # ret = f.is_valid()                            #返回验证是否通过
  16.         # print(ret)                                    #返回布尔值
  17.  
  18.         if f.is_valid():                                #判断验证如果通过
  19.             print(f.cleaned_data)                       #获取到用户提交信息,字典方式
  20.         else:                                           #如果没通过
  21.             print(f.errors)                             #获取错误对象
  22.  
  23.         return render(request, 'app1/index.html',{'cuow':f.errors})  # 打开页面，将错误信息用字典方式传到html页面

3、在html页面接收逻辑处理以字典形式传过来的错误对象，分别获取不同表单的错误信息

  1. <!DOCTYPE html>
  2. <html lang="en">
  3. <head>
  4.     <meta charset="UTF-8">
  5.     <title>Title</title>
  6.     <link rel="stylesheet" type="text/css" href="/static/css/tou.css">
  7. </head>
  8. <body>
  9.  
  10. <form action="/bugarticles/" method="post">
  11.     <div>
  12.         <input type="text" name="user"/>
  13.         <span>{{ cuow.user.0 }}</span>     <!-- 接收错误信息里的user的错误信息 -->
  14.     </div>
  15.     <div>
  16.         <input type="text" name="pwd"/>
  17.         <span>{{ cuow.pwd.0 }}</span>      <!-- 接收错误信息里的pwd的错误信息 -->
  18.     </div>
  19.     <div>
  20.         <input type="submit" value="提交"/>
  21.     </div>
  22. </form>
  23. </body>
  24. </html>

利用表单类自动创建表单标签

以上表单的<input>是我们自己手动写的，还可以用表单类来自动创建表单标签，好处是不用自己写表单标签，还有就是当用户填写的表单不合法提交时提示错误信息不清空表单

注意：表单类根据字段创建的表单标签，当用户输入内容时，首先要经过浏览器默认行为的表单验证，如果浏览器默认行为的表单验证都没有通过那么将无法提交

浏览器默认行为的表单验证，通过了在进行我们定义的表单类验证，验证合法获取用户提交信息，不合法返回错误信息

利用表单类自动创建表单标签

1、首先在get访问页面时，创建表单类不传参数，然后把这个表单类传到html页面，在html页面通过，表单类.字段名称，来自动创建表单标签

　　每一种表单字段类型，都有一个默认的表单标签，这个标签是可以更改的，所以表单类可以创建任何表单标签

2、在post访问时，再次创建表单类需要传参，将post请求对象传入表单类进行验证表单，如果表单不合法，将错误信息对象传到html显示错误信息，将这次创建的表单类传到html页面替换get时创建的表单类

逻辑处理

  1. from django.shortcuts import render
  2. from app1.models import *    #导入数据库操作模块
  3. from app1.biaodan import *   #导入自定义表单验证模块
  4. #逻辑处理模块
  5. def special(request):
  6.     if request.method == 'GET':
  7.         f = yhbd()                                            #创建表单验证类，不传参
  8.         return render(request, 'app1/index.html',{'form':f})  # 打开页面，并将表单验证类传到html生成表单标签
  9.  
  10.     if request.method == "POST":
  11.         f = yhbd(request.POST)                          #创建验证表单类，将用户请求POST对象传进表单验证类进行验证
  12.  
  13.         if f.is_valid():                                #判断验证如果通过
  14.             print(f.cleaned_data)                       #获取到用户提交信息,字典方式
  15.         else:                                           #如果没通过
  16.             # print(f.errors)                           #获取错误对象
  17.             pass
  18.  
  19.         return render(request, 'app1/index.html',{'cuow':f.errors,'form':f})  # 打开页面，将错误信息用字典方式传到html页面，并且将表单类传到html页面替换没传参的表单验证类

html

  1. <!DOCTYPE html>
  2. <html lang="en">
  3. <head>
  4.     <meta charset="UTF-8">
  5.     <title>Title</title>
  6.     <link rel="stylesheet" type="text/css" href="/static/css/tou.css">
  7. </head>
  8. <body>
  9.  
  10. <form action="/bugarticles/" method="post">
  11.     <div>
  12.         {{ form.user }}                                     <!-- 接收get请求时创建的表单类，生成表单标签 -->
  13.         {% if cuow.user.0 %}
  14.             <span class="cuow">{{ cuow.user.0 }}</span>     <!-- 接收错误信息里的user的错误信息 -->
  15.         {% endif %}
  16.     </div>
  17.     <div>
  18.         {{ form.pwd }}                                      <!-- 接收get请求时创建的表单类，生成表单标签 -->
  19.         {% if cuow.pwd.0 %}
  20.             <span class="cuow">{{ cuow.pwd.0 }}</span>      <!-- 接收错误信息里的pwd的错误信息 -->
  21.         {% endif %}
  22.     </div>
  23.     <div>
  24.         <input type="submit" value="提交"/>
  25.     </div>
  26. </form>
  27. </body>
  28. </html>

常用的内置验证字段

EmailField()验证邮箱字段
CharField()验证字符串字段
URLField()验证url地址字段
IntegerField()验证数字字段
GenericIPAddressField()验证IP字段

注意：虽然有很多内置验证字段，但是我们还是要根据我们自己的需求来验证，所以

验证字段的参数

required设置字段是否可以为空
　　True不可以为空
　　False可以为空

  1. #!/usr/bin/env python
  2. # -*- coding:utf-8 -*-
  3. #表单验证
  4. from django import forms        #导入Django的表单验证模块
  5.  
  6. class yhbd(forms.Form):         #自定义验证表单类，继承Django的表单验证类
  7.     user = forms.CharField(required=True)   #True不可以为空
  8.     pwd = forms.CharField()

max_length最大字符数
min_length最小字符数

  1. #!/usr/bin/env python
  2. # -*- coding:utf-8 -*-
  3. #表单验证
  4. from django import forms        #导入Django的表单验证模块
  5.  
  6. class yhbd(forms.Form):         #自定义验证表单类，继承Django的表单验证类
  7.     user = forms.CharField(max_length=4,min_length=2)
  8.     pwd = forms.CharField()

error_messages自定义错误提示信息
　　参数是一个字典{'验证名称':'错误提示'}

  1. #!/usr/bin/env python
  2. # -*- coding:utf-8 -*-
  3. #表单验证
  4. from django import forms        #导入Django的表单验证模块
  5.  
  6. class yhbd(forms.Form):         #自定义验证表单类，继承Django的表单验证类
  7.     user = forms.CharField(
  8.         required=True,
  9.         max_length=4,
  10.         min_length=2,
  11.         error_messages={
  12.             'required':'用户名不能为空',
  13.             'max_length':'最大长度不得超过4个字符',
  14.             'min_length':'最小长度不得少于2个字符'
  15.         }
  16.     )
  17.     pwd = forms.CharField()

invalid设置邮箱格式错误提示信息

  1. #!/usr/bin/env python
  2. # -*- coding:utf-8 -*-
  3. #表单验证
  4. from django import forms        #导入Django的表单验证模块
  5.  
  6. class yhbd(forms.Form):         #自定义验证表单类，继承Django的表单验证类
  7.     user = forms.CharField(
  8.         required=True,
  9.         max_length=4,
  10.         min_length=2,
  11.         error_messages={
  12.             'required':'用户名不能为空',
  13.             'max_length':'最大长度不得超过4个字符',
  14.             'min_length':'最小长度不得少于2个字符'
  15.         }
  16.     )
  17.     pwd = forms.EmailField(
  18.         error_messages={
  19.             'required': '邮箱不能为空',
  20.             'invalid':'邮箱格式不正确'
  21.         }
  22.     )

widget设置表单字段在html页面的类型
　　使用方式：widget=forms.Textarea()
　　Textarea(): <textarea>标签类型
　　TextInput()：<input>标签类型

  1. #!/usr/bin/env python
  2. # -*- coding:utf-8 -*-
  3. #表单验证
  4. from django import forms        #导入Django的表单验证模块
  5.  
  6. class yhbd(forms.Form):         #自定义验证表单类，继承Django的表单验证类
  7.     user = forms.CharField(
  8.         required=True,
  9.         max_length=4,
  10.         min_length=2,
  11.         error_messages={
  12.             'required':'用户名不能为空',
  13.             'max_length':'最大长度不得超过4个字符',
  14.             'min_length':'最小长度不得少于2个字符'
  15.         }
  16.     )
  17.     pwd = forms.CharField(
  18.         widget=forms.TextInput(),
  19.     )

attrs给表单标签设置属性，可以给标签元素设置class样式，和input标签的各种type属性

  1. #!/usr/bin/env python
  2. # -*- coding:utf-8 -*-
  3. #表单验证
  4. from django import forms        #导入Django的表单验证模块
  5.  
  6. class yhbd(forms.Form):         #自定义验证表单类，继承Django的表单验证类
  7.     user = forms.CharField(
  8.         required=True,
  9.         max_length=4,
  10.         min_length=2,
  11.         error_messages={
  12.             'required':'用户名不能为空',
  13.             'max_length':'最大长度不得超过4个字符',
  14.             'min_length':'最小长度不得少于2个字符'
  15.         }
  16.     )
  17.     pwd = forms.CharField(
  18.         widget=forms.TextInput(attrs={'type':'password','class':'c1'}),
  19.     )

Select生成表单，select标签，下拉选项框
　　参数:
　　　　choices设置下拉数据，元组类型
　　　　attrs设置select标签属性

  1. #!/usr/bin/env python
  2. # -*- coding:utf-8 -*-
  3. #表单验证
  4. from django import forms        #导入Django的表单验证模块
  5.  
  6. class yhbd(forms.Form):         #自定义验证表单类，继承Django的表单验证类
  7.     user = forms.CharField(
  8.         required=True,
  9.         max_length=4,
  10.         min_length=2,
  11.         error_messages={
  12.             'required':'用户名不能为空',
  13.             'max_length':'最大长度不得超过4个字符',
  14.             'min_length':'最小长度不得少于2个字符'
  15.         }
  16.     )
  17.  
  18.     zhi = (
  19.         (0, '普通会员'),
  20.         (1, '超级会员'),
  21.         (2, '黄金会员'),
  22.         (3, '白银会员'),
  23.         (4, 'vip会员')
  24.     )
  25.     pwd = forms.CharField(
  26.         widget=forms.widgets.Select(choices=zhi,attrs={'class':'c1'})
  27.     )

下拉框结合数据库应用

  1. #!/usr/bin/env python
  2. # -*- coding:utf-8 -*-
  3. #表单验证
  4. from django import forms        #导入Django的表单验证模块
  5. from app1.models import *       #导入数据库操作
  6.  
  7. class yhbd(forms.Form):         #自定义验证表单类，继承Django的表单验证类
  8.     user = forms.CharField(
  9.         required=True,
  10.         max_length=4,
  11.         min_length=2,
  12.         error_messages={
  13.             'required':'用户名不能为空',
  14.             'max_length':'最大长度不得超过4个字符',
  15.             'min_length':'最小长度不得少于2个字符'
  16.         }
  17.     )
  18.  
  19.     a = shengf.objects.all().values_list('id','shf') #获取数据库里shengf表里的id和shf字段的数据
  20.     pwd = forms.CharField(
  21.         widget=forms.widgets.Select(choices=a,attrs={'class':'c1'}) #将数据库的数据显示到下拉框
  22.     )

下拉框结合数据库应用，防止数据库添加了数据，或者删除了数据，页面缓存了下拉框数据，无法事实数据同步

  1. #!/usr/bin/env python
  2. # -*- coding:utf-8 -*-
  3. #表单验证
  4. from django import forms        #导入Django的表单验证模块
  5. from app1.models import *       #导入数据库操作
  6.  
  7. class yhbd(forms.Form):         #自定义验证表单类，继承Django的表单验证类
  8.     user = forms.CharField(
  9.         required=True,
  10.         max_length=4,
  11.         min_length=2,
  12.         error_messages={
  13.             'required':'用户名不能为空',
  14.             'max_length':'最大长度不得超过4个字符',
  15.             'min_length':'最小长度不得少于2个字符'
  16.         }
  17.     )
  18.  
  19.     a = shengf.objects.all().values_list('id','shf') #获取数据库里shengf表里的id和shf字段的数据
  20.     pwd = forms.CharField(
  21.         widget=forms.widgets.Select(choices=a,attrs={'class':'c1'}) #将数据库的数据显示到下拉框
  22.     )
  23.  
  24.     #防止数据库添加了数据，或者删除了数据，页面缓存了下拉框数据，无法事实数据同步
  25.     def __init__(self,*args, **kwargs):                                     #创建类的__init__方法，每次创建类时都会执行
  26.         super(yhbd,self).__init__(*args, **kwargs)                          #获取当前类的父类里的__init__方法执行
  27.         a = shengf.objects.all().values_list('id', 'shf')                   #重新获取数据库里shengf表里的id和shf字段的数据
  28.         self.fields['pwd'] = forms.CharField(widget=forms.widgets.Select(choices=a,attrs={'class':'c1'}))  #更新一下表单pwd字段的数据

自定义验证规则

validators设置自定义验证规则，参数是一个列表，列表里是自定义验证方法名称

  1. #!/usr/bin/env python
  2. # -*- coding:utf-8 -*-
  3. #表单验证
  4. from django import forms        #导入Django的表单验证模块
  5. from django.core.exceptions import ValidationError
  6. import re
  7.  
  8. class yhbd(forms.Form):         #自定义验证表单类，继承Django的表单验证类
  9.     user = forms.CharField(
  10.         required=True,
  11.         max_length=4,
  12.         min_length=2,
  13.         error_messages={
  14.             'required':'用户名不能为空',
  15.             'max_length':'最大长度不得超过4个字符',
  16.             'min_length':'最小长度不得少于2个字符'
  17.         }
  18.     )
  19.  
  20.     #自定义验证规则
  21.     def shouji(value):
  22.         mobile_re = re.compile(r'^(13[0-9]|15[012356789]|17[678]|18[0-9]|14[57])[0-9]{8}$')
  23.         if not mobile_re.match(value):
  24.             raise ValidationError('手机号码格式错误')   #如果不匹配返回错误信息
  25.  
  26.     pwd = forms.CharField(
  27.         validators=[shouji, ],   #设置自定义验证规则
  28.         required=True,
  29.         widget=forms.TextInput(
  30.             attrs={
  31.                 'class': "cl",
  32.                 'placeholder': u'手机号码'
  33.             }
  34.         ),
  35.         error_messages={
  36.             'required':'手机不能为空',
  37.         }
  38.     )

其他

  1. #!/usr/bin/env python
  2. # -*- coding:utf-8 -*-
  3. import re
  4. from django import forms
  5. from django.core.exceptions import ValidationError
  6.  
  7. def mobile_validate(value):
  8.     mobile_re = re.compile(r'^(13[0-9]|15[012356789]|17[678]|18[0-9]|14[57])[0-9]{8}$')
  9.     if not mobile_re.match(value):
  10.         raise ValidationError('手机号码格式错误')
  11.  
  12. class PublishForm(forms.Form):
  13.  
  14.     user_type_choice = (
  15.         (0, u'普通用户'),
  16.         (1, u'高级用户'),
  17.     )
  18.  
  19.     user_type = forms.IntegerField(widget=forms.widgets.Select(choices=user_type_choice,
  20.                                                                   attrs={'class': "form-control"}))
  21.  
  22.     title = forms.CharField(max_length=20,
  23.                             min_length=5,
  24.                             error_messages={'required': u'标题不能为空',
  25.                                             'min_length': u'标题最少为5个字符',
  26.                                             'max_length': u'标题最多为20个字符'},
  27.                             widget=forms.TextInput(attrs={'class': "form-control",
  28.                                                           'placeholder': u'标题5-20个字符'}))
  29.  
  30.     memo = forms.CharField(required=False,
  31.                            max_length=256,
  32.                            widget=forms.widgets.Textarea(attrs={'class': "form-control no-radius", 'placeholder': u'详细描述', 'rows': 3}))
  33.  
  34.     phone = forms.CharField(validators=[mobile_validate, ],
  35.                             error_messages={'required': u'手机不能为空'},
  36.                             widget=forms.TextInput(attrs={'class': "form-control",
  37.                                                           'placeholder': u'手机号码'}))
  38.  
  39.     email = forms.EmailField(required=False,
  40.                             error_messages={'required': u'邮箱不能为空','invalid': u'邮箱格式错误'},
  41.                             widget=forms.TextInput(attrs={'class': "form-control", 'placeholder': u'邮箱'}))

注意：如果表单是通过Ajax提交的，页面不刷新，那么html页面将无法获取到错误信息，那么我们只能将所有错误信息构造成字典，然后以json的方式返回给Ajax，添加到页面

将models数据库表类转换成表单验证类【必要使用】

这样可以少写表单验证代码，使用的是数据库字段的验证规则

models.py

  1. from django.db import models        # 导入models对象
  2.  
  3. class CourseOrg(models.Model):
  4.     name = models.CharField(max_length=50, verbose_name='机构名称')
  5.     desc = models.TextField(verbose_name='机构描述')
  6.     category = models.CharField(max_length=20, verbose_name='机构类别', default='pxjg', choices=(('pxjg', '培训机构'), ('gx', '高校'), ('gr', '个人')))
  7.     click = models.IntegerField(default=0, verbose_name='点击数')
  8.     fav_nums = models.IntegerField(default=0, verbose_name='收藏数')
  9.     image = models.ImageField(upload_to='org/%Y/%m', storage=ImageStorage(), verbose_name='封面图', max_length=100)
  10.     address = models.CharField(max_length=150, verbose_name='机构地址')
  11.     city = models.ForeignKey(CityDict, verbose_name='外键城市表')
  12.     add_time = models.DateTimeField(default=datetime.now, verbose_name='添加日期')
  13.  
  14.     class Meta:
  15.         verbose_name = '课程机构表'
  16.         verbose_name_plural = verbose_name
  17.  
  18.     def __str__(self):
  19.         return self.name

forms.py

  1. #!/usr/bin/env python
  2. # -*- coding:utf8 -*-
  3. from django import forms                             # 导入Django的表单验证模块
  4. from app_organization.models import CourseOrg        # 导入数据库表类
  5.  
  6. class CourseOrgForm(forms.ModelForm):
  7.     zdyi = forms.CharField()                         # 自定义表单验证字段
  8.  
  9.     class Meta:
  10.         model = CourseOrg                            # 设置要将数据库表类转换成表单验证类的名称
  11.         fields = ['name','category','fav_nums']      # 要使用的字段

第三百一十一节，Django框架，Form表单验证的更多相关文章

  1. web框架-（六）Django补充---form表单验证

    一.form表单验证 1. 常规html页面的form表单验证 常规页面中,如果想实现对表单中用户输入信息的数据验证,需要配合Ajax来实现. 使用前我们先来熟悉下函数参数:request,其中包含的 ...

  2. Day19 Django之Form表单验证、CSRF、Cookie、Session和Model操作

    一.Form表单验证 用于做用户提交数据的验证1.自定义规则 a.自定义规则(类,字段名==html中的name值)b.数据提交-规则进行匹配代码如下: """day19 ...

  3. django之form表单验证

    django中的Form一般有两种功能: 输入html 验证用户输入 #!/usr/bin/env python # -*- coding:utf- -*- import re from django ...

  4. Django框架form表单配合ajax注册

    总结一下,其实form组件的主要功能如下: 生成页面可用的HTML标签 对用户提交的数据进行校验 保留上次输入内容 下面是写的登录页面的实例 1:views视图中的代码 # 注册页面 def regi ...

  5. Django的Form表单验证

    Form(from django import forms) 简短理解:后端提供了一个类:from django import forms,继承此类定义子类.子类中定义和form表单中提交到name名 ...

  6. Django之form表单验证顺序

    概述 django框架提供了一个forms类,来处理web开发中的表单相关事项.众所周知,form最常做的是对用户输入的内容进行验证,为此django的forms类提供了全面的内容验证支持. 验证过程 ...

  7. Django框架form表单的那些事儿

    Form那些事儿 创建Form类时,主要涉及到 [字段] 和 [插件],字段用于对用户请求数据的验证,插件用于自动生成HTML; 1:initial 初始值,input框里面的初始值. class L ...

  8. Django中的Form表单验证

    回忆一下Form表单验证的逻辑: 前端有若干个input输入框,将用户输入内容,以字典传递给后端. 后端预先存在一个Form表单验证的基类,封装了一个检测用户输入是否全部通过的方法.该方法会先定义好错 ...

  9. python_way day19 HTML-day5 （form表单验证，CSRF,cookie，session,缓存）

    python-way day19 1. dJango的form表单验证 2.CSRF 跨站请求伪造 3.cookie,session 4.缓存 一,django表单验证功能 1.django验证基础: ...

  10. 6.4-6.5 使用form表单验证，完善登录页面

    之前是使用自定义的类来实现登录逻辑,现在使用django内置的form表单验证,用继承django的view来实现登录页面. users > views.py 的内容是: from django ...

随机推荐

  1. Python asin() 函数

    描述 asin() 返回x的反正弦弧度值. 语法 以下是 asin() 方法的语法: import math math.asin(x) 注意:asin()是不能直接访问的,需要导入 math 模块,然 ...

  2. sqlserver把小数点后面多余的0去掉

    Sql中想把小数点后多余的0去掉,怎么办? select 5000/10000.0 --想变成0.5select 5500/10000.0 --想变成0.55select 5550/10000.0 - ...

  3. ubuntu为python处理图片安装图片数据增强库imgaug

    1 依赖Required dependencies: six numpy scipy scikit-image (pip install -U scikit-image) OpenCV (i.e. c ...

  4. Win7中安装Windows PowerShell 3.0

    win7内置的powershell是2.0,现在已经明显落伍了,但win系统软件更新,需要解决依赖问题,so,按下面步骤安装即可. 1. 安装Microsoft .NET Framework 4.0的 ...

  5. 使用vim-latex排版

    前几天在某个群上看到了一篇简历,内容不重要,一看排版很漂亮的说.一问才知道是用latex排版工具排版的.一想到我都大三下学期的,也快大四了,是不是要准备一份简历.于是就想使用latex这个排版工具来排 ...

  6. angular学习笔记(二十)-表单验证

    本篇主要介绍angular中的表单验证: 表单验证主要有以下一些内容: 1. required指令: 相当于html5的required属性,验证不能为空 2. ng-maxlength属性: 验证内 ...

  7. C++ 容器类 vector使用

    vector(向量): C++中的一种数据结构,确切的说是一个类.它相当于一个动态的数组,当程序员无法知道自己需要的数组的规模多大时,用其来解决问题可以达到最大节约空间的目的. 用法: 1.文件包含: ...

  8. sublime php插件

    1. Package Control Get Package Control here. 2. Theme - Phoenix   and  Flatland(扁平) If Sublime Text ...

  9. Tomcat的URL中文乱码解决以及传输优化

    默认的tomcat容器如果直接使用get方式在url中传中文时,传到后台接收会是乱码. 乱码问题 原因: tomcat默认的在url传输时是用iso8859-1编码. 解决方案一: 在使用get传输参 ...

  10. C#中模拟用户登陆SharePoint网站

    自动化测试一个SharePoint网站,首先要登陆,我们今天就模拟一下用户登陆SharePoint网站的过程,这一过程可以通过其他方式完成模拟,比如通过Coded UI Test录制脚本会更方便,但是 ...