Python 19 Django 详解

客户端发送请求==》服务器端的url  ==》对应服务器端的函数==》返回字符串 《== open html+ sql orm

Form表单提交：
	提交	-> url	-> 函数或类中的方法　　->DB 或者HTML
						 HttpResponse(已经渲染完成的字符串，obj.name已经被目的变量字符串替代)
						 render/
						 redirect
						 返回给字符串中的html语言语法，都是经过处理的，即render发送的html跟参数并不是直接返回给用户，而是处理好的标准字符串
　　　　 用户	<<<<<<<<<<<<<<返回<<<<<<<<<<<<<   字符串	（接收到redirect时）自动发起另外一个请求
	--> url	...
	
Ajax：
	提交	-> url	->	函数或类（HttpResponse）
	返回字符串			<<<<<<<<<<<<
	location.reload()	==> 刷新
	location.href="某个地址"	==> 跳转

1、django-admin startproject mysite

2、python manage.py startapp cmdb

3、模板路径、静态文件路径、注释csrf

/index/					->	函数或类.as_view()
/detail-(\d+)/			->	函数（参数）或类.as_view() （参数）
/detail/(?P<nid>\d+)	->	函数（参数）或者类.as_view()	(参数)
/cmdb/					->	include("app01.urls")
/cmdb/ name=‘a1‘		->	include("app01.urls")
						- 视图中：reverse
						- 模板语言中：{%url “a1”%}
　*********

　url(r‘^wqefvqwbeqnwdla/‘, views.index, name=‘indexx‘)
　<form action=‘{%url ‘indexx‘%}‘ method="post">
　url(r‘^wqefvqwbeqnwdla/(\d+)/‘, views.index, name=‘indexx‘) =>	<form action=‘{%url ‘indexx‘ 2%}‘ method="post"> form里面的2是写死的，没办法灵活追踪

*******					
urlpatterns = patterns(‘‘,    
		url(r‘^article$‘,‘get_news_index‘ ，name="news_index"),
		　　　　)
<a href="{%url ‘appname:news_index‘%}">资讯</a>
其中appname是该url所在的app的name，而new_index是url(r‘^article$‘,‘get_news_index‘ ，name="news_index")中的name参数
HttpResponseRedirect(reverse("news_index"))

# 默认值
url(r‘^index/‘,views.index, {‘name‘:‘dandy‘}),
def index(request, name):  # 注意这里必须接收name参数，不然报错，因为url里面有**kwargs参数的存在

# 命名空间
/admin/		include(‘app01.urls‘, namespace=‘admin‘)
/cmdb/		include(‘app01.urls‘, namespace=‘cmdb‘)

app01.urls
/index/     name =‘n1‘
# 同时 app01外部设置一下app01的名称、app_name = ‘app01‘
def index(request):
    reverse(‘admin:n1‘)  # 生成urls
模板语言里面：
    {% url ‘admin:index‘%}

request.GET
request.POST
request.FILES
# checkbox 等多选内容   request.POST.getlist()
			
# 上传文件 <form enctype="multipart/form-data">

request.path_info ==> 获取当前请求的网址
文件对象 = request.FILES.get()
文件对象.name => 文件名
文件对象.size =>字节大小
文件对象.chunks()
obj = request.FILES.get(‘aaa‘)
obj.name
f = open(obj.name, mode="wb")
for item in obj.chunks():
	f.write(item)
f.close()

　FBV：函数
　　　def index（request, *args, **kwargs）:
　　　　..
　CBV：类
　　　class Home(views.View):
　　　　def get(self, request, *args, **kwargs):
　　　　　　...

# 视图的其他信息
from django.core.handlers.wsgi import WSGIRequest  #从WSGIRequest 下钻可以查到内部environ的方法
request.environ
request.environ[‘HTTP_USER_AGENT‘]	==> 查看发送过来的终端，iphone，Android，pc. #根据key可以取很多内容，可以for循环查看

