Django-6

Django-6

在表中批量新增记录的两种方式

第一种

def add_msg(request):
    for i in range(1000):
        models.Book.objects.create(title='第%s本书'%i)
    return HttpResponse('数据全部插入成功！')
'''
这种插入方式每次插入时都访问一次数据库，并且在数据表中新增记录的时间本来就过长，当批量新增记录条数过多时，往往延迟过高，并且频繁访问数据库会造成数据压力过大，效率极低，所以不推荐使用。
'''

第二种(bulk_create)

def add_msg(request):
    book_list = []
    for i in range(100000):
        book_list.append(models.Book('title'=''第%s本书'%i'))
    models.Book.objects.bulk_create(book_list)
'''
这种批量插入方式有效的解决了插入数据的时间延迟问题，事先定义一个空列表，然后for循环将实例化得到的数据对象保存在列表中，然后循环结束后利用bulk_create一次性将列表中的对象插入数据库，这样，无论数据有多少条，插入记录的sql始终只有一条，既减轻了访问数据库的次数，又能减轻数据库的压力，因此效率很高。
'''

自定义简易分页器

def add_msg(request):
    # 获取用户想要访问的当前页码数
    current_page = request.GET.get('page',1)
    current_page = int(current_page)
    # 每页展示的数据个数
    per_page_num = 10
    # 定义起始位置和终止位置
    start_page = (current_page-1)*per_page_num
    end_page = current_page * per_page_num
    # 统计数据的总条数
    book_queryset = models.Book.objects.all()
    all_count = book_queryset.count()
    # 求数据到底需要多少页才能展示完
    page_num , more = divmod(all_count,per_page_num)

    if more:
        page_num += 1
    page_html = ''
    xxx = current_page
    if current_page<6:
        current_page = 6
    for i in range(current_page-5,current_page+6):
        if xxx == i:
            page_html += '<li class="active"><a href="?page=%s">%s</a></li>' % (i, i)
        else:
            page_html += '<li><a href="?page=%s">%s</a></li>' % (i, i)
    book_queryset = book_queryset[start_page:end_page]
    return render(request,'add_msg.html',locals())

# 前端     
<body>
{% for foo in book_queryset %}
<p>{{ foo.title }}………………{{ foo.author }}</p>
{% endfor %}
<nav aria-label="Page navigation">
  <ul class="pagination">
    <li>
      <a href="#" aria-label="Previous">
        <span aria-hidden="true">&laquo;</span>
      </a>
    </li>
    {{ page_html|safe }}
    <li>
      <a href="#" aria-label="Next">
        <span aria-hidden="true">&raquo;</span>
      </a>
    </li>
  </ul>
</nav>
</body>

利用封装好的分页器

'''
在app下，新建一个utils文件夹，任意新建一个py文件，将此代码复制到此py文件中。
'''
class Pagination(object):
    def __init__(self, current_page, all_count, per_page_num=10, pager_count=11):
        """
        封装分页相关数据
        :param current_page: 当前页
        :param all_count:    数据库中的数据总条数
        :param per_page_num: 每页显示的数据条数
        :param pager_count:  最多显示的页码个数

        用法:
        queryset = model.objects.all()
        page_obj = Pagination(current_page,all_count)
        page_data = queryset[page_obj.start:page_obj.end]
        获取数据用page_data而不再使用原始的queryset
        获取前端分页样式用page_obj.page_html
        """
        try:
            current_page = int(current_page)
        except Exception as e:
            current_page = 1

        if current_page < 1:
            current_page = 1

        self.current_page = current_page

        self.all_count = all_count
        self.per_page_num = per_page_num

        # 总页码
        all_pager, tmp = divmod(all_count, per_page_num)
        if tmp:
            all_pager += 1
        self.all_pager = all_pager

        self.pager_count = pager_count
        self.pager_count_half = int((pager_count - 1) / 2)

    @property
    def start(self):
        return (self.current_page - 1) * self.per_page_num

    @property
    def end(self):
        return self.current_page * self.per_page_num

    def page_html(self):
        # 如果总页码 < 11个：
        if self.all_pager <= self.pager_count:
            pager_start = 1
            pager_end = self.all_pager + 1
        # 总页码  > 11
        else:
            # 当前页如果<=页面上最多显示11/2个页码
            if self.current_page <= self.pager_count_half:
                pager_start = 1
                pager_end = self.pager_count + 1

            # 当前页大于5
            else:
                # 页码翻到最后
                if (self.current_page + self.pager_count_half) > self.all_pager:
                    pager_end = self.all_pager + 1
                    pager_start = self.all_pager - self.pager_count + 1
                else:
                    pager_start = self.current_page - self.pager_count_half
                    pager_end = self.current_page + self.pager_count_half + 1

        page_html_list = []
        # 添加前面的nav和ul标签
        page_html_list.append('''
                    <nav aria-label='Page navigation>'
                    <ul class='pagination'>
                ''')
        first_page = '<li><a href="?page=%s">首页</a></li>' % (1)
        page_html_list.append(first_page)

        if self.current_page <= 1:
            prev_page = '<li class="disabled"><a href="#">上一页</a></li>'
        else:
            prev_page = '<li><a href="?page=%s">上一页</a></li>' % (self.current_page - 1,)

        page_html_list.append(prev_page)

        for i in range(pager_start, pager_end):
            if i == self.current_page:
                temp = '<li class="active"><a href="?page=%s">%s</a></li>' % (i, i,)
            else:
                temp = '<li><a href="?page=%s">%s</a></li>' % (i, i,)
            page_html_list.append(temp)

        if self.current_page >= self.all_pager:
            next_page = '<li class="disabled"><a href="#">下一页</a></li>'
        else:
            next_page = '<li><a href="?page=%s">下一页</a></li>' % (self.current_page + 1,)
        page_html_list.append(next_page)

        last_page = '<li><a href="?page=%s">尾页</a></li>' % (self.all_pager,)
        page_html_list.append(last_page)
        # 尾部添加标签
        page_html_list.append('''
                                           </nav>
                                           </ul>
                                       ''')
        return ''.join(page_html_list)

