Django【进阶篇 】
Model
到目前为止,当我们的程序涉及到数据库相关操作时,我们一般都会这么搞:
- 创建数据库,设计表结构和字段
- 使用 MySQLdb 来连接数据库,并编写数据访问层代码
- 业务逻辑层去调用数据访问层执行数据库操作
- import MySQLdb
- def GetList(sql):
- db = MySQLdb.connect(user='root', db='wupeiqidb', passwd='', 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='', host='localhost')
- cursor = db.cursor()
- cursor.execute(sql)
- data = cursor.fetchone()
- db.close()
- return data
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()
- 1、models.AutoField 自增列 = int(11)
- 如果没有的话,默认会生成一个名称为 id 的列,如果要显示的自定义一个自增列,必须将给列设置为主键 primary_key=True。
- 2、models.CharField 字符串字段
- 必须 max_length 参数
- 3、models.BooleanField 布尔类型=tinyint(1)
- 不能为空,Blank=True
- 4、models.ComaSeparatedIntegerField 用逗号分割的数字=varchar
- 继承CharField,所以必须 max_lenght 参数
- 5、models.DateField 日期类型 date
- 对于参数,auto_now = True 则每次更新都会更新这个时间;auto_now_add 则只是第一次创建添加,之后的更新不再改变。
- 6、models.DateTimeField 日期类型 datetime
- 同DateField的参数
- 7、models.Decimal 十进制小数类型 = decimal
- 必须指定整数位max_digits和小数位decimal_places
- 8、models.EmailField 字符串类型(正则表达式邮箱) =varchar
- 对字符串进行正则表达式
- 9、models.FloatField 浮点类型 = double
- 10、models.IntegerField 整形
- 11、models.BigIntegerField 长整形
- integer_field_ranges = {
- 'SmallIntegerField': (-32768, 32767),
- 'IntegerField': (-2147483648, 2147483647),
- 'BigIntegerField': (-9223372036854775808, 9223372036854775807),
- 'PositiveSmallIntegerField': (0, 32767),
- 'PositiveIntegerField': (0, 2147483647),
- }
- 12、models.IPAddressField 字符串类型(ip4正则表达式)
- 13、models.GenericIPAddressField 字符串类型(ip4和ip6是可选的)
- 参数protocol可以是:both、ipv4、ipv6
- 验证时,会根据设置报错
- 14、models.NullBooleanField 允许为空的布尔类型
- 15、models.PositiveIntegerFiel 正Integer
- 16、models.PositiveSmallIntegerField 正smallInteger
- 17、models.SlugField 减号、下划线、字母、数字
- 18、models.SmallIntegerField 数字
- 数据库中的字段有:tinyint、smallint、int、bigint
- 19、models.TextField 字符串=longtext
- 20、models.TimeField 时间 HH:MM[:ss[.uuuuuu]]
- 21、models.URLField 字符串,地址正则表达式
- 22、models.BinaryField 二进制
- 23、models.ImageField 图片
- 24、models.FilePathField 文件
更多字段
- 1、null=True
- 数据库中字段是否可以为空
- 2、blank=True
- django的 Admin 中添加数据时是否可允许空值
- 3、primary_key = False
- 主键,对AutoField设置主键后,就会代替原来的自增 id 列
- 4、auto_now 和 auto_now_add
- auto_now 自动创建---无论添加或修改,都是当前操作的时间
- auto_now_add 自动创建---永远是创建时的时间
- 5、choices
- GENDER_CHOICE = (
- (u'M', u'Male'),
- (u'F', u'Female'),
- )
- gender = models.CharField(max_length=2,choices = GENDER_CHOICE)
- 6、max_length
- 7、default 默认值
- 8、verbose_name Admin中字段的显示名称
- 9、name|db_column 数据库中的字段名称
- 10、unique=True 不允许重复
- 11、db_index = True 数据库索引
- 12、editable=True 在Admin里是否可编辑
- 13、error_messages=None 错误提示
- 14、auto_created=False 自动创建
- 15、help_text 在Admin中提示帮助信息
- 16、validators=[]
- 17、upload-to
更多参数
2、连表结构
- 一对多:models.ForeignKey(其他表)
- 多对多:models.ManyToManyField(其他表)
- 一对一:models.OneToOneField(其他表)
应用场景:
- 一对多:当一张表中创建一行数据时,有一个单选的下拉框(可以被重复选择)
例如:创建用户信息时候,需要选择一个用户类型【普通用户】【金牌用户】【铂金用户】等。- 多对多:在某表中创建一行数据是,有一个可以多选的下拉框
例如:创建用户信息,需要为用户指定多个爱好- 一对一:在某表中创建一行数据时,有一个单选的下拉框(下拉框中的内容被用过一次就消失了
例如:原有含10列数据的一张表保存相关信息,经过一段时间之后,10列无法满足需求,需要为原来的表再添加5列数据
二、操作表
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__lt=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
- # 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
- # limit 、offset
- #
- # models.Tb1.objects.all()[10:20]
- # 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"
进阶操作
3、连表操作(了不起的双下划线)
利用双下划线和 _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')
多对多操作
- # F 使用查询条件的值
- #
- # from django.db.models import F
- # models.Tb1.objects.update(num=F('num')+1)
- # Q 构建搜索条件
- from django.db.models import Q
- # 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)
- #
- # from django.db import connection
- # cursor = connection.cursor()
- # cursor.execute("""SELECT * from tb where name = %s""", ['Lennon'])
- # row = cursor.fetchone()
其他操作
注意:xx_set中的【_set】是多对多中的固定搭配
扩展:
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()
Form
- 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)
Model
- 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
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"}),
- }
跨站请求伪造
一、简介
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。
- <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")
- ...
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内置分页
- Paginator
二、自定义分页
分页功能在每个网站都是必要的,对于分页来说,其实就是根据用户的输入计算出应该在数据库表中的起始位置。
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=''>首页</a>"
- else:
- first="<a href='%s%d'>首页</a>" % (baseurl,1)
- pager_list.append(first)
- if currentPage<=1:
- prev="<a href=''>上一页</a>"
- else:
- prev="<a href='%s%d'>上一页</a>" % (baseurl,currentPage-1)
- pager_list.append(prev)
- for i in range(begin+1,end+1):
- if i == currentPage:
- temp="<a href='%s%d' class='selected'>%d</a>" % (baseurl,i,i)
- else:
- temp="<a href='%s%d'>%d</a>" % (baseurl,i,i)
- pager_list.append(temp)
- if currentPage>=totalpage:
- next="<a href='#'>下一页</a>"
- else:
- next="<a href='%s%d'>下一页</a>" % (baseurl,currentPage+1)
- pager_list.append(next)
- if currentPage>=totalpage:
- last="<a href=''>末页</a>"
- else:
- last="<a href='%s%d'>末页</a>" % (baseurl,totalpage)
- pager_list.append(last)
- result=''.join(pager_list)
- return mark_safe(result) #把字符串转成html语言
分页实例
总结,分页时需要做三件事:
- 创建处理分页数据的类
- 根据分页数据获取数据
- 输出分页HTML,即:[上一页][1][2][3][4][5][下一页]
缓存
由于Django是动态网站,所有每次请求均会去数据进行相应的操作,当程序访问量大时,耗时必然会更加明显,最简单解决方式是使用:缓存,缓存将一个某个views的返回值保存至内存或者memcache中,5分钟内再有人来访问时,则不再去执行view中的操作,而是直接从内存或者Redis中之前缓存的内容拿到,并返回。
Django中提供了6种缓存方式:
- 开发调试
- 内存
- 文件
- 数据库
- Memcache缓存(python-memcached模块)
- Memcache缓存(pylibmc模块)
1、配置
a、开发调试
- # 此为开始调试用,实际内部不做任何操作
- # 配置:
- CACHES = {
- 'default': {
- 'BACKEND': 'django.core.cache.backends.dummy.DummyCache', # 引擎
- 'TIMEOUT': 300, # 缓存超时时间(默认300,None表示永不过期,0表示立即过期)
- 'OPTIONS':{
- 'MAX_ENTRIES': 300, # 最大缓存个数(默认300)
- 'CULL_FREQUENCY': 3, # 缓存到达最大个数之后,剔除缓存个数的比例,即:1/CULL_FREQUENCY(默认3)
- },
- 'KEY_PREFIX': '', # 缓存key的前缀(默认空)
- 'VERSION': 1, # 缓存key的版本(默认1)
- 'KEY_FUNCTION' 函数名 # 生成key的函数(默认函数会生成为:【前缀:版本:key】)
- }
- }
- # 自定义key
- def default_key_func(key, key_prefix, version):
- """
- Default function to generate keys.
- Constructs the key used by all other methods. By default it prepends
- the `key_prefix'. KEY_FUNCTION can be used to specify an alternate
- function with custom key making behavior.
- """
- return '%s:%s:%s' % (key_prefix, version, key)
- def get_key_func(key_func):
- """
- Function to decide which key function to use.
- Defaults to ``default_key_func``.
- """
- if key_func is not None:
- if callable(key_func):
- return key_func
- else:
- return import_string(key_func)
- return default_key_func
b、内存
- # 此缓存将内容保存至内存的变量中
- # 配置:
- CACHES = {
- 'default': {
- 'BACKEND': 'django.core.cache.backends.locmem.LocMemCache',
- 'LOCATION': 'unique-snowflake',
- }
- }
- # 注:其他配置同开发调试版本
c、文件
- # 此缓存将内容保存至文件
- # 配置:
- CACHES = {
- 'default': {
- 'BACKEND': 'django.core.cache.backends.filebased.FileBasedCache',
- 'LOCATION': '/var/tmp/django_cache',
- }
- }
- # 注:其他配置同开发调试版本
d、数据库
- # 此缓存将内容保存至数据库
- # 配置:
- CACHES = {
- 'default': {
- 'BACKEND': 'django.core.cache.backends.db.DatabaseCache',
- 'LOCATION': 'my_cache_table', # 数据库表
- }
- }
- # 注:执行创建表命令 python manage.py createcachetable
e、Memcache缓存(python-memcached模块)
- # 此缓存使用python-memcached模块连接memcache
- CACHES = {
- 'default': {
- 'BACKEND': 'django.core.cache.backends.memcached.MemcachedCache',
- 'LOCATION': '127.0.0.1:11211',
- }
- }
- CACHES = {
- 'default': {
- 'BACKEND': 'django.core.cache.backends.memcached.MemcachedCache',
- 'LOCATION': 'unix:/tmp/memcached.sock',
- }
- }
- CACHES = {
- 'default': {
- 'BACKEND': 'django.core.cache.backends.memcached.MemcachedCache',
- 'LOCATION': [
- '172.19.26.240:11211',
- '172.19.26.242:11211',
- ]
- }
- }
f、Memcache缓存(pylibmc模块)
- # 此缓存使用pylibmc模块连接memcache
- CACHES = {
- 'default': {
- 'BACKEND': 'django.core.cache.backends.memcached.PyLibMCCache',
- 'LOCATION': '127.0.0.1:11211',
- }
- }
- CACHES = {
- 'default': {
- 'BACKEND': 'django.core.cache.backends.memcached.PyLibMCCache',
- 'LOCATION': '/tmp/memcached.sock',
- }
- }
- CACHES = {
- 'default': {
- 'BACKEND': 'django.core.cache.backends.memcached.PyLibMCCache',
- 'LOCATION': [
- '172.19.26.240:11211',
- '172.19.26.242:11211',
- ]
- }
- }
2、应用
a. 全站使用
- 使用中间件,经过一系列的认证等操作,如果内容在缓存中存在,则使用FetchFromCacheMiddleware获取内容并返回给用户,当返回给用户之前,判断缓存中是否已经存在,如果不存在则UpdateCacheMiddleware会将缓存保存至缓存,从而实现全站缓存
- MIDDLEWARE = [
- 'django.middleware.cache.UpdateCacheMiddleware',
- # 其他中间件...
- 'django.middleware.cache.FetchFromCacheMiddleware',
- ]
- CACHE_MIDDLEWARE_ALIAS = ""
- CACHE_MIDDLEWARE_SECONDS = ""
- CACHE_MIDDLEWARE_KEY_PREFIX = ""
b. 单独视图缓存
- 方式一:
- from django.views.decorators.cache import cache_page
- @cache_page(60 * 15)
- def my_view(request):
- ...
- 方式二:
- from django.views.decorators.cache import cache_page
- urlpatterns = [
- url(r'^foo/([0-9]{1,2})/$', cache_page(60 * 15)(my_view)),
- ]
c、局部视图使用
- a. 引入TemplateTag
- {% load cache %}
- b. 使用缓存
- {% cache 5000 缓存key %}
- 缓存内容
- {% endcache %}
更多:猛击这里
序列化
关于Django中的序列化主要应用在将数据库中检索的数据返回给客户端用户,特别的Ajax请求一般返回的为Json格式。
1、serializers
- from django.core import serializers
- ret = models.BookType.objects.all()
- data = serializers.serialize("json", ret)
2、json.dumps
- import json
- #ret = models.BookType.objects.all().values('caption')
- ret = models.BookType.objects.all().values_list('caption')
- ret=list(ret)
- result = json.dumps(ret)
由于json.dumps时无法处理datetime日期,所以可以通过自定义处理器来做扩展,如:
- import json
- from datetime import date
- from datetime import datetime
- class JsonCustomEncoder(json.JSONEncoder):
- def default(self, field):
- if isinstance(field, datetime):
- return o.strftime('%Y-%m-%d %H:%M:%S')
- elif isinstance(field, date):
- return o.strftime('%Y-%m-%d')
- else:
- return json.JSONEncoder.default(self, field)
- # ds = json.dumps(d, cls=JsonCustomEncoder)
信号
Django中提供了“信号调度”,用于在框架执行操作时解耦。通俗来讲,就是一些动作发生的时候,信号允许特定的发送者去提醒一些接受者。
1、Django内置信号
- 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 # 创建数据库连接时,自动触发
对于Django内置的信号,仅需注册指定信号,当程序执行相应操作时,自动触发注册函数:
- 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指上述导入的内容
- from django.core.signals import request_finished
- from django.dispatch import receiver
- @receiver(request_finished)
- def my_callback(sender, **kwargs):
- print("Request finished!")
2、自定义信号
a. 定义信号
- import django.dispatch
- pizza_done = django.dispatch.Signal(providing_args=["toppings", "size"])
b. 注册信号
- def callback(sender, **kwargs):
- print("callback")
- print(sender,kwargs)
- pizza_done.connect(callback)
c. 触发信号
- from 路径 import pizza_done
- pizza_done.send(sender='seven',toppings=123, size=456)
由于内置信号的触发者已经集成到Django中,所以其会自动调用,而对于自定义信号则需要开发者在任意位置触发。
更多:猛击这里
Django【进阶篇 】的更多相关文章
- 02:Django进阶篇
目录:Django其他篇 01:Django基础篇 02:Django进阶篇 03:Django数据库操作--->Model 04: Form 验证用户数据 & 生成html 05:Mo ...
- Django进阶篇【1】
注:本篇是Django进阶篇章,适合人群:有Django基础,关于Django基础篇,将在下一章节中补充! 首先我们一起了解下Django整个请求生命周期: Django 请求流程,生命周期: 路由部 ...
- django 进阶篇
models(模型) 创建数据库,设计表结构和字段 使用 MySQLdb 来连接数据库,并编写数据访问层代码 业务逻辑层去调用数据访问层执行数据库操作 import MySQLdb def GetLi ...
- python Django 进阶篇
Python的WEB框架有Django.Tornado.Flask 等多种,Django相较与其他WEB框架其优势为:大而全,框架本身集成了ORM.模型绑定.模板引擎.缓存.Session等诸多功能. ...
- Python之路【第十七篇】Django进阶篇
规范 确立规范的好处: 代码可读性高 方便代码的定位极其查找 为以后代码扩容带来便利 场景: 在多个APP的场景下,单个app的URL函数功能较多的时候,我们可以通过以下方法来解决. 把Views写成 ...
- django进阶篇
原文连接:http://www.cnblogs.com/wupeiqi/articles/5246483.html Model 到目前为止,当我们的程序涉及到数据库相关操作时,我们一般都会这么搞: 创 ...
- Python学习-day20 django进阶篇
Model 到目前为止,当我们的程序涉及到数据库相关操作时,我们一般都会这么搞: 创建数据库,设计表结构和字段 使用 MySQLdb 来连接数据库,并编写数据访问层代码 业务逻辑层去调用数据访问层执行 ...
- Django进阶篇(二)
中间件 解析 django 中的中间件(middleware),在django中,中间件其实就是一个类,在请求到来和结束后, django会根据自己的规则在合适的时机执行中间件中相应的方法. 在dja ...
- Python之路【第十六篇续】Django进阶篇
Django请求生命周期 首先:对于所有的web框架来说本质就是一个socket服务端,浏览器是socket客户端 路由系统 在Django的urls中我们可以根据一个URL对应一个函数名来定义路由规 ...
- Django进阶篇(一)
Form django中的Form一般有两种功能: 1.输入html 2.验证用户输入 最简易的form验证: <!DOCTYPE html> <html lang="en ...
随机推荐
- bzoj1588
splay #include<cstdio> #include<cstring> #include<algorithm> using namespace std; ...
- noip2016十连测round3
A:平均数 题意:有一天,小 A 得到了一个长度为 n 的序列. 他把这个序列的所有连续子序列都列了出来,并对每一个子序列都求了其平均值,然后他把这些平均值写在纸上,并对它们进行排序,最后他报出了第 ...
- bzoj2503&poj3387[NEERC2006]IdealFrame
其实只是把别人的题解强行扩写了 写这篇题解之前我不会的预备知识: 欧拉通路:从图中一个点出发不重复地遍历所有边的路径(可以停在另一个点) 欧拉回路:从图中一个点出发不重复地遍历所有边的回路(必须回到出 ...
- Protocol Framework - SNMP Tutorial
30.4 Protocol Framework TCP/IP network management protocols2 divide the management problem into two ...
- Arcgis SDE10.1 和 Arcgis server10.1的授权文件license
把下面内容复制进空白文本文档,改名和后缀为sde.ecp即可. 3dengine,101,ecp.arcgis.engine,none,WEJDFAZAM5FBAZ8LN115 3dserver,10 ...
- centos 7.1 apache 源码编译安装
Apache编译安装 一,需要软件: http://mirrors.cnnic.cn/apache//apr/apr-1.5.2.tar.gz 1.apr-1.5.2.tar.gz http://mi ...
- CSS 实现背景透明 内容文字不透明 显示
思路主要是 IE9+ 谷歌 火狐等使用rgba(0,0,0,0.5)来确定透明度 前三个值是RGB值 可以直接参考PS里对应的值 最后一个是透明度 例子 background:rgba(255,255 ...
- Json字符串和Json对象的简单总结
JSON(JavaScript Object Notation) 是一种轻量级的数据交换格式.JSON成为理想的数据交换语言. 易于人阅读和编写,同时也易于机器解析和生成(一般用于提升网络传输速率). ...
- [Nhibernate]SchemaExport工具的使用(一)——通过映射文件修改数据表
目录 写在前面 文档与系列文章 SchemaExport工具 SchemaUpdate工具 一个例子 总结 写在前面 上篇文章介绍了使用代码生成器的nhibernate模版来生成持久化类,映射文件等内 ...
- Android中finish掉其它的Activity
在Android开发时,一般情况下我们如果需要关掉当前Activity非常容易,只需要一行代码 this.finish;即可.那么,如果是想要在当前Activity中关掉其它的Activity应该怎么 ...