\r\n\r\n 作为请求头跟body的分割
request.body	所有原生内容存储
request.Meta(...)	用户终端就存储在这里

服务器返回的时候 也是两部分，响应内容和响应头
response[‘name‘] = ‘dandy‘
接受的响应头里面还有上面定制的这组键值对

- 装饰器	==>	用装饰器解决重复用户认证
FBV
	    def auth(func): # FBV
		def inner(request, *args, **kwargs):
			v = request.COOKIES.get(‘username‘)
			if not v:
    			    return redirect(‘/app01/temp1‘)
			return func(request, *args, **kwargs)
		return inner
		
CBV
from django.utils.decorators import method_decorator
	    def auth(func): # FBV
		def inner(request, *args, **kwargs):
			v = request.COOKIES.get(‘username‘)
			if not v:
    			    return redirect(‘/app01/temp1‘)
			return func(request, *args, **kwargs)
		return inner

	# @method_decorator(auth, name=‘dispatch‘)
	class Order(views.View):
		#@method_decorator(auth)
		#def dispatch(self, request, *args, **kwargs):
		#      return super(Order, self).dispatch(request, *args, **kwargs)
		
                @method_decorator(auth) 
		def get(self,request):
		       v = request.COOKIES.get(‘username‘)
		       return render(request, ‘temp3.html‘)
		def get(self,request):
			v = request.COOKIES.get(‘username‘)
			return render(request, ‘temp3.html‘)                

**************在django的模板语言里面，索引用点，没有中括号****************
# 循环取值
{% for i in dict%}
<td>{{%i.item%}}</td>
{%endfor%}

# 取值
<h1>{{obj.name}}</h1>

# if else逻辑判断
{%if a==b%}
    <p>aaa</p>
{%else%}
    <p>vvv</p>
{%endif%}


