西游之路——python全栈——通用模块（pager、check_code、form验证）

1、验证码

import random
from PIL import Image, ImageDraw, ImageFont, ImageFilter

_letter_cases = "abcdefghjkmnpqrstuvwxy"  # 小写字母，去除可能干扰的i，l，o，z
_upper_cases = _letter_cases.upper()  # 大写字母
_numbers = ''.join(map(str, range(3, 10)))  # 数字
init_chars = ''.join((_letter_cases, _upper_cases, _numbers))


def create_validate_code(size=(120, 30),
                         chars=init_chars,
                         img_type="GIF",
                         mode="RGB",
                         bg_color=(238, 99, 99),
                         fg_color=(0, 0, 255),
                         font_size=18,
                         font_type="Monaco.ttf",
                         length=4,
                         draw_lines=True,
                         n_line=(1, 2),
                         draw_points=True,
                         point_chance=2):
    """
    @todo: 生成验证码图片
    @param size: 图片的大小，格式（宽，高），默认为(120, 30)
    @param chars: 允许的字符集合，格式字符串
    @param img_type: 图片保存的格式，默认为GIF，可选的为GIF，JPEG，TIFF，PNG
    @param mode: 图片模式，默认为RGB
    @param bg_color: 背景颜色，默认为白色
    @param fg_color: 前景色，验证码字符颜色，默认为蓝色#0000FF
    @param font_size: 验证码字体大小
    @param font_type: 验证码字体，默认为 ae_AlArabiya.ttf
    @param length: 验证码字符个数
    @param draw_lines: 是否划干扰线
    @param n_lines: 干扰线的条数范围，格式元组，默认为(1, 2)，只有draw_lines为True时有效
    @param draw_points: 是否画干扰点
    @param point_chance: 干扰点出现的概率，大小范围[0, 100]
    @return: [0]: PIL Image实例
    @return: [1]: 验证码图片中的字符串
    """
    width, height = size  # 宽高
    # 创建图形
    img = Image.new(mode, size, bg_color)
    draw = ImageDraw.Draw(img)  # 创建画笔

    def get_chars():
        """生成给定长度的字符串，返回列表格式"""
        return random.sample(chars, length)

    def create_lines():
        """绘制干扰线"""
        line_num = random.randint(*n_line)  # 干扰线条数
        for i in range(line_num):
            # 起始点
            begin = (random.randint(0, size[0]), random.randint(0, size[1]))
            # 结束点
            end = (random.randint(0, size[0]), random.randint(0, size[1]))
            draw.line([begin, end], fill=(0, 0, 0))

    def create_points():
        """绘制干扰点"""
        chance = min(100, max(0, int(point_chance)))  # 大小限制在[0, 100]
        for w in range(width):
            for h in range(height):
                tmp = random.randint(0, 100)
                if tmp > 100 - chance:
                    draw.point((w, h), fill=(0, 0, 0))

    def create_strs():
        """绘制验证码字符"""
        c_chars = get_chars()
        strs = ' %s ' % ' '.join(c_chars)  # 每个字符前后以空格隔开
        font = ImageFont.truetype(font_type, font_size)
        font_width, font_height = font.getsize(strs)

        draw.text(((width - font_width) / 3, (height - font_height) / 3),
                  strs, font=font, fill=fg_color)

        return ''.join(c_chars)

    if draw_lines:
        create_lines()
    if draw_points:
        create_points()
    strs = create_strs()
    # 图形扭曲参数
    params = [1 - float(random.randint(1, 2)) / 100,
              0,
              0,
              0,
              1 - float(random.randint(1, 10)) / 100,
              float(random.randint(1, 2)) / 500,
              0.001,
              float(random.randint(1, 2)) / 500
              ]
    img = img.transform(size, Image.PERSPECTIVE, params)  # 创建扭曲
    img = img.filter(ImageFilter.EDGE_ENHANCE_MORE)  # 滤镜，边界加强（阈值更大）
    return img, strs

需要配合 MONACO.TTF 字体使用

2、分页

