Django基础

首页 > 代码库 > Django基础

2024-10-15 20:38:02 214人阅读

Python的WEB框架有Django、Tornado、Flask 等多种，Django相较与其他WEB框架其优势为：大而全，框架本身集成了ORM、模型绑定、模板引擎、缓存、Session等诸多功能。

基本配置

一、创建django程序

终端命令：django-admin startproject sitename
IDE创建Django程序时，本质上都是自动执行上述命令

其他常用命令：

1.创建django命令
django-admin.py startproject project-name（你工程的名字）
2.创建django的app
python manage.py startapp app-name（你app的名字）
或 django-admin.py startapp app-name（你app的名字）
3.同步数据库
python manage.py syncdb
注意：Django 1.7.1及以上的版本需要用以下命令
python manage.py makemigrations
python manage.py migrate
4.调试模式
python manage.py runserver 8001
#监听所有可用 ip （电脑可能有一个或多个内网ip，一个或多个外网ip，即有多个ip地址）
python manage.py runserver 0.0.0.0:8000
5.清除数据库
python manage.py flush
6.创建超级管理员
python manage.py createsuperuser
按照提示就ok
7.修改管理员密码
python manage.py changepassword username（你当时设定的用户名）
8.导入和导出数据
python manage.py dumpdata appname > appname.json
python manage.py loaddata appname.json
9.进入数据库
python manage.py dbshell
10.更多命令
python manage.py

　　python manage.py makemigrations
　　python manage.py migrate

二、配置文件

1、数据库