使用：

# 后端
from app.utils.mypage import Pagination
# 使用封装好的分页器代码
def login(request):
    book_queryset = models.Book.objects.all()
    current_page = request.GET.get('page',1)
    all_count = book_queryset.count()
    # 1.实例化产生对象
    page_obj = Pagination(current_page=current_page,all_count=all_count)
    # 2.对真实数据进行切片操作
    page_queryset = book_queryset[page_obj.start:page_obj.end]
    return render(request,'login.html',locals())

# 前端
{% for book_obj in page_queryset %}
    <p>{{ book_obj.title }}</p>
{% endfor %}
{{ page_obj.page_html|safe }}

创建多对多表关系的三种方式

全自动(***)

利用Django提供的ManyToMany字段
好处在于Django orm会自动帮你创建第三张关系表
但是它智慧帮你创建两个表的关系字段，不会再额外添加字段
虽然很方便，但是第三张表的扩展性比较差，无法随意的添加额外的字段，例如两张表新建关系时的日期等待...

class Book(models.Model):
    ...
    authors = models.ManyToManyField(to='Author')

class Author(models.Models):
    ...

纯手动(*)

手动创建第三张表
好处在于第三张表可以任意的添加额外的字段，完全由自身所控制。
但是手动创建的第三张表在orm查询时，很多方法都不支持，数据查询的时候非常麻烦。

class Book(models.Model):
    ...
class Author(models.Models):
    ...
class Book2Author(models.Model):
    book_id = models.ForeignKey(to='Book')
    author_id = models.ForeignKey(to='Author')
    create_time = models.DateField(auto_now_add=True)
    ...

半自动

手动建表，但是需要告诉orm，这第三张表是你手动建的。
orm只需要给我提供方便的查询方法
优点：可以使用orm查询方法
缺点：不支持add(),set(),remove(),clear()

class Book(models.Model):
    ...
    authors = models.ManyToManyField(to='Author',       through='Book2Author', through_fields=('book','author'))

class Author(models.Model):
    ...
    books = models.ManyToManyField(to='Book', through='Book2Author', through_fields=('author', 'book'))

class Book2Author(models.Model):
    book = models.ForeignKey(to='Book')
    author = models.ForeignKey(to='Author')
    create_time = models.DateField(auto_now_add=True)
    ...

注意：

半自动一定要加两个额外的参数
- through/through_fields
through_fields参数里添加字段的顺序
- 由第三张表通过那个字段查询单表，就把哪个字段放前面。

Form组件

我们之前在HTML页面中利用form表单向后端提交数据时，都会写一些获取用户输入的标签并且用form标签把它们包起来。

与此同时我们在好多场景下都需要对用户的输入做校验，比如校验用户是否输入，输入的长度和格式等正不正确。如果用户输入的内容有错误就需要在页面上相应的位置显示对应的错误信息.。

Django form组件就实现了上面所述的功能。

总结一下，其实form组件的主要功能如下:

生成页面可用的HTML标签
对用户提交的数据进行校验
展示错误信息并保留上次输入内容

不用form组件指定input输入规范