render(request,"*.html", {"obj":1234, "k1":{1,2,3,4}, "k2":{"name":"dandy"})
	
<h1>{{obj}}</h1>
<h2>{{k1.0}}</h1>
<h3>{{k2.name}}</h3>
{%for i in k1%}
<td>i</td>
{%endfor%}

{%for row in k2.keys%}
<td>row</td>
{%endfor%}

{%for row in k2.values%}
<td>row</td>
{%endfor%}
	
{%for key,value in k2.items%}
<td>key, value</td>
{%endfor%}

　模板语言序列化

　JSON.parse(data)==>转换为json数据
　JSON.stringify(data)==>json数据转换为字符串

{{forloop.counter}}	--> 模板语言里给表的每行加一个序号，自增，相当于数据库ID
{{forloop.counter0}}	-->从0开始
{{forloop.revcounter}}	-->倒序
{{forloop.revcounter0}}	-->倒序排到0
{{forloop.last}}	-->是否是最后一个循环
{{forloop.first}}	-->是否是第一个循环
{{forloop.parentloop}}	-->父循环的序列号（外层还有个循环，嵌套的在里面的用这一句，第一次输出全是1，第二次2）

- 母版..html
	模板继承
		- master		{% block content %}{% endblock %}
		- master:header	{% block title %}{% endblock %}
		
		页网页先写上{% extends ‘master.html‘ %}，表明继承哪个模板
		- 子页面		{% block content %}{% endblock %}	==> 替换模板里面的哪个block
		- 子页面		{% block title %}{% endblock %}
		
		关于继承母版的css跟js：
		在母版的css下面写上一个	{% block css %}{% endblock %}
							{% block js %}{% endblock %}
		子页面继承：	-css	{% block css %}
							<style>
							    body{background-color: red}
							</style>
						{% endblock %}
					-js	{% block js %}
    							<script>
								..
							</script>
						{% endblock %}
		
include tag页面，相当于网页上某一块标签样式一直重复的使用,渲染网页的某一块
		- tag.html  ==> <form>
    				    <input type=‘text‘ />
				    <input type=‘button‘ />
				</form>
							
		- 要使用tag的界面==>	{% include ‘tag.html‘%}
									

自定义sample_tag
	1、在app下创建一个templatetags目录
	2、在此目录下新建任意xxoo.py文件
	3、from django import template
	   register = template.Library()
					
　　　　　　 @register.simple_tag
	   def func(a1, a2)
	       return a1+a2
			
	4、settings注册app
	5、顶部{% load xxoo%}	如果有extends，写在之后
	6、{% func 1 3%}	==>{% func arg1 arg2 %}
	缺点：不能作为if条件
	优点：参数任意
自定义filter
	1、2、同上
	3、		from django import template
			from django.utils.safestring import mark_safe
			register = template.Library()
			
			@register.filter
			def func(a1, a2)  # filter只能传2个参数
				return a1+a2
	4、5、
	6、	{{"maliya"|func:"LaoShi"}}	==>	{{arg1|func:"参数二"}}
	优点：可以作为if条件（模板语言里）
	缺点：参数不能任意，最多2个，不能加空格

帮助方法：
{{ item.event_start|date:"Y-m-d H:i:s"}}
{{ bio|truncatewords:"30" }}
{{ my_list|first|upper }}
{{ name|lower }}

$.ajax({
	url:‘/host‘		# 提交到哪
	type:“POST”		# 提交方式
	data:{‘k1‘:‘v1‘,‘k2‘:‘v2‘}
	success: function(data){	# 这个匿名函数会等到服务端给我们返回数据时自动触发
		if(data){
			location.reload()
		}else{
			alert(data)
		}
	}
	})
　　　　　ajax请求 return HttpResponse
	$.get(url=‘xxx‘,data={‘x‘:‘x‘})
		-->调用上面的ajax，type为get
	
	$.post
		-->调用ajax，type为post
	$.getJson

        建议：永远让服务器端返回一个字典
	return HttpResponse(json.dumps(字典))
	

        模板语言序列化
	JSON.parse(data)==>转换为json数据
	JSON.stringify(data)==>json数据转换为字符串
	
	$.ajax({
		data:$(‘.edit_form‘).serialize()	# 获取所有的editform里面的元素值，打包
		dataType:‘JSON‘	# 匿名函数的data就会自动序列化成json。#如果这样写返回给success的数据已经就是json数据类型对象
		traditional:true,  # 传给后台的json数据中有列表的时候必须加上,
	})    
jquery
　　var list = []
　　hid = $(this).val()
　　list.push(hid)

# 设置cookies
res = redirect(request, ‘/index/‘)
res.set_cookies(‘username‘,‘dandy‘)	==> 设置cookie，关闭浏览器失效
或者
res = render(request, ‘index.html‘)
res.set_cookies(‘username‘,‘dandy‘)

# 获取cookies
v = request.COOKIES.get(‘username‘)
v = request.COOKIES[‘username‘]

其他参数
key,              键
value=‘‘,         值
max_age=None,     超时时间
expires=None,    截止时间失效
path=‘/‘,         Cookie生效的路径，/ 表示根路径，特殊的：跟路径的cookie可以被任何url的页面访问 
domain=None,      Cookie生效的域名
secure=False,     https传输
httponly=False    只能http协议传输，无法被JavaScript获取（不是绝对，底层抓包可以获取到也可以被覆盖）

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

# 基于salt的值加盐
obj = HttpResponse(‘s‘)
obj.set_signed_cookie(‘username‘,‘dandy‘, salt=‘asdfqw‘)
# 基于salt进行解密
request.get_signed_cookie(‘username‘, salt=‘asdfqw‘)

中间件 django.middleware.csrf.CsrfViewMiddleware

@csrf_protect，为当前函数强制设置防跨站请求伪造功能，即便settings中没有设置全局中间件。
@csrf_exempt，取消当前函数防跨站请求伪造功能，即便settings中设置了全局中间件。
注：from django.views.decorators.csrf import csrf_exempt,csrf_protect

在ajax的函数里面加上一个header就好了
header:{‘X-CSRFtoken‘,$.cookie(‘csrftoken‘)
	
　　　　  $.ajax({
		url:‘/login/‘,
		type:‘POST‘,
		data:{‘user‘:‘root‘,‘pwd‘:‘123‘},
		header:{‘X-CSRFtoken‘:...},
		success:function(){
		}
	})

$.ajaxSetup({
		beforeSend:function(xhr,settings){		# xml http request对象
		xhr.setRequestHeader(‘X-CSRFtoken‘,$.cookie(‘csrftoken‘))
		}
	});

<!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));  # 这四种都不需要进行csrf认证
        }
        $.ajaxSetup({
            beforeSend: function(xhr, settings) {
                if (!csrfSafeMethod(settings.type) && !this.crossDomain) {
                    xhr.setRequestHeader("X-CSRFToken", csrftoken);
                }
            }
        });
        function Do(){
            $.ajax({  # ajax函数不变
                url:"/app01/test/",
                data:{id:1},
                type:‘POST‘,
                success:function(data){
                    console.log(data);
                }
            });
        }
    </script>