class Pagination(object):
    def __init__(self,totalCount,currentPage,CurentUrl,perPageItemNum=3,maxPageNum=3,):
        # 所有数据总个数
        self.total_count = int(totalCount)
        # 当前页
        try:
            v = int(currentPage)
            if v <= 0:
                v = 1
            self.current_page = v

        except Exception as e:
            self.current_page = 1
        # 每页显示行数
        self.per_page_item_num = int(perPageItemNum)
        # 最多页面数
        self.max_page_num = int(maxPageNum)
        self.current_url = CurentUrl

    def start(self):
        return (self.current_page - 1)*self.per_page_item_num

    def end(self):
        return self.current_page*self.per_page_item_num

    @property
    def num_pages(self):
        a,b = divmod(self.total_count,self.per_page_item_num)
        if b == 0:
            return a
        return a+1

    @property
    def pager_num_range(self):
        # 当前页
        # self.current_page
        # 最多显示页码数 7
        # self.per_page_num
        # 总页数
        # self.num_pages
        # 判断最小极值
        if self.max_page_num > self.num_pages:
            # 根据当前页动态生成，设置页面显示数
            return range(1, self.num_pages + 1)
        # 总页数特别多时
        part = int(self.max_page_num/2)

        if part >= self.current_page:
            return range(1, self.max_page_num + 1)

        # 判断最大极值
        if (self.current_page + part) >= self.num_pages:
            return range(self.num_pages - self.max_page_num + 1, self.num_pages + 1)

        return range(self.current_page - part, self.current_page + part +1)

    def page_str(self):
        page_list = []

        if self.current_page ==1:
            prev = "<li><a href='#'>上一页</a></li>"
        else:
            prev = "<li><a href='%s?p=%s'>上一页</a></li>" %(self.current_url,self.current_page-1)
        page_list.append(prev)

        first = "<li><a href='%s?p=1'>首页</a></li>" % self.current_url
        page_list.append(first)

        for i in self.pager_num_range:
            if self.current_page == i:
                tem = "<li class='active'><a href='%s?p=%s'>%s</a></li>" % (self.current_url, i,i)
            else:
                tem = "<li><a href='%s?p=%s'>%s</a></li>" % (self.current_url, i, i)
            page_list.append(tem)

        last = "<li><a href='%s?p=%s'>尾页</a></li>" % (self.current_url, self.num_pages)
        page_list.append(last)

        if self.current_page == self.num_pages:
            nex = "<li><a href='#'>下一页</a>"
        else:
            nex = "<li><a href='%s?p=%s'>下一页</a></li>" % (self.current_url, self.current_page + 1)
        page_list.append(nex)

        return ''.join(page_list)

使用时需要传入三个参数

　　- 信息总数

　　- 当前页

　　- 当前url

obj_list = Pagination(article_list.count(), current_page, current_url)
    data_list = article_list[obj_list.start():obj_list.end()]

3、form验证

from django import forms
from django.forms import fields,widgets
from repository import models
from django.core.exceptions import ValidationError

class RegisterForm(forms.Form):
    username = fields.CharField(
        label='用户名',
        required=True,
        max_length=32,
        initial='请输入用户名',
        error_messages={
            'required': '用户名不能为空',
            'min_length': '用户名过短',
            'invalid': '格式错误',
        }
    )
    password = fields.CharField(
        label='密码',
        required=True,
        max_length=32,
        min_length=6,
        error_messages={
            'required': '密码不能为空',
            'min_length': '密码长度太短',
            'invalid': '格式有误',
        }
    )
    # fields.RegexField()   自定义正则
    confirm_pwd = fields.CharField(
        label='确认密码',
        required=True,
        max_length=32,
        min_length=6,
        error_messages={
            'required': '密码不能为空',
            'min_length': '密码长度太短',
            'invalid': '格式有误',
        }
    )
    email = fields.EmailField(
        widget=widgets.EmailInput(attrs={"class":"form-control","placeholder": "输入邮箱"}),
        label='邮箱',
        required=True,
        error_messages={
            'required': '不能为空',
        }
    )
    # 注意使用cleaned_data.get('username')取值
    def clean_username(self):
        ret = models.User.objects.filter(username=self.cleaned_data.get('username'))
        if not ret:
            return self.cleaned_data.get('username')
        else:
            raise ValidationError('用户名已存在')

    def clean_password(self):
        pwd = self.cleaned_data.get('password')
        if not pwd.isdigit():
            return self.cleaned_data.get('password')
        else:
            raise ValidationError('不能全是数字')

    # 验证前后密码是否一致
    def clean(self):
        password = self.cleaned_data.get('password')
        confirm_pwd = self.cleaned_data.get('confirm_pwd')
        if confirm_pwd == password:
            return self.cleaned_data
        else:
            raise ValidationError('密码输入不一致')

