title: Django 从0开始创建一个项目

tags: Django

Django 从0开始创建一个项目

创建Django工程及配置

创建工程：django-admin starproject 项目名
创建APP：Python3 manage.py startapp app名称
- 可以创建多个app,每个app代表不同的业务，开发的时候互不影响
- URL通过路由分发实现跳转
注册APP：在后面加上app的名称

INSTALLED_APPS = [

    'django.contrib.admin',

    'django.contrib.auth',

    'django.contrib.contenttypes',

    'django.contrib.sessions',

    'django.contrib.messages',

    'django.contrib.staticfiles',

    'app01',

    'app02',

    'app03',

]

配置模板路径：'DIRS': [os.path.join(BASE_DIR, 'templates')],
配置静态文件路径：STATICFILES_DIRS = ( os.path.join(BASE_DIR, 'static'), )
注释配置文件的一行: 'django.middleware.csrf.CsrfViewMiddleware',
- 这个不注释POST请求拿不到数据

Django的目录结构：

|--mysite01

|---|app01

    |----------|migrations

    |          |admin.py

    |          |apps.py

    |          |models.py

    |          |tests.py

    |          |views.py

    |mysite01

    |--------|__init__.py

    |        |settings.py

    |        |urls.py

    |        |wsgi.py

    |

    |templates

    |

    |manage.py

- migrations 存放有关数据库的文件，保存数据库的修改信息

- admin Django自己的后台管理

- models 通过ORM用类创建数据库和表

- tests 单元测试

- views 视图函数，业务处理，可以继续进行分类，此时就是views文件夹

- apps app的配置文件

- /mysite01/mysite01/__init__.py 配置数据库，默认是sqllite,这里配置成mysql,通过pymysql连接数据库

    import pymysql

    pymysql.install_as_MySQLdb()

-urls 路由系统

- wsgi web服务

路由系统：

URL-函数的对应关系

/login/ 一一对应静态路由
/add-user/(\d+) 支持正则动态路由
/add-user/(\d+).html 伪静态

具体实现

第一步是在urls中导入视图函数from app01 import views

设置URL：



urlpatterns = [

    url(r'^admin/', admin.site.urls),

    url(r'^index/', views.index),

    url(r'^edit/(\w+)/', views.edit), # 通过正则匹配路径

]

编写视图函数：

把URL变美观 ,视图函数要有参数接收def edit(request,arg):

from django.shortcuts import render, HttpResponse, redirect

def index(request):

    user_list = [

        'aaa', 'bbb', 'ccc',

    ]

    return render(request, 'index.html', {'user_list': user_list})

def edit(request, a1):

    print(a1)   # 接收函数URL的参数

    return HttpResponse("ok")

编写index.html,关键是以/结尾

<ul>

    {% for i in user_list %}

      <li>{{ i }}| <a href="/edit/{{ i }}/">编辑</a></li>

    {% endfor %}

  </ul>

总结：

在函数中通过参数a1接收url
点击的标签上添加路径结尾要用/
url(r'^edit/(\w+)/', views.edit),通常这里是以/结尾的

正则匹配

按照位置传值(有先后顺序)

url(r'^edit/(\w+)/(\w+)/', views.edit),

def edit(request, a1, a2):

    print(a1, a2)   # 接收函数URL的参数

    return HttpResponse("ok")

按照名称（关键字）（?P\w+）
- 注意是在正则表达式的括号里面传参数
- 可以没有顺序，这个过程相当于找到相应的参数名进行赋值

url(r'^edit/(?P<a1>\w+)/(?P<a2>\w+)/', views.edit),

def edit(request, a1, a2):

    return HttpResponse("ok")

注意：这两种是不能混合使用的，必须是统一的形式，这样才能用 *args, **kwargs.

要主要下面的情况是，*args用来接收按位置传值，**kwargs用来接收按关键字传值的

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

    return HttpResponse("ok")

规定路由的结尾
- 推荐用终止符$
  
  ^edit$