</body>
</html>

a.创建类和字段
		class User(models.Model):
			id = models.IntegerField()
			name = models.CharField(max_length=12)
			
		python manage.py makemigrations
		python manage.py migrate
		
		# settings.py 	注册APP
	
b.操作
	增	=>models.User.objects.create(id=2,name="dandy") ==>id 不是主键，不自增，不是key
		=> dic = {‘name‘:‘xx‘, "age":22}
		models.User.objects.create(**dic)
			
		obj = models.User("name":"xx", "age":22)
		obj.save()
			
	删	models.User.objects.filter(name=‘xx‘).delete()
	改	
		models.User.objects.filter(id__gt=1).update(name=‘asd‘)
		dic = {"name":"xx", "age",22}
		models.User.objects.filter(id__gt=1).update(**dic)
	查	
		models.User.objects.filter(id__gte=1)  >=
		models.User.objects.filter(id__lte=1, name=‘xxo‘)
		dic = {"name":"dandy","age__gt":22}
		models.User.objects.filter(**dic)	字典
	
	外键
		class UserType(models.Model):
			caption = models.CharField(max_length=22)
			
		class User(models.Model):
			name = models.CharField(max_length=23)
			age = models.IntegerField()
			# user_type_id = models.IntegerField()
			user_type = models.ForeignKey("UserType", to_field="id")
			
			choices_detail = (
				(u‘M‘, u‘Male‘),
				(u‘F‘, u‘Female‘),
			)
			model = models.CharField(max_length=2, choices=choices_detail)

	查询：models.User.objects.all()
		　 ==>queryset ==>[obj(id, name, age),obj(id, name, age)]   -->对象
		  models.User.objects.all().values("id","name")			
	　　　　 　　==>queryset ==>[{"id":1, "name": "dandy"},{}]			 -->字典
		  models.User.objects.all().values_list("id","name")
		   ==>queryset ==>[(1,"dandy"),()]							 -->列表
			
		  models.User.objects.get(id=1)  # 获取到一个对象，如果id不存在就报错
		  models.User.objects.filter(id=1)  # 没有拿到就是空列表
		  models.User.objects.filter(id=1).first()  # 没有拿到就是None
		  
		# 用.进行跨表
		  v = models.User.objects.filter(id__gt=0)
		  v[0].b.caption	-->	通过.进行跨表  ==> [obj(id, name,另一个对象(....))]
		# 用__双下划线进行跨表  
		  v = models.User.objects.filter(id__gt=0).values(‘id,name,user_type__caption‘) 
		# 获取到的列表内部，是一个个元组，用index取值
		  v = models.User.objects.filter(id__gt=0).values_list(‘id,name,user_type__caption‘) 
		  {%for row in v%}
		  row.0 - row.1
		  {%endfor%}
			
		{{forloop.counter}}	--> 模板语言里给表的每行加一个序号，自增，相当于数据库ID
		{{forloop.counter0}}	-->从0开始
		{{forloop.revcounter}}	-->倒序
		{{forloop.revcounter0}}	-->倒序排到0
		{{forloop.last}}		-->是否是最后一个循环
		{{forloop.first}}		-->是否是第一个循环
		{{forloop.parentloop}}	-->父循环的序列号（外层还有个循环，嵌套的在里面的用这一句，第一次输出全是1，第二次2） 