class LoginForm(forms.Form):
    username = fields.CharField(
        label='用户名',
        required=True,
        max_length=32,
        initial='请输入用户名',
        error_messages={
            'required': '用户名不能为空',
        }
    )
    password = fields.CharField(
        label='密码',
        required=True,
        max_length=32,
        min_length=6,
        error_messages={
            'required': '密码不能为空',
        }
    )
    def clean(self):
        user_list = models.User.objects.all().values_list('username','password')
        user_list = list(user_list)
        login_list = (self.cleaned_data.get('username'),self.cleaned_data.get('password'))
        if login_list in user_list:
            return self.cleaned_data
        else:
            raise ValidationError('用户名或密码错误')

class ArticleForm(forms.Form):
    title = fields.CharField(
        label='标题',
        widget=widgets.TextInput(attrs={'class':'form-control', 'placeholder':'标题5-32个字符'}),
        required=True,
        min_length=5,
        max_length=32,
        error_messages={
            'required':'不能为空',
            'min_length':'标题最少为5个字节',
            'max_length':'标题最少为32个字节',
        }
    )
    summary = fields.CharField(
        label='简介',
        required=True,
        widget=widgets.Textarea(attrs={'class':'form-control', 'placeholder':'简介10-64个字符'}),
        max_length=32,
        min_length=10,
        error_messages={
            'required':'不能为空',
            'min_length':'简介最少为10个字节',
            'max_length':'简介最多为64个字节',
        }
    )
    detail = fields.CharField(
        label='内容',
        required=True,
        widget=widgets.Textarea(attrs={'id':'detail','class': 'kind-content', 'placeholder': '简介32-256个字符'}),
        max_length=256,
        min_length=32,
        error_messages={
            'required': '不能为空',
            'min_length': '简介最少为32个字节',
            'max_length': '简介最少为256个字节',
        }
    )
    user_choice = models.User.objects.all().values_list('id','username')
    user = fields.IntegerField(
        label='作者',
        widget=widgets.Select(choices=user_choice, attrs={'class':'form-control'})
    )
    blog_choice = models.Blog.objects.all().values_list('id','title')
    blog = fields.IntegerField(
        label='博客',
        widget=widgets.Select(choices=blog_choice, attrs={'class':'form-control'})
    )
    tags_choice = models.Tags.objects.all().values_list('id', 'caption')
    tags = fields.IntegerField(
        label='标签',
        widget=widgets.Select(choices=tags_choice, attrs={'class':'form-control'})
    )
    category_choice = models.Category.objects.all().values_list('id','caption')
    category = fields.IntegerField(
        label='分类',
        widget=widgets.Select(choices=category_choice, attrs={'class':'form-control'})
    )

    def clean(self):
        self.cleaned_data['user_id'] = self.cleaned_data.get('user')
        self.cleaned_data['tags_id'] = self.cleaned_data.get('tags')
        self.cleaned_data['blog_id'] = self.cleaned_data.get('blog')
        self.cleaned_data['category_id'] = self.cleaned_data.get('category')
        del self.cleaned_data['user']
        del self.cleaned_data['tags']
        del self.cleaned_data['blog']
        del self.cleaned_data['category']
        return self.cleaned_data

class TroubleForm(forms.Form):
    title = fields.CharField(
        label='标题',
        required=True,
        widget=widgets.TextInput(attrs={'class':'form-control', 'placeholder':'输入标题5-32个字符'}),
        max_length=32,
        min_length=5,
        error_messages={
            'required':'标题不能为空',
            'min_length':'标题最少为5个字节',
            'invalid':'格式错误',
        }
    )
    detail = fields.CharField(
        label='内容',
        required=True,
        widget=widgets.Textarea(attrs={'id':'detail','class':'kind-content', 'placeholder':'输入内容5-256个字符'}),
        max_length=256,
        min_length=5,
        error_messages={
            'required': '内容不能为空',
            'min_length': '内容最少为5个字节',
            'invalid': '格式错误',
        }
    )

有关form组件详情：稍后更新