- 伪静态(SEO)
  
  url(r'^edit/(\w+)'.html$, views.edit),
404页面，默认页面

用户输错的时候返回404页面，或者是默认的主页

url(r'^', views.index),

前面的正则是不加内容的，后面写函数名

路由分发(涉及多个app的时候)

在处理不同业务的时候，多个app

引入include

mysite下面的总的路由

from django.conf.urls import url, include  # 在这里引入include

from django.contrib import admin

from app01 import views

urlpatterns = [

    url(r'^admin/', admin.site.urls),

    url(r'^app01/', include('app01.urls')), # 先匹配app01，然后找app01下面的url

    url(r'^app02/', include('app02.urls')),

]

app01的路由

from django.conf.urls import url

from django.contrib import admin

from app01 import views

urlpatterns = [

    url(r'^index/', views.index),

]

app02子路由

from django.conf.urls import url

from django.contrib import admin

from app02 import views

urlpatterns = [

    url(r'^index/', views.index),

]

url 关系命名

通过刚给URL设置别名，可以通过别名反向获取URL

url(r'^index,views.index,name =n1)

在index函数中就可以通过'n1'获取路径

from django.urls import reverse

v = reverse('n1')

    print(v)

还可以自己定义，返回的路径名

根据名字反生成URL

name reverse

URL的后缀可以自己任意定义

通过位置参数传值

url(r'^index/(\w+)/', views.index, name='n1'),

def index(request, a1): # 这里需要接受参数

    user_list = [

        'aaa', 'bbb', 'ccc',

    ]

    v = reverse('n1', args=(1,))  # 这里是等号，里面的参数可以是任意值

    print(v)

    return render(request, 'index.html', {'user_list': user_list})

通过关键字

url(r'^index/(?P<a1>\w+)/', views.index, name='n1'),

def index(request, a1): # 接收参数

    user_list = [

        'aaa', 'bbb', 'ccc',

    ]

    # v = reverse('n1', args=(1,))

    v = reverse('n1', kwargs={'a1': 123}) # 这里是按照关键字，形式是字典

    print(v)

    return render(request, 'index.html', {'user_list': user_list})

应用：

  {% url “m1” %}

  {% url “m1” "m2" %}

在模板中的form表单中不用action写具体的路径，直接获取路径

url(r'^login/', views.login, name='m1'),

def login(request):

    return render(request, 'login.html')

注意的是'm1' 要加引号

<form method="POST" action="{% url "m1" %}">

    <input type="text">

</form>

在跳转路径的时候

url(r'^index/', views.index, name='n1'),

url(r'^edit/(\w+)/', views.edit, name='n2'),

下面的url "n2"接收URL ，i是拼接的路径，后面还可以添加用空格分割

<ul>

    {% for i in user_list %}

            <!-- <li>{{ i }}| <a href="/edit/{{ i }}/">编辑</a></li> -->

            <li>{{ i }}| <a href="{% url "n2" i %}/">编辑</a></li>

    {% endfor %}

</ul>

别名是用于权限管理

前端处理在模板中通过别名反向获取
Python处理

视图函数 CBV(class based view) FBV(function based view)

CBV是URL对应类,FBV是URL对应函数

from表单提交

get 查

post 创建

View 下面的常用方法，实现增删改查可以进入View中查看除post get外都是ajax的方法

"""

get 查

post 创建

put 更新

delete 删除

"""

通过Class来获取get和post的数据，具体的实现方法是继承了View类中的dispath中的handle方法，handle通过把获取的GET/POST转换成小写，然后返回函数并执行

if request.method.lower() in self.http_method_names:

    handler = getattr(self, request.method.lower(), self.http_method_not_allowed)

else:

    handler = self.http_method_not_allowed

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

具体实现

url

CBV用类的方法as_view(),返回值是一个函数，在这里是get/post

url(r'^login.html$',views.Login.as_view()),

类

注意下面注释中的三点

1 导入View

2 继承View

3 request 获取全部的内容

from django.views import View # 需要导入

class Login(View):   # 继承View

    """

    get     查

    post    创建

    put     更新

    delete  删除

    """

    def get(self, request):  # 还要有参数request

        return render(request, 'login.html')

    def post(self, request):

        user = request.POST.get('user')  # 从前端的post发送的内容中获取数据

        print(user)

        return HttpResponse('login.post')

login的前端

<form method="POST" action="/login.html">

        <input type="text" name="user">

        <input type="submit" value="提交">

</form>

自己重写dispath方法

内部是通过反射getattr具体是dispatch函数

关键点：

1 super继承

2 返回值

3 前后加上相应的操作(批量操作)，实现了装饰器的功能

class Login(View):

    def dispath(self,request,*args,**kwargs):

        print("before")

        obj = super(Login, self).dispath(request,*args,**kwargs)  # 通过super继承父类的方法

        print('after')

        return obj  # 返回值就是执行相应的函数

    def get(self, request):

        return render(request, 'login.html')

    def post(self, request):

        user = request.POST.get('user')

        print(user)

        return HttpResponse('login.post')

参考文章

在models中使用反射

修改类的__str__

class UserType(models.Model):

    """

    用户类型

    """

    title = models.CharField(max_length=32)

    def __str__(self):

        return "%s-%s" %(self.id,self.title)  # 直接通过点就可以

v= models.UserType.objects.all().first()

v= models.UserType.objects.all()

print(v)

class UserInfo(models.Model):

    """

    用户表

    """

    name = models.CharField(max_length=16)

    age = models.IntegerField()

    ut = models.ForeignKey('UserType')

    def __str__(self):

        return "%s-%s-%s-%s" %(self.id,self.name,self.age,self.ut)

obj = models.UserType.objects.all().first()  # 这样获得是对象 all()获得是Queryset对象

    result = obj.userinfo_set.all()  #　　　

    print(result)

    "<QuerySet [<UserInfo: UserInfo object>, <UserInfo: UserInfo object>, <UserInfo: UserInfo object>]>"

    for i in result:

        print(i)

结果：

1-用户1-19-1-普通用户

3-蛋子-19-1-普通用户

4-钢弹-19-1-普通用户

Django的ORM操作

http请求

URL-视图(模板+数据)

ORM利用pymysql第三方连接数据库

Django默认的是MySQLDB，需要修改成pymysql

Django默认

ORM 操作表

Django自己有ORM框架，类-表，对象-行

其他的框架自己用pymysql和SqlAchemy

创建表
修改表(SQLAchemery不能修改表)
删除表

1 创建数据库

2 django默认的数据库是SQLlite,修改配置文件,设置连接的数据库为MySQL

DATABASES = {

    'default': {

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

        'NAME':'dataname',  # 数据库名

        'USER': 'root',

        'PASSWORD': '',

        'HOST': 'localhost',

        'PORT': 3306,

        }

}

3 替换MySQLDB,通过pymysql连接数据库

在工程的__init__中添加

import pymysql

pymysql.install_as_MySQLdb()

ORM操作数据行

在models中创建类

创建user_info表,默认id自动生成，注意数据长度

from django.db import models

class UserInfo(models.Model):

    nid = models.BigAutoField(primary_key=True)  # 不写默认生成id列

    user = models.CharField(max_length=32)

    password = models.CharField(max_length=64)

注册app

在settings中的添加

INSTALLED_APPS = [

    'django.contrib.admin',

    'django.contrib.auth',

    'django.contrib.contenttypes',

    'django.contrib.sessions',

    'django.contrib.messages',

    'django.contrib.staticfiles',

    'app01',

    'app02',

    'app03',

]

创建表的命令

python3 manage.py makemigrations
python3 manage.py migrate

D:\mysite01>python3 manage.py makemigrations

Migrations for 'app01':

  app01\migrations\0001_initial.py

    - Create model UserInfo

D:\mysite01>python3 manage.py migrate

Operations to perform:

  Apply all migrations: admin, app01, auth, contenttypes, sessions

Running migrations:

  Applying contenttypes.0001_initial... OK

  Applying auth.0001_initial... OK

  Applying admin.0001_initial... OK

  Applying admin.0002_logentry_remove_auto_add... OK

  Applying app01.0001_initial... OK

  Applying contenttypes.0002_remove_content_type_name... OK

  Applying auth.0002_alter_permission_name_max_length... OK

  Applying auth.0003_alter_user_email_max_length... OK

  Applying auth.0004_alter_user_username_opts... OK

  Applying auth.0005_alter_user_last_login_null... OK

  Applying auth.0006_require_contenttypes_0002... OK

  Applying auth.0007_alter_validators_add_error_messages... OK

  Applying auth.0008_alter_user_username_max_length... OK

  Applying sessions.0001_initial... OK

最后生成的表的名字是app01_userifo

修改表的列名

在类中直接修改，然后执行创建表的命令。

数据库的修改的内容都保存在migrations文件中，修改前会先读取，然后就行修改

输入y确认修改

D:\mysite01>python3 manage.py makemigrations

Did you rename userinfo.password to userinfo.pwd (a CharField)? [y/N] y

Migrations for 'app01':

  app01\migrations\0004_auto_20170624_2021.py

    - Rename field password on userinfo to pwd

D:\mysite01>python3 manage.py migrate

Operations to perform:

  Apply all migrations: admin, app01, auth, contenttypes, sessions

Running migrations:

  Applying app01.0004_auto_20170624_2021... OK

数据表增加

注意的是是否为空，有两种方案

设置为空 age = models.IntegerField(null=True)
设置默认值age = models.IntegerField(default=1)

创建外键关系

新建usergroup表，然后在userinfo表中增加一列外键关系表

ug = models.ForeignKey('UserGroup',null=True)

设置默认为空
最终生成的外键的名字是ug_id

数据行增删改查操作

增加一行数据

from app01 import models

def index(request):

    models.UserGroup.objects.create(title="技术部")

    return HttpResponse("...")

导入多条数据

外键用ug_id，添加前要有外键的数据

 models.UserInfo.objects.create(user='abc', pwd='123', age=18, ug_id=1)

查看数据

group_list = models.UserGroup.objects.all()

print(group_list)

QuerySet [<UserGroup: UserGroup object>, <UserGroup: UserGroup object>]

得到的结果是一个QuerySet对象，可以看做一个列表，列表中的每一个对象代表一行数据

在后台查看数据

def index(request):

    group_list = models.UserGroup.objects.all()

    print(group_list)

    for row in group_list:

        print(row.id, row.title)

    return HttpResponse("...")

在前端模板中查看数据

  <ul>

    {% for row in user_list %}

      <li>{{ row.nid }} | {{row.user }} | {{ row.pwd }} | {{ row.age }}</li>

    {% endfor %}

  </ul>

结果：

1 | abc | 123 | 18

2 | abc | 123 | 18

查看数据的范围filter

使用了双下划线

user_list = models.UserInfo.objects.filter(nid=1)

user_list = models.UserInfo.objects.filter(nid__gt=1) # nid 大于1的数据

user_list = models.UserInfo.objects.filter(nid__lt=2) # nid 小于2的数据

删除数据

注意有外键的不能删除

models.UserInfo.objects.filter(nid=3).delete()

更新数据

models.UserGroup.objects.filter(id=2).update(title="新的部门")

连表操作

和SQLAchemy类似

对象可以跨表

在循环的时候跨表

拿一个的时候是obj

all 是QerySet[obj,obj]

filterQerySet[obj,obj]

正向操作

1 all()使用点

通过UserInfo 的ut(外键)连表UserType

    v = models.UserInfo.objects.all().first()  # 用first进行试验

    print(v.ut.id,v.ut.title)  # 使用点能点出方法

2 values() 使用双下划线进行跨表

返回值是字典

v2 = models.UserInfo.objects.values('id','name','age','ut__id','ut__title')

    for i in v2:

        print(i)

    """

    {'id': 1, 'name': '用户1', 'age': 19, 'ut__id': 1, 'ut__title': '普通用户'}

    {'id': 2, 'name': '用户2', 'age': 19, 'ut__id': 2, 'ut__title': '超级用户'}

    {'id': 3, 'name': '蛋子', 'age': 19, 'ut__id': 1, 'ut__title': '普通用户'}

    {'id': 4, 'name': '钢弹', 'age': 19, 'ut__id': 1, 'ut__title': '普通用户'}

    {'id': 5, 'name': '钢珠', 'age': 19, 'ut__id': 3, 'ut__title': '白金用户'}

    """

3 value_list()

values_lis也是用双下划线

返回值是元组

v2 = models.UserInfo.objects.values_list('id','name','age','ut__id','ut__title')

    for i in v2:

        print(i)

(1, '用户1', 19, 1, '普通用户')

(2, '用户2', 19, 2, '超级用户')

(3, '蛋子', 19, 1, '普通用户')

(4, '钢弹', 19, 1, '普通用户')

(5, '钢珠', 19, 3, '白金用户')

反向操作

1 小写的表名_set

下面是通过all().first()获取第一个对象。只能通过对象进行反向操作userinfo_set.all()

    obj = models.UserType.objects.all().first()  # 这样获得是对象 all()获得是Queryset对象

    result = obj.userinfo_set.all()  # 只能是通过对象进行操作　

    print(result)

    "<QuerySet [<UserInfo: UserInfo object>, <UserInfo: UserInfo object>, <UserInfo: UserInfo object>]>"

    for i in result:

        print(i)

下面是通过反射获得的：

1-用户1-19-1-普通用户

3-蛋子-19-1-普通用户

4-钢弹-19-1-普通用户

2 values

返回的是字典

v = models.UserType.objects.values('id','title','userinfo')

    for i in v:

        print(i)

结果：

{'id': 1, 'title': '普通用户', 'userinfo': 1}

{'id': 1, 'title': '普通用户', 'userinfo': 3}

{'id': 1, 'title': '普通用户', 'userinfo': 4}

{'id': 2, 'title': '超级用户', 'userinfo': 2}

{'id': 3, 'title': '白金用户', 'userinfo': 5}

v = models.UserType.objects.values('id', 'title', 'userinfo__id','userinfo__name','userinfo__age')

    for i in v:

        print(i)

结果：

{'id': 1, 'title': '普通用户', 'userinfo__id': 1, 'userinfo__name': '用户1', 'userinfo__age': 19}

{'id': 1, 'title': '普通用户', 'userinfo__id': 3, 'userinfo__name': '蛋子', 'userinfo__age': 19}

{'id': 1, 'title': '普通用户', 'userinfo__id': 4, 'userinfo__name': '钢弹', 'userinfo__age': 19}

{'id': 2, 'title': '超级用户', 'userinfo__id': 2, 'userinfo__name': '用户2', 'userinfo__age': 19}

{'id': 3, 'title': '白金用户', 'userinfo__id': 5, 'userinfo__name': '钢珠', 'userinfo__age': 19}

3 values_list

values_list返回的是元组对象

用filter进行跨表

正向操作

v=models.UserInfo.objects.filter(ut__title='普通用户').values('id','name','ut__title')

    # print(v)

    for i in v:

        print(i)

结果：



    {'id': 1, 'name': '用户1', 'ut__title': '普通用户'}

    {'id': 3, 'name': '蛋子', 'ut__title': '普通用户'}

    {'id': 4, 'name': '钢弹', 'ut__title': '普通用户'}

反向操作

A.onjects.filter(b__id=xx 或 b__age=xx 或 b__name=)

下面测试的是age=19的用户

v=models.UserType.objects.filter(userinfo__age=19).values('id','title','userinfo__name')

    print(v)

    for i in v:

        print(i)

结果：

{'id': 1, 'title': '普通用户', 'userinfo__name': '用户1'}

{'id': 2, 'title': '超级用户', 'userinfo__name': '用户2'}

{'id': 1, 'title': '普通用户', 'userinfo__name': '蛋子'}

{'id': 1, 'title': '普通用户', 'userinfo__name': '钢弹'}

{'id': 3, 'title': '白金用户', 'userinfo__name': '钢珠'}

Django分页

分页的目的是：在数据量太大分批获取数据并在页面上进行展示

简单的操作就是通过切片获取

 user_list = models.UserInfo.objects.all()[1:10]

 user_list = models.UserInfo.objects.all()[10:20]

Django自带分页

适合做上下页，只能在Django中用

分页操作实现

首先导入对象Paginator

from django.core.paginator import Paginator,Page,PageNotAnInteger,EmptyPage

在浏览器中通过GET发送当前的页码，后面加上?page=1

如http://127.0.0.1:8000/index.html?page=1

python后台代码

def index(request):

    """

    Djangon内置的分页，实现的功能是上下页

    :param request:

    :return:

    """

    # 通过GET方式获取当前页码

    current_page = request.GET.get('page')

    user_list = models.UserInfo.objects.all()  # 获取全部的用户数据

    # user_list = models.UserInfo.objects.all().count() # 获取具体的数据量

    # print(user_list)

    # user_list = models.UserInfo.objects.all()[0:10]  # 通过切片的方式获取数据

    paginator = Paginator(user_list, 10)  # (第一参数object_list,第二个参数per_age)

    # 下面是paginator的方法

    # per_page: 每页显示条目数量

    # count:    数据总个数

    # num_pages:总页数

    # page_range:总页数的索引范围，如: (1,10),(1,200)

    # page:     返回值是一个对象

    posts = paginator.page(current_page)  # 传入的是页码的值

    # 下面是posts的方法

    # has_next              是否有下一页

    # next_page_number      下一页页码

    # has_previous          是否有上一页

    # previous_page_number  上一页页码

    # object_list           分页之后的数据列表

    # number                当前页

    # paginator             paginator对象

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

前端代码,通过posts拿到分页后的数据，上下页之前先判断是否有上一页或者下一页，之后拼接路径。

<h1>django内置的分页</h1>

    <ul>

        {% for row in posts.object_list %} {# object_list是分页之后的数据列表 #}

            <li>{{ row.name }}</li>

        {% endfor %}

    </ul>

    <div>

        {% if posts.has_previous %}

            <a href="/index.html?page={{ posts.previous_page_number }}">上一页</a>

        {% endif %}

        {% if posts.has_next %} {# 判断有下一页的时候 #}

            <a href="/index.html?page={{ posts.next_page_number }}">下一页</a>

        {% endif %}

    </div>

关于URL中的问题

在URL中只能接收的是int型的数字，如果传入的是字母，会报错PageNotAnInteger at /index.html,在后台进行异常处理，捕捉异常之后的操作是返回到第一页。

在URL中传入的是负数的话，报错EmptyPage at /index.html，处理同样是返回到第一页

已经在前面导入了异常处理的

from django.core.paginator import Paginator,Page,PageNotAnInteger,EmptyPage

try:

    posts = paginator.page(current_page)  # 传入的是页码的值

    # except PageNotAnInteger as e:

    #     posts = paginator.page(1)

    # except EmptyPage as e:

    #     posts = paginator.page(1)

except Exception as e:

    posts = paginator.page(1)

Django的页码

Django的页码在数据量很大的时候，会显示所有的分页的页码，比如有300条数据，每页显示10条数据，就会有30个页码。所以需要进行自己开发

在index的上下页中间添加，post下有paginator方法，paginator下有page_range 方法

<div>

        {% if posts.has_previous %}

            <a href="/index.html?page={{ posts.previous_page_number }}">上一页</a>

        {% endif %}

        {% for num in posts.paginator.page_range %} {# post下有paginator，paginator下有page_range #}

            <a href="/index.html?page={{ num }}">{{ num }}</a>

        {% endfor %}

        {% if posts.has_next %} {# 判断有下一页的时候 #}

            <a href="/index.html?page={{ posts.next_page_number }}">下一页</a>

        {% endif %}

</div>

总结：

Django的分页适用于上下翻页的情况，不适合中间的页码

自定义分页

可以在任何地方使用，以后封装成一个类

最原始的实现

def custom(request):

    # 用户当前要访问的页码

    current_page = request.GET.get('page')

    current_page = int(current_page)

    # 每页显示的个数

    per_page = 10

    # 1 1:10  最后一个取不到

    # 2 10:20

    # 3 20:30

    start = (current_page - 1) * per_page

    end = current_page * per_page

    user_list = models.UserInfo.objects.all()[start:end]

    return render(request, 'custom.html', {"user_list": user_list})

把页码的计算封装成类

注意类中的参数传值的时候要一一对应

class PageInfo(object):

    def __init__(self, current_page, all_count, per_page, ):

        try:

            self.current_page = int(current_page)

        except Exception as e:

            current_page = 1  # url 不是

        self.per_page = per_page

        a, b = divmod(all_count, per_page)  # 通过divmod进行分页，有余数的再加一页

        if b:

            a += 1

        self.all_page = a  # all_page 是总的页码

    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='/custom.html?page=1'>1</a>" # 双引号中中用单引号

        # return v

        # 显示所有的页码

        page_list = []

        for i in range(1, self.all_page + 1):

            if i == self.current_page:

                # 判断是当前页的时候，加上背景色

                # temp = "<a style='padding=5px display=inl' href='/custom.html?page=%s'>%s</a>" %(i,i)  # 选中的加背景色

                temp = "<a style='display: inline-block;padding: 5px;margin: 5px;background-color: red' href='/custom.html?page=%s'>%s</a>" % (

                i, i)

            else:

                temp = "<a style='display: inline-block;padding: 5px;margin: 5px' href='/custom.html?page=%s'>%s</a>" % (

                i, i)

            page_list.append(temp)

        return ''.join(page_list)  # 把列表中的值取出并拼接成字符串

# 自定义分页

def custom(request):

    # 用户当前要访问的页码

    # current_page = request.GET.get('page')

    # page_info = PageInfo(current_page,10)

    all_count = models.UserInfo.objects.all().count()

    page_info = PageInfo(request.GET.get('page'), all_count, 10)

    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})

继续优化成页码的显示方式

这种是定义了固定的显示页面数11(当前页和前后5页)，现在的问题是两端的极限值的问题

左边必须是当前页>=6

右边的问题是会查不到数据后还显示页码

class PageInfo(object):

    def __init__(self, current_page, all_count, per_page, show_page=11):

        try:

            self.current_page = int(current_page)

        except Exception as e:

            current_page = 1  # url 不是

        self.per_page = per_page

        a, b = divmod(all_count, per_page)  # 通过divmod进行分页，有余数的再加一页

        if b:

            a += 1

        self.all_page = a  # all_page 是总的页码

        self.show_page = show_page

    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='/custom.html?page=1'>1</a>" # 双引号中中用单引号

        # return v

        half = int((self.show_page-1)/2)

        begin = self.current_page - half

        stop =self.current_page +half +1

        # 显示所有的页码

        page_list = []

        for i in range(begin,stop):

            if i == self.current_page:

                # 判断是当前页的时候，加上背景色

                # temp = "<a style='padding=5px display=inl' href='/custom.html?page=%s'>%s</a>" %(i,i)  # 选中的加背景色

                temp = "<a style='display: inline-block;padding: 5px;margin: 5px;background-color: red' href='/custom.html?page=%s'>%s</a>" % (

                i, i)

            else:

                temp = "<a style='display: inline-block;padding: 5px;margin: 5px' href='/custom.html?page=%s'>%s</a>" % (

                i, i)

            page_list.append(temp)

        return ''.join(page_list)  # 把列表中的值取出并拼接成字符串

优化右边的极限