创建多对多
		方式一：自定义创建表
		自己创建表1、表2，然后创建表1_to_表2
		
                
		方式二：Django自动生成（Django自动创建关系表）
		创建表1，创建表2并在二中加一列
			- r = models.ManyToManyField(‘表1‘)
		自动创建的表，无法对表直接做操作
                只有3个列，自增id，2张表的自增id
		
		绑定
		obj = 表1.objects.get(id=1)
		obj.r.add(1)==>表1的id1跟表2的id1绑定 
		
		也可以批量传入列表,下面2种都支持
		obj.r.add(1,2,3)
		obj.r.add([1,2,3])
		删除
		obj.r.remove(1)
		obj.r.remove(2,4)
		obj.r.remove(*[1,2,3])
		
		obj.r.clear()  # 清空表1 id=1的在表3里面的所有关系 
		obj.set([3,5,6]) ==> 表3的数据库里面只会保留1 3；1 5；1 6这三个；
　　　　　　　　　　　　　　　　　　　　　　 清空其他所有的
		
		obj.r.all()		==>表1 id=1的所有的组合对象列表 queryset    

def index(request):
    print(‘到达‘)
    return HttpResponse(‘ok‘)

#!/user/bin/env python
# -*-coding: utf-8-*-
from django.utils.deprecation import MiddlewareMixin
from django.shortcuts import HttpResponse
class M1(MiddlewareMixin):
    def process_request(self, request):
        print(‘m1‘)
    def process_response(self, request, response):
        print(‘m1_r‘)
        return response


class M2(MiddlewareMixin):
    def process_request(self, request):
        print(‘m2‘)
        return HttpResponse(‘中断‘)  # 这里返回
    def process_response(self, request, response):
        print(‘m2_r‘)
        return response


class M3(MiddlewareMixin):
    def process_request(self, request):
        print(‘m3‘)

    def process_response(self, request, response):
        print(‘m3_r‘)
        return response

    CACHES = {
        ‘default‘: {
            ‘BACKEND‘: ‘django.core.cache.backends.memcached.PyLibMCCache‘,
            ‘LOCATION‘: [
                (‘172.19.26.240:11211‘,11)
                (‘172.19.26.242:11211‘,10)
            ]
        }
    }

CACHES = {
    ‘default‘: {
        ‘BACKEND‘: ‘django.core.cache.backends.filebased.FileBasedCache‘,
        ‘LOCATION‘: os.path.join(BASE_DIR, ‘cache‘)
    }
}

from django.views.decorators.cache import cache_page
@cache_page(10)
def cache_test(request):
    ctime = time.time()
    print(ctime)
    return render(request, ‘cache.html‘, {"obj": ctime})

Model signals
    pre_init                    # django的modal执行其构造方法前，自动触发
    post_init                   # django的modal执行其构造方法后，自动触发
    pre_save                    # django的modal对象保存前，自动触发
    post_save                   # django的modal对象保存后，自动触发
    pre_delete                  # django的modal对象删除前，自动触发
    post_delete                 # django的modal对象删除后，自动触发
    m2m_changed                 # django的modal中使用m2m字段操作第三张表（add,remove,clear）前后，自动触发
    class_prepared              # 程序启动时，检测已注册的app中modal类，对于每一个类，自动触发