注册功能
用户输入的用户名中不能包含傻逼
如果包含了就提示用户输入的内容不符合社会主义核心价值观
用户输入的密码不能小于三位
如果密码少于三位提示用户密码太短了

def reg(request):
    back_dic = {"username":'','password':''}
    if request.method == 'POST':
        username = request.POST.get('username')
        password = request.POST.get('password')
        if '傻逼' in username:
            # 提示信息
            back_dic['username'] = '不符合社会主义核心价值观'
        if len(password) < 3:
            # 提示信息
            back_dic['password'] = '密码不能少于三位'
    return render(request,'reg.html',locals())

<form action="" method="post">
    <p>username:
        <input type="text" name="username">
        <span style="color: red">{{ back_dic.username }}</span>
    </p>
    <p>password:<input type="text" name="password">
    <span style="color: red">{{ back_dic.password }}</span>
    </p>
    <input type="submit">
</form>

form组件的使用

必须先自定义个类(与orm建表类似)

from django import forms
class MyRegForm(forms.Form):
    username = forms.CharField(min_length=3,max_length=8)
    password = forms.CharField(min_length=3,max_length=8)
    email = forms.EmailField()

如何校验数据

from app import views
# 给自定义类传一个字典，生成一个对象
obj = views.MyRegForm({'username':'jason','password':'12','email':'123'})
# 1.判断数据是否全部合法,只有数据全部符合规范才会是True
obj.is_vaild()
# 2.查看校验后的符合检验规则的数据
obj.cleaned_data
# 3.查看不符合校验规则的数据以及不符合的原因是什么
obj.errors  # 错误信息已列表存储，因为错误信息可能有多个。
{
    'password': ['Ensure this value has at least 3 characters (it has 2).'],
    'email': ['Enter a valid email address.']
}
# 5.校验数据时，默认情况下，类里面所有的字段都必须传值
obj = views.MyRegForm({'username':'jason','password':'123'})
obj.is_valid()
# False
obj.errors
# {'email': ['This field is required.']}
# 6.默认情况下，可以多传值，但是绝对不能少传，因为校验规则只在传的字典里找要校验的键，没有的话就报错，如果多了的话，不再进行校验，所以传多了不影响。
obj = views.MyRegForm({'username':'jason','password':'1233','email':'123@qq.com','xxx':'ooo'})
obj.is_valid()
# True

如何渲染页面

forms组件只会帮你渲染获取用户输入的标签，提交按钮需要你自己手动写。

三种方式

<p>第一种渲染前端页面的方式:封装程度太高了 标签样式及参数不方便调整 可扩展性差(不推荐使用)
    {{ form_obj.as_p }}
    {{ form_obj.as_ul }}
</p>

<p>第二种渲染页面的方式:扩展性较高 不足之处在于 需要你手写的代码量比较多(不推荐使用)</p>
<p>
    {{ form_obj.username.label }}{{ form_obj.username }}
</p>
<p>
    {{ form_obj.password.label }}{{ form_obj.password }}
</p>
<p>
    {{ form_obj.email.label }}{{ form_obj.email }}
</p>

<p>第三种渲染前端页面的方式:代码量和扩展性都很高(推荐使用)</p>
{% for foo in form_obj %}
<p>{{ foo.label }}{{ foo }}</p>
{% endfor %}

如何展示错误信息

首先要取消前端帮我们做的校验，因为校验数据通常是前后端都有校验，只有前端校验太不安全，因为前端页面在浏览器可以被任意更改，所以，前端校验可有可无，只要后端有叫稳定的校验方式即可。

取消前端的校验，只需在form表单中添加一个参数novalidate即可。

<form action='' method='post' novalidate>

展示错误信息：用对象obj.errors.0

因为obj.error里存放的是列表，索引0取出第一个错误信息。

<form action="" method="post" novalidate>
    {% for foo in form_obj %}
    <p>
        {{ foo.label }}:{{ foo }}
        <span style="color: red">{{ foo.errors.0 }}</span>
    </p>
    {% endfor %}
    <input type="submit">
</form>

用form组件搭建的页面

# 后端
def formmm(request):
    # 1.生成一个空的对象
    form_obj = MyRegForm()
    if request.method == 'POST':
        # 2.获取用户提交的数据
        # print(request.POST)  # request.POST  其实也可以看成是一个字典
        # 3.借助于form组件帮助我们校验
        form_obj = MyRegForm(request.POST)  # 由于request.POST其实就是一个大字典 所以直接当做参数传入即可
        # 4.判断用户输入的数据是否符合校验规则
        if form_obj.is_valid():
            return HttpResponse('你上传的数据没有问题')
    return render(request,'formmm.html',locals())