DATABASES = {

‘default‘: {

‘ENGINE‘: ‘django.db.backends.mysql‘,

‘NAME‘:‘dbname‘,

‘USER‘: ‘root‘,

‘PASSWORD‘: ‘xxx‘,

‘HOST‘: ‘‘,

‘PORT‘: ‘‘,

}

# 由于Django内部连接MySQL时使用的是MySQLdb模块，而python3中还无此模块，所以需要使用pymysql来代替

# 如下设置放置的与project同名的配置的 __init__.py文件中

import pymysql

pymysql.install_as_MySQLdb()　

2、模版

TEMPLATE_DIRS = (

os.path.join(BASE_DIR,‘templates‘),

)

3、静态文件

STATICFILES_DIRS = (

os.path.join(BASE_DIR,‘static‘),

)

路由系统

1、单一路由对应

1	`url(r‘^index$‘, views.index),`

2、基于正则的路由

1 2	`url(r‘^index/(\d)‘, views.index),` `url(r‘^manage/(?P<name>\w)/(?P<id>\d*)‘, views.manage),`

3、添加额外的参数

1	`url(r‘^manage/(?P<name>\w*)‘, views.manage,{‘id‘:333}),`

4、为路由映射设置名称

1 2	`url(r‘^home‘, views.home, name=‘h1‘),` `url(r‘^index/(\d*)‘, views.index, name=‘h2‘),`

设置名称之后，可以在不同的地方调用，如：

模板中使用生成URL {% url ‘h2‘ 2012 %}
函数中使用生成URL reverse(‘h2‘, args=(2012,)) 路径:django.urls.reverse
Model中使用获取URL 自定义get_absolute_url() 方法

class NewType(models.Model):
    caption = models.CharField(max_length=16)


    def get_absolute_url(self):
        """
        为每个对象生成一个URL
        应用：在对象列表中生成查看详细的URL，使用此方法即可！！！
        :return:
        """
        # return ‘/%s/%s‘ % (self._meta.db_table, self.id)
        # 或
        from django.urls import reverse
        return reverse(‘NewType.Detail‘, kwargs={‘nid‘: self.id})

View Code

获取请求匹配成功的URL信息：request.resolver_match

5、根据app对路由规则进行分类

1	`url(r‘^web/‘,include(‘web.urls‘)),`

6、命名空间

a. project.urls.py

from django.conf.urls import url,include

urlpatterns = [

url(r‘^a/‘, include(‘app01.urls‘, namespace=‘author-polls‘)),

url(r‘^b/‘, include(‘app01.urls‘, namespace=‘publisher-polls‘)),

]

b. app01.urls.py

from django.conf.urls import url

from app01 import views

app_name = ‘app01‘

urlpatterns = [

url(r‘^(?P<pk>\d+)/$‘, views.detail, name=‘detail‘)

]

c. app01.views.py

def detail(request, pk):

print(request.resolver_match)

return HttpResponse(pk)

以上定义带命名空间的url之后，使用name生成URL时候，应该如下：

v = reverse(‘app01:detail‘, kwargs={‘pk‘:11})
{% url ‘app01:detail‘ pk=12 pp=99 %}

django中的路由系统和其他语言的框架有所不同，在django中每一个请求的url都要有一条路由映射，这样才能将请求交给对一个的view中的函数去处理。其他大部分的Web框架则是对一类的url请求做一条路由映射，从而是路由系统变得简洁。

通过反射机制，为django开发一套动态的路由系统Demo： 点击下载

模板

1、模版的执行

模版的创建过程，对于模版，其实就是读取模版（其中嵌套着模版标签），然后将 Model 中获取的数据插入到模版中，最后将信息返回给用户。

def current_datetime(request):
    now = datetime.datetime.now()
    html = "<html><body>It is now %s.</body></html>" % now
    return HttpResponse(html)

from django import template
t = template.Template(‘My name is {{ name }}.‘)
c = template.Context({‘name‘: ‘Adrian‘})
print t.render(c)

import datetime
from django import template
import DjangoDemo.settings
 
now = datetime.datetime.now()
fp = open(settings.BASE_DIR+‘/templates/Home/Index.html‘)
t = template.Template(fp.read())
fp.close()
html = t.render(template.Context({‘current_date‘: now}))
return HttpResponse(html

from django.template.loader import get_template
from django.template import Context
from django.http import HttpResponse
import datetime
 
def current_datetime(request):
    now = datetime.datetime.now()
    t = get_template(‘current_datetime.html‘)
    html = t.render(Context({‘current_date‘: now}))
    return HttpResponse(html)

return render_to_response(‘Account/Login.html‘,data,context_instance=RequestContext(request))

View Code

2、模版语言

　模板中也有自己的语言，该语言可以实现数据展示

{{ item }}
{% for item in item_list %} <a>{{ item }}</a> {% endfor %}
　　forloop.counter
　　forloop.first
　　forloop.last
{% if ordered_warranty %} {% else %} {% endif %}
母板：{% block title %}{% endblock %}
子板：{% extends "base.html" %}
　　　{% block title %}{% endblock %}
帮助方法：
{{ item.event_start|date:"Y-m-d H:i:s"}}
{{ bio|truncatewords:"30" }}
{{ my_list|first|upper }}
{{ name|lower }}

3、自定义simple_tag

a、在app中创建templatetags模块

b、创建任意 .py 文件，如：xx.py

#!/usr/bin/env python

#coding:utf-8

from django import template

from django.utils.safestring import mark_safe

register = template.Library()

@register.simple_tag

def my_simple_time(v1,v2,v3):

return v1 + v2 + v3

@register.simple_tag

def my_input(id,arg):

result = "<input type=‘text‘ id=‘%s‘ class=‘%s‘ />" %(id,arg,)

return mark_safe(result)

c、在使用自定义simple_tag的html文件中导入之前创建的 xx.py 文件名

1	`{%` `load xx` `%}`

d、使用simple_tag

1 2	`{%` `my_simple_time` `1` `2` `3%}` `{%` `my_input` `‘id_username‘` `‘hide‘%}`

e、在settings中配置当前app，不然django无法找到自定义的simple_tag　　

INSTALLED_APPS = (

‘django.contrib.admin‘,

‘django.contrib.auth‘,

‘django.contrib.contenttypes‘,

‘django.contrib.sessions‘,

‘django.contrib.messages‘,

‘django.contrib.staticfiles‘,

‘app01‘,

)

更多见文档：https://docs.djangoproject.com/en/1.10/ref/templates/language/

Model

到目前为止，当我们的程序涉及到数据库相关操作时，我们一般都会这么搞：

创建数据库，设计表结构和字段
使用 MySQLdb 来连接数据库，并编写数据访问层代码
业务逻辑层去调用数据访问层执行数据库操作

import MySQLdb
 
def GetList(sql):
    db = MySQLdb.connect(user=‘root‘, db=‘wupeiqidb‘, passwd=‘1234‘, host=‘localhost‘)
    cursor = db.cursor()
    cursor.execute(sql)
    data = cursor.fetchall()
    db.close()
    return data
 
def GetSingle(sql):
    db = MySQLdb.connect(user=‘root‘, db=‘wupeiqidb‘, passwd=‘1234‘, host=‘localhost‘)
    cursor = db.cursor()
    cursor.execute(sql)
    data = cursor.fetchone()
    db.close()
    return data

View Code

django为使用一种新的方式，即：关系对象映射（Object Relational Mapping，简称ORM）。

　　PHP：activerecord

　　Java：Hibernate

　　C#：Entity Framework

django中遵循 Code Frist 的原则，即：根据代码中定义的类来自动生成数据库表。

一、创建表

1、基本结构

from django.db import models

class userinfo(models.Model):

name = models.CharField(max_length=30)

email = models.EmailField()

memo = models.TextField()

AutoField(Field)
        - int自增列，必须填入参数 primary_key=True

    BigAutoField(AutoField)
        - bigint自增列，必须填入参数 primary_key=True

        注：当model中如果没有自增列，则自动会创建一个列名为id的列
        from django.db import models

        class UserInfo(models.Model):
            # 自动创建一个列名为id的且为自增的整数列
            username = models.CharField(max_length=32)

        class Group(models.Model):
            # 自定义自增列
            nid = models.AutoField(primary_key=True)
            name = models.CharField(max_length=32)

    SmallIntegerField(IntegerField):
        - 小整数 -32768 ～ 32767

    PositiveSmallIntegerField(PositiveIntegerRelDbTypeMixin, IntegerField)
        - 正小整数 0 ～ 32767
    IntegerField(Field)
        - 整数列(有符号的) -2147483648 ～ 2147483647

    PositiveIntegerField(PositiveIntegerRelDbTypeMixin, IntegerField)
        - 正整数 0 ～ 2147483647

    BigIntegerField(IntegerField):
        - 长整型(有符号的) -9223372036854775808 ～ 9223372036854775807

    自定义无符号整数字段

        class UnsignedIntegerField(models.IntegerField):
            def db_type(self, connection):
                return ‘integer UNSIGNED‘

        PS: 返回值为字段在数据库中的属性，Django字段默认的值为：
            ‘AutoField‘: ‘integer AUTO_INCREMENT‘,
            ‘BigAutoField‘: ‘bigint AUTO_INCREMENT‘,
            ‘BinaryField‘: ‘longblob‘,
            ‘BooleanField‘: ‘bool‘,
            ‘CharField‘: ‘varchar(%(max_length)s)‘,
            ‘CommaSeparatedIntegerField‘: ‘varchar(%(max_length)s)‘,
            ‘DateField‘: ‘date‘,
            ‘DateTimeField‘: ‘datetime‘,
            ‘DecimalField‘: ‘numeric(%(max_digits)s, %(decimal_places)s)‘,
            ‘DurationField‘: ‘bigint‘,
            ‘FileField‘: ‘varchar(%(max_length)s)‘,
            ‘FilePathField‘: ‘varchar(%(max_length)s)‘,
            ‘FloatField‘: ‘double precision‘,
            ‘IntegerField‘: ‘integer‘,
            ‘BigIntegerField‘: ‘bigint‘,
            ‘IPAddressField‘: ‘char(15)‘,
            ‘GenericIPAddressField‘: ‘char(39)‘,
            ‘NullBooleanField‘: ‘bool‘,
            ‘OneToOneField‘: ‘integer‘,
            ‘PositiveIntegerField‘: ‘integer UNSIGNED‘,
            ‘PositiveSmallIntegerField‘: ‘smallint UNSIGNED‘,
            ‘SlugField‘: ‘varchar(%(max_length)s)‘,
            ‘SmallIntegerField‘: ‘smallint‘,
            ‘TextField‘: ‘longtext‘,
            ‘TimeField‘: ‘time‘,
            ‘UUIDField‘: ‘char(32)‘,

    BooleanField(Field)
        - 布尔值类型

    NullBooleanField(Field):
        - 可以为空的布尔值

    CharField(Field)
        - 字符类型
        - 必须提供max_length参数， max_length表示字符长度

    TextField(Field)
        - 文本类型

    EmailField(CharField)：
        - 字符串类型，Django Admin以及ModelForm中提供验证机制

    IPAddressField(Field)
        - 字符串类型，Django Admin以及ModelForm中提供验证 IPV4 机制

    GenericIPAddressField(Field)
        - 字符串类型，Django Admin以及ModelForm中提供验证 Ipv4和Ipv6
        - 参数：
            protocol，用于指定Ipv4或Ipv6， ‘both‘,"ipv4","ipv6"
            unpack_ipv4， 如果指定为True，则输入::ffff:192.0.2.1时候，可解析为192.0.2.1，开启刺功能，需要protocol="both"

    URLField(CharField)
        - 字符串类型，Django Admin以及ModelForm中提供验证 URL

    SlugField(CharField)
        - 字符串类型，Django Admin以及ModelForm中提供验证支持 字母、数字、下划线、连接符（减号）

    CommaSeparatedIntegerField(CharField)
        - 字符串类型，格式必须为逗号分割的数字

    UUIDField(Field)
        - 字符串类型，Django Admin以及ModelForm中提供对UUID格式的验证

    FilePathField(Field)
        - 字符串，Django Admin以及ModelForm中提供读取文件夹下文件的功能
        - 参数：
                path,                      文件夹路径
                match=None,                正则匹配
                recursive=False,           递归下面的文件夹
                allow_files=True,          允许文件
                allow_folders=False,       允许文件夹

    FileField(Field)
        - 字符串，路径保存在数据库，文件上传到指定目录
        - 参数：
            upload_to = ""      上传文件的保存路径
            storage = None      存储组件，默认django.core.files.storage.FileSystemStorage

    ImageField(FileField)
        - 字符串，路径保存在数据库，文件上传到指定目录
        - 参数：
            upload_to = ""      上传文件的保存路径
            storage = None      存储组件，默认django.core.files.storage.FileSystemStorage
            width_field=None,   上传图片的高度保存的数据库字段名（字符串）
            height_field=None   上传图片的宽度保存的数据库字段名（字符串）

    DateTimeField(DateField)
        - 日期+时间格式 YYYY-MM-DD HH:MM[:ss[.uuuuuu]][TZ]

    DateField(DateTimeCheckMixin, Field)
        - 日期格式      YYYY-MM-DD

    TimeField(DateTimeCheckMixin, Field)
        - 时间格式      HH:MM[:ss[.uuuuuu]]

    DurationField(Field)
        - 长整数，时间间隔，数据库中按照bigint存储，ORM中获取的值为datetime.timedelta类型

    FloatField(Field)
        - 浮点型

    DecimalField(Field)
        - 10进制小数
        - 参数：
            max_digits，小数总长度
            decimal_places，小数位长度

    BinaryField(Field)
        - 二进制类型

字段

null                数据库中字段是否可以为空
    db_column           数据库中字段的列名
    db_tablespace
    default             数据库中字段的默认值
    primary_key         数据库中字段是否为主键
    db_index            数据库中字段是否可以建立索引
    unique              数据库中字段是否可以建立唯一索引
    unique_for_date     数据库中字段【日期】部分是否可以建立唯一索引
    unique_for_month    数据库中字段【月】部分是否可以建立唯一索引
    unique_for_year     数据库中字段【年】部分是否可以建立唯一索引

    verbose_name        Admin中显示的字段名称
    blank               Admin中是否允许用户输入为空
    editable            Admin中是否可以编辑
    help_text           Admin中该字段的提示信息
    choices             Admin中显示选择框的内容，用不变动的数据放在内存中从而避免跨表操作
                        如：gf = models.IntegerField(choices=[(0, ‘何穗‘),(1, ‘大表姐‘),],default=1)

    error_messages      自定义错误信息（字典类型），从而定制想要显示的错误信息；
                        字典健：null, blank, invalid, invalid_choice, unique, and unique_for_date
                        如：{‘null‘: "不能为空.", ‘invalid‘: ‘格式错误‘}

    validators          自定义错误验证（列表类型），从而定制想要的验证规则
                        from django.core.validators import RegexValidator
                        from django.core.validators import EmailValidator,URLValidator,DecimalValidator,                        MaxLengthValidator,MinLengthValidator,MaxValueValidator,MinValueValidator
                        如：
                            test = models.CharField(
                                max_length=32,
                                error_messages={
                                    ‘c1‘: ‘优先错信息1‘,
                                    ‘c2‘: ‘优先错信息2‘,
                                    ‘c3‘: ‘优先错信息3‘,
                                },
                                validators=[
                                    RegexValidator(regex=‘root_\d+‘, message=‘错误了‘, code=‘c1‘),
                                    RegexValidator(regex=‘root_112233\d+‘, message=‘又错误了‘, code=‘c2‘),
                                    EmailValidator(message=‘又错误了‘, code=‘c3‘), ]
                            )

参数

class UserInfo(models.Model):
        nid = models.AutoField(primary_key=True)
        username = models.CharField(max_length=32)
        class Meta:
            # 数据库中生成的表名称 默认 app名称 + 下划线 + 类名
            db_table = "table_name"

            # 联合索引
            index_together = [
                ("pub_date", "deadline"),
            ]

            # 联合唯一索引
            unique_together = (("driver", "restaurant"),)

            # admin中显示的表名称
            verbose_name

            # verbose_name加s
            verbose_name_plural
        
    更多：https://docs.djangoproject.com/en/1.10/ref/models/options/

元信息

1.触发Model中的验证和错误提示有两种方式：
        a. Django Admin中的错误信息会优先根据Admiin内部的ModelForm错误信息提示，如果都成功，才来检查Model的字段并显示指定错误信息
        b. 调用Model对象的 clean_fields 方法，如：
            # models.py
            class UserInfo(models.Model):
                nid = models.AutoField(primary_key=True)
                username = models.CharField(max_length=32)

                email = models.EmailField(error_messages={‘invalid‘: ‘格式错了.‘})

            # views.py
            def index(request):
                obj = models.UserInfo(username=‘11234‘, email=‘uu‘)
                try:
                    print(obj.clean_fields())
                except Exception as e:
                    print(e)
                return HttpResponse(‘ok‘)

           # Model的clean方法是一个钩子，可用于定制操作，如：上述的异常处理。

    2.Admin中修改错误提示
        # admin.py
        from django.contrib import admin
        from model_club import models
        from django import forms


        class UserInfoForm(forms.ModelForm):
            username = forms.CharField(error_messages={‘required‘: ‘用户名不能为空.‘})
            email = forms.EmailField(error_messages={‘invalid‘: ‘邮箱格式错误.‘})
            age = forms.IntegerField(initial=1, error_messages={‘required‘: ‘请输入数值.‘, ‘invalid‘: ‘年龄必须为数值.‘})

            class Meta:
                model = models.UserInfo
                # fields = (‘username‘,)
                fields = "__all__"


        class UserInfoAdmin(admin.ModelAdmin):
            form = UserInfoForm


        admin.site.register(models.UserInfo, UserInfoAdmin)

拓展

2、连表结构

一对多：models.ForeignKey(其他表)
多对多：models.ManyToManyField(其他表)
一对一：models.OneToOneField(其他表)

应用场景：

一对多：当一张表中创建一行数据时，有一个单选的下拉框（可以被重复选择）
例如：创建用户信息时候，需要选择一个用户类型【普通用户】【金牌用户】【铂金用户】等。

多对多：在某表中创建一行数据是，有一个可以多选的下拉框
例如：创建用户信息，需要为用户指定多个爱好

一对一：在某表中创建一行数据时，有一个单选的下拉框（下拉框中的内容被用过一次就消失了
例如：原有含10列数据的一张表保存相关信息，经过一段时间之后，10列无法满足需求，需要为原来的表再添加5列数据

ForeignKey(ForeignObject) # ForeignObject(RelatedField)
        to,                         # 要进行关联的表名
        to_field=None,              # 要关联的表中的字段名称
        on_delete=None,             # 当删除关联表中的数据时，当前表与其关联的行的行为
                                        - models.CASCADE，删除关联数据，与之关联也删除
                                        - models.DO_NOTHING，删除关联数据，引发错误IntegrityError
                                        - models.PROTECT，删除关联数据，引发错误ProtectedError
                                        - models.SET_NULL，删除关联数据，与之关联的值设置为null（前提FK字段需要设置为可空）
                                        - models.SET_DEFAULT，删除关联数据，与之关联的值设置为默认值（前提FK字段需要设置默认值）
                                        - models.SET，删除关联数据，
                                                      a. 与之关联的值设置为指定值，设置：models.SET(值)
                                                      b. 与之关联的值设置为可执行对象的返回值，设置：models.SET(可执行对象)

                                                        def func():
                                                            return 10

                                                        class MyModel(models.Model):
                                                            user = models.ForeignKey(
                                                                to="User",
                                                                to_field="id"
                                                                on_delete=models.SET(func),)
        related_name=None,          # 反向操作时，使用的字段名，用于代替 【表名_set】 如： obj.表名_set.all()
        related_query_name=None,    # 反向操作时，使用的连接前缀，用于替换【表名】     如： models.UserGroup.objects.filter(表名__字段名=1).values(‘表名__字段名‘)
        limit_choices_to=None,      # 在Admin或ModelForm中显示关联数据时，提供的条件：
                                    # 如：
                                            - limit_choices_to={‘nid__gt‘: 5}
                                            - limit_choices_to=lambda : {‘nid__gt‘: 5}

                                            from django.db.models import Q
                                            - limit_choices_to=Q(nid__gt=10)
                                            - limit_choices_to=Q(nid=8) | Q(nid__gt=10)
                                            - limit_choices_to=lambda : Q(Q(nid=8) | Q(nid__gt=10)) & Q(caption=‘root‘)
        db_constraint=True          # 是否在数据库中创建外键约束
        parent_link=False           # 在Admin中是否显示关联数据


    OneToOneField(ForeignKey)
        to,                         # 要进行关联的表名
        to_field=None               # 要关联的表中的字段名称
        on_delete=None,             # 当删除关联表中的数据时，当前表与其关联的行的行为

                                    ###### 对于一对一 ######
                                    # 1. 一对一其实就是 一对多 + 唯一索引
                                    # 2.当两个类之间有继承关系时，默认会创建一个一对一字段
                                    # 如下会在A表中额外增加一个c_ptr_id列且唯一：
                                            class C(models.Model):
                                                nid = models.AutoField(primary_key=True)
                                                part = models.CharField(max_length=12)

                                            class A(C):
                                                id = models.AutoField(primary_key=True)
                                                code = models.CharField(max_length=1)

    ManyToManyField(RelatedField)
        to,                         # 要进行关联的表名
        related_name=None,          # 反向操作时，使用的字段名，用于代替 【表名_set】 如： obj.表名_set.all()
        related_query_name=None,    # 反向操作时，使用的连接前缀，用于替换【表名】     如： models.UserGroup.objects.filter(表名__字段名=1).values(‘表名__字段名‘)
        limit_choices_to=None,      # 在Admin或ModelForm中显示关联数据时，提供的条件：
                                    # 如：
                                            - limit_choices_to={‘nid__gt‘: 5}
                                            - limit_choices_to=lambda : {‘nid__gt‘: 5}

                                            from django.db.models import Q
                                            - limit_choices_to=Q(nid__gt=10)
                                            - limit_choices_to=Q(nid=8) | Q(nid__gt=10)
                                            - limit_choices_to=lambda : Q(Q(nid=8) | Q(nid__gt=10)) & Q(caption=‘root‘)
        symmetrical=None,           # 仅用于多对多自关联时，symmetrical用于指定内部是否创建反向操作的字段
                                    # 做如下操作时，不同的symmetrical会有不同的可选字段
                                        models.BB.objects.filter(...)

                                        # 可选字段有：code, id, m1
                                            class BB(models.Model):

                                            code = models.CharField(max_length=12)
                                            m1 = models.ManyToManyField(‘self‘,symmetrical=True)

                                        # 可选字段有: bb, code, id, m1
                                            class BB(models.Model):

                                            code = models.CharField(max_length=12)
                                            m1 = models.ManyToManyField(‘self‘,symmetrical=False)

        through=None,               # 自定义第三张表时，使用字段用于指定关系表
        through_fields=None,        # 自定义第三张表时，使用字段用于指定关系表中那些字段做多对多关系表
                                        from django.db import models

                                        class Person(models.Model):
                                            name = models.CharField(max_length=50)

                                        class Group(models.Model):
                                            name = models.CharField(max_length=128)
                                            members = models.ManyToManyField(
                                                Person,
                                                through=‘Membership‘,
                                                through_fields=(‘group‘, ‘person‘),
                                            )

                                        class Membership(models.Model):
                                            group = models.ForeignKey(Group, on_delete=models.CASCADE)
                                            person = models.ForeignKey(Person, on_delete=models.CASCADE)
                                            inviter = models.ForeignKey(
                                                Person,
                                                on_delete=models.CASCADE,
                                                related_name="membership_invites",
                                            )
                                            invite_reason = models.CharField(max_length=64)
        db_constraint=True,         # 是否在数据库中创建外键约束
        db_table=None,              # 默认创建第三张表时，数据库中表的名称

字段以及参数

二、操作表

1、基本操作

# 增
    #
    # models.Tb1.objects.create(c1=‘xx‘, c2=‘oo‘)  增加一条数据，可以接受字典类型数据 **kwargs

    # obj = models.Tb1(c1=‘xx‘, c2=‘oo‘)
    # obj.save()

    # 查
    #
    # models.Tb1.objects.get(id=123)         # 获取单条数据，不存在则报错（不建议）
    # models.Tb1.objects.all()               # 获取全部
    # models.Tb1.objects.filter(name=‘seven‘) # 获取指定条件的数据

    # 删
    #
    # models.Tb1.objects.filter(name=‘seven‘).delete() # 删除指定条件的数据

    # 改
    # models.Tb1.objects.filter(name=‘seven‘).update(gender=‘0‘)  # 将指定条件的数据更新，均支持 **kwargs
    # obj = models.Tb1.objects.get(id=1)
    # obj.c1 = ‘111‘
    # obj.save()                                                 # 修改单条数据

基本操作

2、进阶操作（了不起的双下划线）

利用双下划线将字段和对应的操作连接起来

# 获取个数
        #
        # models.Tb1.objects.filter(name=‘seven‘).count()

        # 大于，小于
        #
        # models.Tb1.objects.filter(id__gt=1)              # 获取id大于1的值
        # models.Tb1.objects.filter(id__gte=1)              # 获取id大于等于1的值
        # models.Tb1.objects.filter(id__lt=10)             # 获取id小于10的值
        # models.Tb1.objects.filter(id__lte=10)             # 获取id小于10的值
        # models.Tb1.objects.filter(id__lt=10, id__gt=1)   # 获取id大于1 且 小于10的值

        # in
        #
        # models.Tb1.objects.filter(id__in=[11, 22, 33])   # 获取id等于11、22、33的数据
        # models.Tb1.objects.exclude(id__in=[11, 22, 33])  # not in

        # isnull
        # Entry.objects.filter(pub_date__isnull=True)

        # contains
        #
        # models.Tb1.objects.filter(name__contains="ven")
        # models.Tb1.objects.filter(name__icontains="ven") # icontains大小写不敏感
        # models.Tb1.objects.exclude(name__icontains="ven")

        # range
        #
        # models.Tb1.objects.filter(id__range=[1, 2])   # 范围bettwen and

        # 其他类似
        #
        # startswith，istartswith, endswith, iendswith,

        # order by
        #
        # models.Tb1.objects.filter(name=‘seven‘).order_by(‘id‘)    # asc
        # models.Tb1.objects.filter(name=‘seven‘).order_by(‘-id‘)   # desc

        # group by
        #
        # from django.db.models import Count, Min, Max, Sum
        # models.Tb1.objects.filter(c1=1).values(‘id‘).annotate(c=Count(‘num‘))
        # SELECT "app01_tb1"."id", COUNT("app01_tb1"."num") AS "c" FROM "app01_tb1" WHERE "app01_tb1"."c1" = 1 GROUP BY "app01_tb1"."id"

        # limit 、offset
        #
        # models.Tb1.objects.all()[10:20]

        # regex正则匹配，iregex 不区分大小写
        #
        # Entry.objects.get(title__regex=r‘^(An?|The) +‘)
        # Entry.objects.get(title__iregex=r‘^(an?|the) +‘)

        # date
        #
        # Entry.objects.filter(pub_date__date=datetime.date(2005, 1, 1))
        # Entry.objects.filter(pub_date__date__gt=datetime.date(2005, 1, 1))

        # year
        #
        # Entry.objects.filter(pub_date__year=2005)
        # Entry.objects.filter(pub_date__year__gte=2005)

        # month
        #
        # Entry.objects.filter(pub_date__month=12)
        # Entry.objects.filter(pub_date__month__gte=6)

        # day
        #
        # Entry.objects.filter(pub_date__day=3)
        # Entry.objects.filter(pub_date__day__gte=3)

        # week_day
        #
        # Entry.objects.filter(pub_date__week_day=2)
        # Entry.objects.filter(pub_date__week_day__gte=2)

        # hour
        #
        # Event.objects.filter(timestamp__hour=23)
        # Event.objects.filter(time__hour=5)
        # Event.objects.filter(timestamp__hour__gte=12)

        # minute
        #
        # Event.objects.filter(timestamp__minute=29)
        # Event.objects.filter(time__minute=46)
        # Event.objects.filter(timestamp__minute__gte=29)

        # second
        #
        # Event.objects.filter(timestamp__second=31)
        # Event.objects.filter(time__second=2)
        # Event.objects.filter(timestamp__second__gte=31)

进阶操作

3、其他操作

# extra
    #
    # extra(self, select=None, where=None, params=None, tables=None, order_by=None, select_params=None)
    #    Entry.objects.extra(select={‘new_id‘: "select col from sometable where othercol > %s"}, select_params=(1,))
    #    Entry.objects.extra(where=[‘headline=%s‘], params=[‘Lennon‘])
    #    Entry.objects.extra(where=["foo=‘a‘ OR bar = ‘a‘", "baz = ‘a‘"])
    #    Entry.objects.extra(select={‘new_id‘: "select id from tb where id > %s"}, select_params=(1,), order_by=[‘-nid‘])

    # F
    #
    # from django.db.models import F
    # models.Tb1.objects.update(num=F(‘num‘)+1)


    # Q
    #
    # 方式一：
    # Q(nid__gt=10)
    # Q(nid=8) | Q(nid__gt=10)
    # Q(Q(nid=8) | Q(nid__gt=10)) & Q(caption=‘root‘)
    # 方式二：
    # con = Q()
    # q1 = Q()
    # q1.connector = ‘OR‘
    # q1.children.append((‘id‘, 1))
    # q1.children.append((‘id‘, 10))
    # q1.children.append((‘id‘, 9))
    # q2 = Q()
    # q2.connector = ‘OR‘
    # q2.children.append((‘c1‘, 1))
    # q2.children.append((‘c1‘, 10))
    # q2.children.append((‘c1‘, 9))
    # con.add(q1, ‘AND‘)
    # con.add(q2, ‘AND‘)
    #
    # models.Tb1.objects.filter(con)


    # 执行原生SQL
    #
    # from django.db import connection, connections
    # cursor = connection.cursor()  # cursor = connections[‘default‘].cursor()
    # cursor.execute("""SELECT * from auth_user where id = %s""", [1])
    # row = cursor.fetchone()

其他操作

4、连表操作（了不起的双下划线）

利用双下划线和 _set 将表之间的操作连接起来

class UserProfile(models.Model):
    user_info = models.OneToOneField(‘UserInfo‘)
    username = models.CharField(max_length=64)
    password = models.CharField(max_length=64)

    def __unicode__(self):
        return self.username


class UserInfo(models.Model):
    user_type_choice = (
        (0, u‘普通用户‘),
        (1, u‘高级用户‘),
    )
    user_type = models.IntegerField(choices=user_type_choice)
    name = models.CharField(max_length=32)
    email = models.CharField(max_length=32)
    address = models.CharField(max_length=128)

    def __unicode__(self):
        return self.name


class UserGroup(models.Model):

    caption = models.CharField(max_length=64)

    user_info = models.ManyToManyField(‘UserInfo‘)

    def __unicode__(self):
        return self.caption


class Host(models.Model):
    hostname = models.CharField(max_length=64)
    ip = models.GenericIPAddressField()
    user_group = models.ForeignKey(‘UserGroup‘)

    def __unicode__(self):
        return self.hostname

表结构实例

user_info_obj = models.UserInfo.objects.filter(id=1).first()
print user_info_obj.user_type
print user_info_obj.get_user_type_display()
print user_info_obj.userprofile.password
 
user_info_obj = models.UserInfo.objects.filter(id=1).values(‘email‘, ‘userprofile__username‘).first()
print user_info_obj.keys()
print user_info_obj.values()

一对一操作

类似一对一
1、搜索条件使用 __ 连接
2、获取值时使用 .    连接

一对多

user_info_obj = models.UserInfo.objects.get(name=u‘武沛齐‘)
user_info_objs = models.UserInfo.objects.all()
 
group_obj = models.UserGroup.objects.get(caption=‘CEO‘)
group_objs = models.UserGroup.objects.all()
 
# 添加数据
#group_obj.user_info.add(user_info_obj)
#group_obj.user_info.add(*user_info_objs)
 
# 删除数据
#group_obj.user_info.remove(user_info_obj)
#group_obj.user_info.remove(*user_info_objs)
 
# 添加数据
#user_info_obj.usergroup_set.add(group_obj)
#user_info_obj.usergroup_set.add(*group_objs)
 
# 删除数据
#user_info_obj.usergroup_set.remove(group_obj)
#user_info_obj.usergroup_set.remove(*group_objs)
 
# 获取数据
#print group_obj.user_info.all()
#print group_obj.user_info.all().filter(id=1)
 
# 获取数据
#print user_info_obj.usergroup_set.all()
#print user_info_obj.usergroup_set.all().filter(caption=‘CEO‘)
#print user_info_obj.usergroup_set.all().filter(caption=‘DBA‘)

多对多操作

扩展：

a、自定义上传

def upload_file(request):
    if request.method == "POST":
        obj = request.FILES.get(‘fafafa‘)
        f = open(obj.name, ‘wb‘)
        for chunk in obj.chunks():
            f.write(chunk)
        f.close()
    return render(request, ‘file.html‘)

自定义上传

b、Form上传文件实例

class FileForm(forms.Form):
    ExcelFile = forms.FileField()

from django.db import models

class UploadFile(models.Model):
    userid = models.CharField(max_length = 30)
    file = models.FileField(upload_to = ‘./upload/‘)
    date = models.DateTimeField(auto_now_add=True)

def UploadFile(request):
    uf = AssetForm.FileForm(request.POST,request.FILES)
    if uf.is_valid():
            upload = models.UploadFile()
            upload.userid = 1
            upload.file = uf.cleaned_data[‘ExcelFile‘]
            upload.save()
            
            print upload.file

form+model+view

Form

django中的Form一般有两种功能：

输入html
验证用户输入

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import re
from django import forms
from django.core.exceptions import ValidationError


def mobile_validate(value):
    mobile_re = re.compile(r‘^(13[0-9]|15[012356789]|17[678]|18[0-9]|14[57])[0-9]{8}$‘)
    if not mobile_re.match(value):
        raise ValidationError(‘手机号码格式错误‘)


class PublishForm(forms.Form):

    user_type_choice = (
        (0, u‘普通用户‘),
        (1, u‘高级用户‘),
    )

    user_type = forms.IntegerField(widget=forms.widgets.Select(choices=user_type_choice,
                                                                  attrs={‘class‘: "form-control"}))

    title = forms.CharField(max_length=20,
                            min_length=5,
                            error_messages={‘required‘: u‘标题不能为空‘,
                                            ‘min_length‘: u‘标题最少为5个字符‘,
                                            ‘max_length‘: u‘标题最多为20个字符‘},
                            widget=forms.TextInput(attrs={‘class‘: "form-control",
                                                          ‘placeholder‘: u‘标题5-20个字符‘}))

    memo = forms.CharField(required=False,
                           max_length=256,
                           widget=forms.widgets.Textarea(attrs={‘class‘: "form-control no-radius", ‘placeholder‘: u‘详细描述‘, ‘rows‘: 3}))

    phone = forms.CharField(validators=[mobile_validate, ],
                            error_messages={‘required‘: u‘手机不能为空‘},
                            widget=forms.TextInput(attrs={‘class‘: "form-control",
                                                          ‘placeholder‘: u‘手机号码‘}))

    email = forms.EmailField(required=False,
                            error_messages={‘required‘: u‘邮箱不能为空‘,‘invalid‘: u‘邮箱格式错误‘},
                            widget=forms.TextInput(attrs={‘class‘: "form-control", ‘placeholder‘: u‘邮箱‘}))

Form

def publish(request):
    ret = {‘status‘: False, ‘data‘: ‘‘, ‘error‘: ‘‘, ‘summary‘: ‘‘}
    if request.method == ‘POST‘:
        request_form = PublishForm(request.POST)
        if request_form.is_valid():
            request_dict = request_form.clean()
            print request_dict
            ret[‘status‘] = True
        else:
            error_msg = request_form.errors.as_json()
            ret[‘error‘] = json.loads(error_msg)
    return HttpResponse(json.dumps(ret))

View

扩展：ModelForm

在使用Model和Form时，都需要对字段进行定义并指定类型，通过ModelForm则可以省去From中字段的定义

class AdminModelForm(forms.ModelForm):
      
    class Meta:
        model = models.Admin
        #fields = ‘__all__‘
        fields = (‘username‘, ‘email‘)
          
        widgets = {
            ‘email‘ : forms.PasswordInput(attrs={‘class‘:"alex"}),
        }

View Code

跨站请求伪造

一、简介

django为用户实现防止跨站请求伪造的功能，通过中间件 django.middleware.csrf.CsrfViewMiddleware 来完成。而对于django中设置防跨站请求伪造功能有分为全局和局部。

全局：

　　中间件 django.middleware.csrf.CsrfViewMiddleware

局部：

@csrf_protect，为当前函数强制设置防跨站请求伪造功能，即便settings中没有设置全局中间件。
@csrf_exempt，取消当前函数防跨站请求伪造功能，即便settings中设置了全局中间件。

注：from django.views.decorators.csrf import csrf_exempt,csrf_protect

二、应用

1、普通表单

veiw中设置返回值：

　　return render_to_response(‘Account/Login.html‘,data,context_instance=RequestContext(request))　　

或者

return render(request, ‘xxx.html‘, data)

html中设置Token:

　　{% csrf_token %}

2、Ajax

对于传统的form，可以通过表单的方式将token再次发送到服务端，而对于ajax的话，使用如下方式。

view.py

from django.template.context import RequestContext

# Create your views here.

def test(request):

if request.method == ‘POST‘:

print request.POST

return HttpResponse(‘ok‘)

return render_to_response(‘app01/test.html‘,context_instance=RequestContext(request))

text.html

<!DOCTYPE html>

<html>

<head lang="en">

<meta charset="UTF-8">

<title></title>

</head>

<body>

{% csrf_token %}

<input type="button" onclick="Do();" value="Do it"/>

<script src="/static/plugin/jquery/jquery-1.8.0.js"></script>

<script src="/static/plugin/jquery/jquery.cookie.js"></script>

<script type="text/javascript">

var csrftoken = $.cookie(‘csrftoken‘);

function csrfSafeMethod(method) {

// these HTTP methods do not require CSRF protection

return (/^(GET|HEAD|OPTIONS|TRACE)$/.test(method));

}

$.ajaxSetup({

beforeSend: function(xhr, settings) {

if (!csrfSafeMethod(settings.type) && !this.crossDomain) {

xhr.setRequestHeader("X-CSRFToken", csrftoken);

}

});

function Do(){

$.ajax({

url:"/app01/test/",

data:{id:1},

type:‘POST‘,

success:function(data){

console.log(data);

}

});

}

</script>

</body>

</html>

更多：https://docs.djangoproject.com/en/dev/ref/csrf/#ajax

Cookie

1、获取Cookie：

request.COOKIES[‘key‘]

request.get_signed_cookie(key, default=RAISE_ERROR, salt=‘‘, max_age=None)

参数：

default: 默认值

salt: 加密盐

max_age: 后台控制过期时间

2、设置Cookie：

rep = HttpResponse(...) 或 rep ＝ render(request, ...)

rep.set_cookie(key,value,...)

rep.set_signed_cookie(key,value,salt=‘加密盐‘,...)

参数：

key, 键

value=‘‘, 值

max_age=None, 超时时间

expires=None, 超时时间(IE requires expires, so set it if hasn‘t been already.)

path=‘/‘, Cookie生效的路径，/ 表示根路径，特殊的：跟路径的cookie可以被任何url的页面访问

domain=None, Cookie生效的域名

secure=False, https传输

httponly=False 只能http协议传输，无法被JavaScript获取（不是绝对，底层抓包可以获取到也可以被覆盖）

由于cookie保存在客户端的电脑上，所以，JavaScript和jquery也可以操作cookie。

1 2	`<script src=‘/static/js/jquery.cookie.js‘></script>` `$.cookie("list_pager_num",` `30,{ path:` `‘/‘` `});`

Session

Django中默认支持Session，其内部提供了5种类型的Session供开发者使用：

数据库（默认）
缓存
文件
缓存+数据库
加密cookie

1、数据库Session

Django默认支持Session，并且默认是将Session数据存储在数据库中，即：django_session 表中。

a. 配置 settings.py

SESSION_ENGINE = ‘django.contrib.sessions.backends.db‘ # 引擎（默认）

SESSION_COOKIE_NAME ＝ "sessionid" # Session的cookie保存在浏览器上时的key，即：sessionid＝随机字符串（默认）

SESSION_COOKIE_PATH ＝ "/" # Session的cookie保存的路径（默认）

SESSION_COOKIE_DOMAIN = None # Session的cookie保存的域名（默认）

SESSION_COOKIE_SECURE = False # 是否Https传输cookie（默认）

SESSION_COOKIE_HTTPONLY = True # 是否Session的cookie只支持http传输（默认）

SESSION_COOKIE_AGE = 1209600 # Session的cookie失效日期（2周）（默认）

SESSION_EXPIRE_AT_BROWSER_CLOSE = False # 是否关闭浏览器使得Session过期（默认）

SESSION_SAVE_EVERY_REQUEST = False # 是否每次请求都保存Session，默认修改之后才保存（默认）

b. 使用

def index(request):

# 获取、设置、删除Session中数据

request.session[‘k1‘]

request.session.get(‘k1‘,None)

request.session[‘k1‘] = 123

request.session.setdefault(‘k1‘,123) # 存在则不设置

del request.session[‘k1‘]

# 所有键、值、键值对

request.session.keys()

request.session.values()

request.session.items()

request.session.iterkeys()

request.session.itervalues()

request.session.iteritems()

# 用户session的随机字符串

request.session.session_key

# 将所有Session失效日期小于当前日期的数据删除

request.session.clear_expired()

# 检查用户session的随机字符串在数据库中是否

request.session.exists("session_key")

# 删除当前用户的所有Session数据

request.session.delete("session_key")

request.session.set_expiry(value)

* 如果value是个整数，session会在些秒数后失效。

* 如果value是个datatime或timedelta，session就会在这个时间后失效。

* 如果value是0,用户关闭浏览器session就会失效。

* 如果value是None,session会依赖全局session失效策略。

　　2、缓存Session

a. 配置 settings.py

SESSION_ENGINE = ‘django.contrib.sessions.backends.cache‘ # 引擎

SESSION_CACHE_ALIAS = ‘default‘ # 使用的缓存别名（默认内存缓存，也可以是memcache），此处别名依赖缓存的设置

SESSION_COOKIE_NAME ＝ "sessionid" # Session的cookie保存在浏览器上时的key，即：sessionid＝随机字符串

SESSION_COOKIE_PATH ＝ "/" # Session的cookie保存的路径

SESSION_COOKIE_DOMAIN = None # Session的cookie保存的域名

SESSION_COOKIE_SECURE = False # 是否Https传输cookie

SESSION_COOKIE_HTTPONLY = True # 是否Session的cookie只支持http传输

SESSION_COOKIE_AGE = 1209600 # Session的cookie失效日期（2周）

SESSION_EXPIRE_AT_BROWSER_CLOSE = False # 是否关闭浏览器使得Session过期

SESSION_SAVE_EVERY_REQUEST = False # 是否每次请求都保存Session，默认修改之后才保存

b. 使用

同上

3、文件Session

a. 配置 settings.py

SESSION_ENGINE = ‘django.contrib.sessions.backends.file‘ # 引擎

SESSION_FILE_PATH = None

# 缓存文件路径，如果为None，则使用tempfile模块获取一个临时地址tempfile.gettempdir()                                                            # 如：/var/folders/d3/j9tj0gz93dg06bmwxmhh6_xm0000gn/T

SESSION_COOKIE_NAME ＝ "sessionid" # Session的cookie保存在浏览器上时的key，即：sessionid＝随机字符串

SESSION_COOKIE_PATH ＝ "/" # Session的cookie保存的路径

SESSION_COOKIE_DOMAIN = None # Session的cookie保存的域名

SESSION_COOKIE_SECURE = False # 是否Https传输cookie

SESSION_COOKIE_HTTPONLY = True # 是否Session的cookie只支持http传输

SESSION_COOKIE_AGE = 1209600 # Session的cookie失效日期（2周）

SESSION_EXPIRE_AT_BROWSER_CLOSE = False # 是否关闭浏览器使得Session过期

SESSION_SAVE_EVERY_REQUEST = False # 是否每次请求都保存Session，默认修改之后才保存

b. 使用

同上

4、缓存+数据库Session

数据库用于做持久化，缓存用于提高效率

a. 配置 settings.py

SESSION_ENGINE = ‘django.contrib.sessions.backends.cached_db‘ # 引擎

b. 使用

同上

5、加密cookie Session

a. 配置 settings.py

SESSION_ENGINE = ‘django.contrib.sessions.backends.signed_cookies‘ # 引擎

b. 使用

同上

更多参考：猛击这里和猛击这里

扩展：Session用户验证

def login(func):

def wrap(request, *args, **kwargs):

# 如果未登陆，跳转到指定页面

if request.path == ‘/test/‘:

return redirect(‘http://www.baidu.com‘)

return func(request, *args, **kwargs)

return wrap

分页

一、Django内置分页

from django.shortcuts import render
from django.core.paginator import Paginator, EmptyPage, PageNotAnInteger

L = []
for i in range(999):
    L.append(i)

def index(request):
    current_page = request.GET.get(‘p‘)

    paginator = Paginator(L, 10)
    # per_page: 每页显示条目数量
    # count:    数据总个数
    # num_pages:总页数
    # page_range:总页数的索引范围，如: (1,10),(1,200)
    # page:     page对象
    try:
        posts = paginator.page(current_page)
        # has_next              是否有下一页
        # next_page_number      下一页页码
        # has_previous          是否有上一页
        # previous_page_number  上一页页码
        # object_list           分页之后的数据列表
        # number                当前页
        # paginator             paginator对象
    except PageNotAnInteger:
        posts = paginator.page(1)
    except EmptyPage:
        posts = paginator.page(paginator.num_pages)
    return render(request, ‘index.html‘, {‘posts‘: posts})

views.py

<!DOCTYPE html>
<html>
<head lang="en">
    <meta charset="UTF-8">
    <title></title>
</head>
<body>
<ul>
    {% for item in posts %}
        <li>{{ item }}</li>
    {% endfor %}
</ul>

<div class="pagination">
      <span class="step-links">
        {% if posts.has_previous %}
            <a href=http://www.mamicode.com/"?p={{ posts.previous_page_number }}">Previous</a>
        {% endif %}
          <span class="current">
            Page {{ posts.number }} of {{ posts.paginator.num_pages }}.
          </span>
          {% if posts.has_next %}
              <a href=http://www.mamicode.com/"?p={{ posts.next_page_number }}">Next</a>
          {% endif %}
      </span>

</div>
</body>
</html>

Html

from django.shortcuts import render
from django.core.paginator import Paginator, EmptyPage, PageNotAnInteger


class CustomPaginator(Paginator):
    def __init__(self, current_page, max_pager_num, *args, **kwargs):
        """
        :param current_page: 当前页
        :param max_pager_num:最多显示的页码个数
        :param args:
        :param kwargs:
        :return:
        """
        self.current_page = int(current_page)
        self.max_pager_num = max_pager_num
        super(CustomPaginator, self).__init__(*args, **kwargs)

    def page_num_range(self):
        # 当前页面
        # self.current_page
        # 总页数
        # self.num_pages
        # 最多显示的页码个数
        # self.max_pager_num
        print(1)
        if self.num_pages < self.max_pager_num:
            return range(1, self.num_pages + 1)
        print(2)
        part = int(self.max_pager_num / 2)
        if self.current_page - part < 1:
            return range(1, self.max_pager_num + 1)
        print(3)
        if self.current_page + part > self.num_pages:
            return range(self.num_pages + 1 - self.max_pager_num, self.num_pages + 1)
        print(4)
        return range(self.current_page - part, self.current_page + part + 1)


L = []
for i in range(999):
    L.append(i)

def index(request):
    current_page = request.GET.get(‘p‘)
    paginator = CustomPaginator(current_page, 11, L, 10)
    # per_page: 每页显示条目数量
    # count:    数据总个数
    # num_pages:总页数
    # page_range:总页数的索引范围，如: (1,10),(1,200)
    # page:     page对象
    try:
        posts = paginator.page(current_page)
        # has_next              是否有下一页
        # next_page_number      下一页页码
        # has_previous          是否有上一页
        # previous_page_number  上一页页码
        # object_list           分页之后的数据列表
        # number                当前页
        # paginator             paginator对象
    except PageNotAnInteger:
        posts = paginator.page(1)
    except EmptyPage:
        posts = paginator.page(paginator.num_pages)

    return render(request, ‘index.html‘, {‘posts‘: posts})

扩展内置分页：views.py

<!DOCTYPE html>
<html>
<head lang="en">
    <meta charset="UTF-8">
    <title></title>
</head>
<body>

<ul>
    {% for item in posts %}
        <li>{{ item }}</li>
    {% endfor %}
</ul>

<div class="pagination">
<span class="step-links">
{% if posts.has_previous %}
    <a href=http://www.mamicode.com/"?p={{ posts.previous_page_number }}">Previous</a>
{% endif %}

    {% for i in posts.paginator.page_num_range %}
        <a href=http://www.mamicode.com/"?p={{ i }}">{{ i }}</a>
    {% endfor %}

    {% if posts.has_next %}
        <a href=http://www.mamicode.com/"?p={{ posts.next_page_number }}">Next</a>
    {% endif %}
</span>

<span class="current">
Page {{ posts.number }} of {{ posts.paginator.num_pages }}.
</span>

</div>
</body>
</html>

扩展内置分页：Html

二、自定义分页

分页功能在每个网站都是必要的，对于分页来说，其实就是根据用户的输入计算出应该在数据库表中的起始位置。

1、设定每页显示数据条数

2、用户输入页码（第一页、第二页...）

3、根据设定的每页显示条数和当前页码，计算出需要取数据表的起始位置

4、在数据表中根据起始位置取值，页面上输出数据

需求又来了，需要在页面上显示分页的页面。如：［上一页］［1］［2］［3］［4］［5］［下一页］

1、设定每页显示数据条数

2、用户输入页码（第一页、第二页...）

3、设定显示多少页号

4、获取当前数据总条数

5、根据设定显示多少页号和数据总条数计算出，总页数

6、根据设定的每页显示条数和当前页码，计算出需要取数据表的起始位置

7、在数据表中根据起始位置取值，页面上输出数据

8、输出分页html，如：［上一页］［1］［2］［3］［4］［5］［下一页］

#!/usr/bin/env python
# _*_coding:utf-8_*_
from django.utils.safestring import mark_safe
 
class PageInfo(object):
    def __init__(self,current,totalItem,peritems=5):
        self.__current=current
        self.__peritems=peritems
        self.__totalItem=totalItem
    def From(self):
        return (self.__current-1)*self.__peritems
    def To(self):
        return self.__current*self.__peritems
    def TotalPage(self):  #总页数
        result=divmod(self.__totalItem,self.__peritems)
        if result[1]==0:
            return result[0]
        else:
            return result[0]+1
 
def Custompager(baseurl,currentPage,totalpage):  #基础页，当前页，总页数
    perPager=11
    #总页数<11
    #0 -- totalpage
    #总页数>11
        #当前页大于5 currentPage-5 -- currentPage+5
            #currentPage+5是否超过总页数,超过总页数，end就是总页数
        #当前页小于5 0 -- 11
    begin=0
    end=0
    if totalpage <= 11:
        begin=0
        end=totalpage
    else:
        if currentPage>5:
            begin=currentPage-5
            end=currentPage+5
            if end > totalpage:
                end=totalpage
        else:
            begin=0
            end=11
    pager_list=[]
    if currentPage<=1:
        first="<a href=http://www.mamicode.com/‘‘>首页"
    else:
        first="<a href=http://www.mamicode.com/‘%s%d‘>首页" % (baseurl,1)
    pager_list.append(first)
 
    if currentPage<=1:
        prev="<a href=http://www.mamicode.com/‘‘>上一页"
    else:
        prev="<a href=http://www.mamicode.com/‘%s%d‘>上一页" % (baseurl,currentPage-1)
    pager_list.append(prev)
 
    for i in range(begin+1,end+1):
        if i == currentPage:
            temp="<a href=http://www.mamicode.com/‘%s%d‘ class=‘selected‘>%d" % (baseurl,i,i)
        else:
            temp="<a href=http://www.mamicode.com/‘%s%d‘>%d" % (baseurl,i,i)
        pager_list.append(temp)
    if currentPage>=totalpage:
        next="<a href=http://www.mamicode.com/‘#‘>下一页"
    else:
        next="<a href=http://www.mamicode.com/‘%s%d‘>下一页" % (baseurl,currentPage+1)
    pager_list.append(next)
    if currentPage>=totalpage:
        last="<a href=http://www.mamicode.com/‘‘>末页"
    else:
        last="<a href=http://www.mamicode.com/‘%s%d‘>末页" % (baseurl,totalpage)
    pager_list.append(last)
    result=‘‘.join(pager_list)
    return mark_safe(result)   #把字符串转成html语言

分页实例

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time    : 2017/6/26 19:53
# @Author  : Allen Liu
# @File    : pager.py

class PageInfo(object):

    def __init__(self,current_page,all_count,per_page,base_url,show_page=9):
        """
        current_page: 当前页码
        all_count: 数据库总行数
        per_page: 每页显示行数
        """
        try:
            self.current_page = int(current_page)
        except Exception as e:
            self.current_page = 1
        self.per_page = per_page

        a,b = divmod(all_count,per_page)
        if b: a += 1
        self.all_pager = a
        # all_pager 是 总页码数

        self.show_pager = show_page
        self.base_url = base_url

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

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

    def pager(self):
        # v = "<a href=http://www.mamicode.com/‘/custom.html?page=1‘>12"
        # return v
        page_list = []
        half = int((self.show_pager-1)/2)

        #如果数据总页数 < 9
        if self.all_pager < self.show_pager:
            begin = 1
            stop = self.all_pager + 1
        # 如果数据总页数 > 9
        else:
            # 如果当前页 <=5 ,永远显示 1,9
            if self.current_page <= half:
                begin = 1
                stop = self.show_pager +1
            else:
            # 尾页处理
                if self.current_page + half > self.all_pager:
                # 当前页+当前一半页码数 > 所有，则控制页码不再延伸
                    begin = self.all_pager - self.show_pager + 1
                    stop = self.all_pager + 1
                else:
                # 正常页码前后延伸
                    begin = self.current_page - half
                    stop = self.current_page + half + 1

        if self.current_page <= 1:
            prev = "<li><a href=http://www.mamicode.com/‘#‘>上一页"
        else:
            prev = "<li><a href=http://www.mamicode.com/‘%s?page=%s‘>上一页" % (self.base_url, self.current_page - 1,)
        page_list.append(prev)


        for i in range(begin,stop):
            if i == self.current_page:
                temp = "<li class=‘active‘><a href=http://www.mamicode.com/‘%s?page=%s‘>%s" % (self.base_url,i,i,)
            else:
                temp = "<li><a href=http://www.mamicode.com/‘%s?page=%s‘>%s" % (self.base_url,i,i,)
            page_list.append(temp)


        if self.current_page >= self.all_pager:
            nex = "<li><a href=http://www.mamicode.com/‘#‘>下一页"
        else:
            nex = "<li><a href=http://www.mamicode.com/‘%s?page=%s‘>下一页" % (self.base_url,self.current_page+1,)
        page_list.append(nex)

        # print(‘‘.join(page_list))
        return ‘‘.join(page_list)




    # all_count = models.UserInfo.objects.all().count()
    # page_info = PageInfo(request.GET.get(‘page‘),all_count,10,‘/custom.html‘,9)
    # user_list = models.UserInfo.objects.all()[page_info.start():page_info.end()]
    #
    # return render(request,‘custom.html‘,{‘user_list‘:user_list,‘page_info‘:page_info})

万能分页

Django基础

声明：以上内容来自用户投稿及互联网公开渠道收集整理发布，本网站不拥有所有权，未作人工编辑处理，也不承担相关法律责任，若内容有误或涉及侵权可进行投诉：投诉/举报工作人员会在5个工作日内联系你，一经查实，本站将立刻删除涉嫌侵权内容。

联系
我们

首页 > 代码库 > Django基础

Django基础

基本配置

路由系统

模板

Model

Form

跨站请求伪造

Cookie

Session

分页

看完仍有疑问？有类似问题直接问程序猿