Management signals
    pre_migrate                 # 执行migrate命令前，自动触发
    post_migrate                # 执行migrate命令后，自动触发
Request/response signals
    request_started             # 请求到来前，自动触发
    request_finished            # 请求结束后，自动触发
    got_request_exception       # 请求异常后，自动触发
Test signals
    setting_changed             # 使用test测试修改配置文件时，自动触发
    template_rendered           # 使用test测试渲染模板时，自动触发
Database Wrappers
    connection_created          # 创建数据库连接时，自动触发

from django.core.signals import request_finished
    from django.core.signals import request_started
    from django.core.signals import got_request_exception

    from django.db.models.signals import class_prepared
    from django.db.models.signals import pre_init, post_init
    from django.db.models.signals import pre_save, post_save
    from django.db.models.signals import pre_delete, post_delete
    from django.db.models.signals import m2m_changed
    from django.db.models.signals import pre_migrate, post_migrate

    from django.test.signals import setting_changed
    from django.test.signals import template_rendered

    from django.db.backends.signals import connection_created


    def callback(sender, **kwargs):
        print("xxoo_callback")
        print(sender,kwargs)

    xxoo.connect(callback)
    # xxoo指上述导入的内容

import pymysql
pymysql.install_as_MySQLdb()

import  .....

url(r‘^fm/‘, views.fm),

{‘user‘: ‘dandy‘, ‘pwd‘: ‘password.1‘, ‘email‘: ‘fqoweq@fac.com‘}

obj.errors对应的输出
<ul class="errorlist"><li>user<ul class="errorlist"><li>This field is required.</li></ul></li><li>pwd<ul class="errorlist"><li>This field is required.</li></ul></li><li>email<ul class="errorlist"><li>This field is required.</li></ul></li></ul>

obj.errors.as_json()对应的输出结果
{"user": [{"message": "This field is required.", "code": "required"}], "pwd": [{"message": "This field is required.", "code": "required"}], "email": [{"message": "This field is required.", "code": "required"}]}

首先，HttpResponse是我们所推荐的方法，一个自定义的序列化字典，前段接收到这个字符串进行反序列化，就可以从json数组中随意的选取自己的值，灵活性更高，自定制效果更好。

当然我们也可以用Render来返回一个Html，当然这里的html并不是常规意义上的html，比如是这样一个html
    <p>{{obj.name}}</p>
然后函数或者类里面返回
    render(request,‘index.html‘,{‘obj‘:obj})
根据django的请求生命周期，很容易我们就可以看出，我们首先执行函数或者类，然后得到这个obj对象，再加上这个html，其次对这个渲染的html进行解释，最后得到的其实就是一个<p>dandy</p>
这样的标签的字符串，通常我们会用这种方式返回给ajax一些标签。但是对于这类字符串，是无法进行修改的，或者说很难，灵活性跟直接返回序列化字典对比就能看出来差很多。 

所以还是那句话，在绝大多数情况下，更推荐使用HttpResponse来返回序列化字典给前端的ajax。
另外，切记，redirect返回是无效的。

a、XSS恶意攻击：防止写script之类循环让网页一直输出弹框（最简单的实例）恶意攻击：防止写script之类循环让网页一直输出弹框（最简单的实例）
  前端：{{name|safe}}==>告诉网页这个返回的字符串是安全的。不屏蔽成字符串

b、from django.utils.safestring import mark_safe
　 page_str = "<a href=‘index‘>name</a>"
　 page_str = mark_safe(page_str)

divmod 除 余数
active 
逻辑：
	当前页：current_page
	总页数：total_count
	每页显示10条数据：page_per_count
	页码：11
	
	如果：总页数<11
		start_index = 0
		end_index = 总页数
		
	else：
		当前页<=6 显示1~11
		当前页小于6 显示当前页-5，当前页+5+1 
		如果当前页+5>总页数：
		end_index = total_count + 1