# 前端
<form action="" method="post" novalidate>
    {% for foo in form_obj %}
    <p>
        {{ foo.label }}:{{ foo }}
        <span style="color: red">{{ foo.errors.0 }}</span>
    </p>
    {% endfor %}
    <input type="submit">
</form>

forms组件参数详解

from django import forms
from django.forms import widgets  # 当你forms点不出来的时候 你可以手动导入一下
class MyRegForm(forms.Form):
    username = forms.CharField(min_length=3,max_length=8,label='用户名',
                               error_messages={
                                   'min_length':'用户名最短三位',
                                   'max_length':'用户名最长八位',
                                   'required':'用户名不能为空'
                               },initial='我是初始值',required=False,
                               widget= widgets.TextInput(attrs={'class':'form-control others'})
                               )
    password = forms.CharField(min_length=3,max_length=8,label='密码',error_messages={
                                   'min_length':'密码最短三位',
                                   'max_length':'密码最长八位',
                                   'required':'密码不能为空'
                               },widget=widgets.PasswordInput())
    confirm_password = forms.CharField(min_length=3, max_length=8, label='确认密码', error_messages={
        'min_length': '确认密码最短三位',
        'max_length': '确认密码最长八位',
        'required': '确认密码不能为空'
    })
    email = forms.EmailField(label='邮箱',error_messages={
            'required':'邮箱不能为空',
            'invalid':'邮箱格式不正确'
    },required=False,widget=widgets.EmailInput(attrs={'class':'form-control'}))

max_length: 限制最大长度
min_length: 限制最小长度
label: 自定义标签信息
error_messages: 自定义报错信息，已k:v字典的形式存放
initial: 自定义默认值
required: 默认为True不能为空，False可以为空

如何改变input框的type的属性值

from django.forms import widgets
# 指定widgets属性即可
widget= widgets.TextInput()
widget=widgets.PasswordInput()
widget=widgets.EmailInput()

如何让forms组件渲染bootstrap样式

# 在widget参数中添加attrs的属性，属性值就是前端的class属性，以K:V形式存放。
widget= widgets.TextInput(attrs={'class':'form-control others'})  # 如果有多个类属性 空格隔开
widget=widgets.PasswordInput(attrs={'class':'form-control others'})
widget=widgets.EmailInput(attrs={'class':'form-control'})

正则校验

from django import forms
from django.forms import Form
from django.core.validators import RegexValidator

class MyForm(Form):
    user = forms.CharField(
        validators=[RegexValidator(r'^[0-9]+$', '请输入数字'),       RegexValidator(r'^159[0-9]+$', '数字必须以159开头')],
    )

form组件钩子函数

当你需要对某一个字段数据进行额外的一系列校验，你可以考虑使用钩子函数

局部钩子

针对单个字段的，使用局部钩子。

例如：指定username字段不能出现傻逼。

在自定义类里，自定义一个局部钩子函数。

def clean_username(self):
    username = self.cleaned_data.get('username')
    if '傻逼' in username:
        raise ValidationError('用户名不符合规范。')
    return username

全局钩子

针对多个字段的校验，使用全局钩子。

例如：校验两次密码是否一致。

在自定义类里，自定义一个全局钩子函数。

def clean(self):
    password = self.cleaned_data.get('password')
    confirm_password = self.cleaned_data.get('confirm_password')
    if not password == confirm_password:
        self.add_error('confirm_password','两次密码不一致')
    return self.cleaned_data

form组件的其它字段

gender = forms.ChoiceField(
    choices=((1, "男"), (2, "女"), (3, "保密")),
    label="性别",
    initial=3,
    widget=widgets.RadioSelect()
)
hobby = forms.ChoiceField(
    choices=((1, "篮球"), (2, "足球"), (3, "双色球"),),
    label="爱好",
    initial=3,
    widget=widgets.Select()
)
hobby1 = forms.MultipleChoiceField(
    choices=((1, "篮球"), (2, "足球"), (3, "双色球"),),
    label="爱好",
    initial=[1, 3],
    widget=widgets.SelectMultiple()
)
keep = forms.ChoiceField(
    label="是否记住密码",
    initial="checked",
    widget=forms.widgets.CheckboxInput()
)
hobby2 = forms.MultipleChoiceField(
    choices=((1, "篮球"), (2, "足球"), (3, "双色球"),),
    label="爱好",
    initial=[1, 3],
    widget=forms.widgets.CheckboxSelectMultiple()
)

来源：https://www.cnblogs.com/dadazunzhe/p/11761885.html

标签

obj文件

数据校验

html代码

num

form