#!/user/bin/env python
# -*-coding: utf-8-*-
from django.utils.safestring import mark_safe
class Page:
    def __init__(self, data_total_count, current_index, show_data_count=10, show_tag_count=11, ):
        self.data_total_count = data_total_count
        self.current_index = current_index
        self.show_data_count = show_data_count
        self.show_tag_count = show_tag_count
    @property
    def start(self):
        return (self.current_index - 1) * self.show_data_count
    @property
    def end(self):
        return self.current_index * self.show_data_count
    @property
    def all_count(self):
        v, y = divmod(self.data_total_count, self.show_data_count)
        if y:
            v += 1
        return v

    def page_str(self, base_url):
        if self.all_count < self.show_tag_count:
            start_index =1
            end_index = self.all_count + 1
        else:
            if self.current_index <= (self.show_tag_count+1)/2:
                start_index = 1
                end_index = self.show_tag_count + 1
            else:
                start_index = self.current_index - (self.show_tag_count - 1)/2
                end_index = self.current_index + (self.show_tag_count + 1)/2
                if (self.current_index + 5) > self.all_count:
                    start_index = self.all_count - self.show_tag_count + 1
                    end_index = self.all_count + 1
        page_list = []
        if self.current_index == 1:
            prev = "<a class=‘page‘ href=‘javascript:void(0)‘>上一页</a>"
        else:
            prev = "<a class=‘page‘ href=‘%s?p=%s‘>上一页</a>" %(base_url, self.current_index - 1)
        page_list.append(prev)
        for i in range(int(start_index), int(end_index)):
            if i == self.current_index:
                temp = "<a class=‘page active‘ href=‘%s?p=%s‘>%s</a>" %(base_url, i, i)
            else:
                temp = "<a class=‘page‘ href=‘%s?p=%s‘>%s</a>" % (base_url, i, i)
            page_list.append(temp)
        if self.current_index == self.all_count:
            nex = "<a class=‘page‘ href=‘javascript:void(0)‘>下一页</a>"
        else:
            nex = "<a class=‘page‘ href=‘%s?p=%s‘>下一页</a>" % (base_url, self.current_index + 1)
        page_list.append(nex)
        dest = """
        <input type=‘text‘ value=1 /><a onclick="jumpTo(this,"%s?p=");">GO</a>
        <script>
            function jumpTo(ths, base){
                var val = ths.previousSibling.value;
                location.href = base + val;
            }
        </script>
        """ % base_url
        page_list.append(dest)
        page_str = mark_safe("".join(page_list))
        return page_str

from utils import paging
def temp3(request):
    if request.method == "GET":
        page_count = int(request.COOKIES.get("page_count", 10))

        current_index = request.GET.get(‘p‘, 1)
        current_index = int(current_index)  # 当前的页数
        page_obj = paging.Page(len(li), current_index, page_count)
        data_list = li[int(page_obj.start):int(page_obj.end)]

        page_str = page_obj.page_str("/app01/temp3/")

        return render(request, ‘temp3.html‘, {"list": data_list, "str": page_str})

    <ul>
        {% for row in list %}
            <li>{{ row }}</li>
        {% endfor %}
    </ul>
    <select id="slt" onchange="page_count(this)">
        <option value="5">5</option>
        <option value="10">10</option>
        <option value="20">20</option>
        <option value="30">30</option>
    </select>
    <div class="page_index">
        {{ str|safe }}
    </div>
    <script src="/static/jquery-3.2.1.js"></script>
    <script src="/static/jquery.cookie.js"></script>
    <script>
        $(function() {
            var v = $.cookie("page_count");
{#            var v = $.cookie("page_count", {‘path‘: "/app01/temp3/"});#}
            $("#slt").val(v)
        });
        function page_count(ths) {
            val = $(ths).val();
            $.cookie("page_count", val)
        }
    </script>