Model

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

  • 创建数据库,设计表结构和字段
  • 使用 MySQLdb 来连接数据库,并编写数据访问层代码
  • 业务逻辑层去调用数据访问层执行数据库操作
  1. import MySQLdb
  2.  
  3. def GetList(sql):
  4. db = MySQLdb.connect(user='root', db='wupeiqidb', passwd='', host='localhost')
  5. cursor = db.cursor()
  6. cursor.execute(sql)
  7. data = cursor.fetchall()
  8. db.close()
  9. return data
  10.  
  11. def GetSingle(sql):
  12. db = MySQLdb.connect(user='root', db='wupeiqidb', passwd='', host='localhost')
  13. cursor = db.cursor()
  14. cursor.execute(sql)
  15. data = cursor.fetchone()
  16. db.close()
  17. return data

django为使用一种新的方式,即:关系对象映射(Object Relational Mapping,简称ORM)。

  PHP:activerecord

  Java:Hibernate

  C#:Entity Framework

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

一、创建表

1、基本结构

  1. from django.db import models
  2.  
  3. class userinfo(models.Model):
  4. name = models.CharField(max_length=30)
  5. email = models.EmailField()
  6. memo = models.TextField()
  1. 1models.AutoField  自增列 = int(11)
  2.   如果没有的话,默认会生成一个名称为 id 的列,如果要显示的自定义一个自增列,必须将给列设置为主键 primary_key=True
  3. 2models.CharField  字符串字段
  4.   必须 max_length 参数
  5. 3models.BooleanField  布尔类型=tinyint(1)
  6.   不能为空,Blank=True
  7. 4models.ComaSeparatedIntegerField  用逗号分割的数字=varchar
  8.   继承CharField,所以必须 max_lenght 参数
  9. 5models.DateField  日期类型 date
  10.   对于参数,auto_now = True 则每次更新都会更新这个时间;auto_now_add 则只是第一次创建添加,之后的更新不再改变。
  11. 6models.DateTimeField  日期类型 datetime
  12.   DateField的参数
  13. 7models.Decimal  十进制小数类型 = decimal
  14.   必须指定整数位max_digits和小数位decimal_places
  15. 8models.EmailField  字符串类型(正则表达式邮箱) =varchar
  16.   对字符串进行正则表达式
  17. 9models.FloatField  浮点类型 = double
  18. 10models.IntegerField  整形
  19. 11models.BigIntegerField  长整形
  20.   integer_field_ranges = {
  21.     'SmallIntegerField': (-32768, 32767),
  22.     'IntegerField': (-2147483648, 2147483647),
  23.     'BigIntegerField': (-9223372036854775808, 9223372036854775807),
  24.     'PositiveSmallIntegerField': (0, 32767),
  25.     'PositiveIntegerField': (0, 2147483647),
  26.   }
  27. 12models.IPAddressField  字符串类型(ip4正则表达式)
  28. 13models.GenericIPAddressField  字符串类型(ip4ip6是可选的)
  29.   参数protocol可以是:bothipv4ipv6
  30.   验证时,会根据设置报错
  31. 14models.NullBooleanField  允许为空的布尔类型
  32. 15models.PositiveIntegerFiel  正Integer
  33. 16models.PositiveSmallIntegerField  正smallInteger
  34. 17models.SlugField  减号、下划线、字母、数字
  35. 18models.SmallIntegerField  数字
  36.   数据库中的字段有:tinyintsmallintintbigint
  37. 19models.TextField  字符串=longtext
  38. 20models.TimeField  时间 HH:MM[:ss[.uuuuuu]]
  39. 21models.URLField  字符串,地址正则表达式
  40. 22models.BinaryField  二进制
  41. 23models.ImageField 图片
  42. 24models.FilePathField 文件

更多字段

  1. 1null=True
  2.   数据库中字段是否可以为空
  3. 2blank=True
  4.   django Admin 中添加数据时是否可允许空值
  5. 3primary_key = False
  6.   主键,对AutoField设置主键后,就会代替原来的自增 id
  7. 4auto_now auto_now_add
  8.   auto_now 自动创建---无论添加或修改,都是当前操作的时间
  9.   auto_now_add 自动创建---永远是创建时的时间
  10. 5choices
  11. GENDER_CHOICE = (
  12. (u'M', u'Male'),
  13. (u'F', u'Female'),
  14. )
  15. gender = models.CharField(max_length=2,choices = GENDER_CHOICE)
  16. 6max_length
  17. 7default  默认值
  18. 8verbose_name  Admin中字段的显示名称
  19. 9name|db_column  数据库中的字段名称
  20. 10unique=True  不允许重复
  21. 11db_index = True  数据库索引
  22. 12editable=True  在Admin里是否可编辑
  23. 13error_messages=None  错误提示
  24. 14auto_created=False  自动创建
  25. 15help_text  在Admin中提示帮助信息
  26. 16validators=[]
  27. 17upload-to

更多参数

2、连表结构

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

应用场景:

  • 一对多:当一张表中创建一行数据时,有一个单选的下拉框(可以被重复选择)
    例如:创建用户信息时候,需要选择一个用户类型【普通用户】【金牌用户】【铂金用户】等。
  • 多对多:在某表中创建一行数据是,有一个可以多选的下拉框
    例如:创建用户信息,需要为用户指定多个爱好
  • 一对一:在某表中创建一行数据时,有一个单选的下拉框(下拉框中的内容被用过一次就消失了
    例如:原有含10列数据的一张表保存相关信息,经过一段时间之后,10列无法满足需求,需要为原来的表再添加5列数据

二、操作表

1、基本操作

  1. # 增
  2. #
  3. # models.Tb1.objects.create(c1='xx', c2='oo') 增加一条数据,可以接受字典类型数据 **kwargs
  4.  
  5. # obj = models.Tb1(c1='xx', c2='oo')
  6. # obj.save()
  7.  
  8. # 查
  9. #
  10. # models.Tb1.objects.get(id=123) # 获取单条数据,不存在则报错(不建议)
  11. # models.Tb1.objects.all() # 获取全部
  12. # models.Tb1.objects.filter(name='seven') # 获取指定条件的数据
  13.  
  14. # 删
  15. #
  16. # models.Tb1.objects.filter(name='seven').delete() # 删除指定条件的数据
  17.  
  18. # 改
  19. # models.Tb1.objects.filter(name='seven').update(gender='0') # 将指定条件的数据更新,均支持 **kwargs
  20. # obj = models.Tb1.objects.get(id=1)
  21. # obj.c1 = '111'
  22. # obj.save() # 修改单条数据

基本操作

2、进阶操作(了不起的双下划线)

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

  1. # 获取个数
  2. #
  3. # models.Tb1.objects.filter(name='seven').count()
  4.  
  5. # 大于,小于
  6. #
  7. # models.Tb1.objects.filter(id__gt=1) # 获取id大于1的值
  8. # models.Tb1.objects.filter(id__lt=10) # 获取id小于10的值
  9. # models.Tb1.objects.filter(id__lt=10, id__gt=1) # 获取id大于1 且 小于10的值
  10.  
  11. # in
  12. #
  13. # models.Tb1.objects.filter(id__in=[11, 22, 33]) # 获取id等于11、22、33的数据
  14. # models.Tb1.objects.exclude(id__in=[11, 22, 33]) # not in
  15.  
  16. # contains
  17. #
  18. # models.Tb1.objects.filter(name__contains="ven")
  19. # models.Tb1.objects.filter(name__icontains="ven") # icontains大小写不敏感
  20. # models.Tb1.objects.exclude(name__icontains="ven")
  21.  
  22. # range
  23. #
  24. # models.Tb1.objects.filter(id__range=[1, 2]) # 范围bettwen and
  25.  
  26. # 其他类似
  27. #
  28. # startswith,istartswith, endswith, iendswith,
  29.  
  30. # order by
  31. #
  32. # models.Tb1.objects.filter(name='seven').order_by('id') # asc
  33. # models.Tb1.objects.filter(name='seven').order_by('-id') # desc
  34.  
  35. # limit 、offset
  36. #
  37. # models.Tb1.objects.all()[10:20]
  38.  
  39. # group by
  40. from django.db.models import Count, Min, Max, Sum
  41. # models.Tb1.objects.filter(c1=1).values('id').annotate(c=Count('num'))
  42. # 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 将表之间的操作连接起来

  1. class UserProfile(models.Model):
  2. user_info = models.OneToOneField('UserInfo')
  3. username = models.CharField(max_length=64)
  4. password = models.CharField(max_length=64)
  5.  
  6. def __unicode__(self):
  7. return self.username
  8.  
  9. class UserInfo(models.Model):
  10. user_type_choice = (
  11. (0, u'普通用户'),
  12. (1, u'高级用户'),
  13. )
  14. user_type = models.IntegerField(choices=user_type_choice)
  15. name = models.CharField(max_length=32)
  16. email = models.CharField(max_length=32)
  17. address = models.CharField(max_length=128)
  18.  
  19. def __unicode__(self):
  20. return self.name
  21.  
  22. class UserGroup(models.Model):
  23.  
  24. caption = models.CharField(max_length=64)
  25.  
  26. user_info = models.ManyToManyField('UserInfo')
  27.  
  28. def __unicode__(self):
  29. return self.caption
  30.  
  31. class Host(models.Model):
  32. hostname = models.CharField(max_length=64)
  33. ip = models.GenericIPAddressField()
  34. user_group = models.ForeignKey('UserGroup')
  35.  
  36. def __unicode__(self):
  37. return self.hostname

表结构实例

  1. user_info_obj = models.UserInfo.objects.filter(id=1).first()
  2. print user_info_obj.user_type
  3. print user_info_obj.get_user_type_display()
  4. print user_info_obj.userprofile.password
  5.  
  6. user_info_obj = models.UserInfo.objects.filter(id=1).values('email', 'userprofile__username').first()
  7. print user_info_obj.keys()
  8. print user_info_obj.values()

一对一操作

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

一对多

  1. user_info_obj = models.UserInfo.objects.get(name=u'武沛齐')
  2. user_info_objs = models.UserInfo.objects.all()
  3.  
  4. group_obj = models.UserGroup.objects.get(caption='CEO')
  5. group_objs = models.UserGroup.objects.all()
  6.  
  7. # 添加数据
  8. #group_obj.user_info.add(user_info_obj)
  9. #group_obj.user_info.add(*user_info_objs)
  10.  
  11. # 删除数据
  12. #group_obj.user_info.remove(user_info_obj)
  13. #group_obj.user_info.remove(*user_info_objs)
  14.  
  15. # 添加数据
  16. #user_info_obj.usergroup_set.add(group_obj)
  17. #user_info_obj.usergroup_set.add(*group_objs)
  18.  
  19. # 删除数据
  20. #user_info_obj.usergroup_set.remove(group_obj)
  21. #user_info_obj.usergroup_set.remove(*group_objs)
  22.  
  23. # 获取数据
  24. #print group_obj.user_info.all()
  25. #print group_obj.user_info.all().filter(id=1)
  26.  
  27. # 获取数据
  28. #print user_info_obj.usergroup_set.all()
  29. #print user_info_obj.usergroup_set.all().filter(caption='CEO')
  30. #print user_info_obj.usergroup_set.all().filter(caption='DBA')

多对多操作

  1. # F 使用查询条件的值
  2. #
  3. # from django.db.models import F
  4. # models.Tb1.objects.update(num=F('num')+1)
  5.  
  6. # Q 构建搜索条件
  7. from django.db.models import Q
  8. # con = Q()
  9. #
  10. # q1 = Q()
  11. # q1.connector = 'OR'
  12. # q1.children.append(('id', 1))
  13. # q1.children.append(('id', 10))
  14. # q1.children.append(('id', 9))
  15. #
  16. # q2 = Q()
  17. # q2.connector = 'OR'
  18. # q2.children.append(('c1', 1))
  19. # q2.children.append(('c1', 10))
  20. # q2.children.append(('c1', 9))
  21. #
  22. # con.add(q1, 'AND')
  23. # con.add(q2, 'AND')
  24. #
  25. # models.Tb1.objects.filter(con)
  26.  
  27. #
  28. # from django.db import connection
  29. # cursor = connection.cursor()
  30. # cursor.execute("""SELECT * from tb where name = %s""", ['Lennon'])
  31. # row = cursor.fetchone()

其他操作

注意:xx_set中的【_set】是多对多中的固定搭配

扩展:

a、自定义上传

  1. def upload_file(request):
  2. if request.method == "POST":
  3. obj = request.FILES.get('fafafa')
  4. f = open(obj.name, 'wb')
  5. for chunk in obj.chunks():
  6. f.write(chunk)
  7. f.close()
  8. return render(request, 'file.html')

b、Form上传文件实例

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

Form

  1. from django.db import models
  2.  
  3. class UploadFile(models.Model):
  4. userid = models.CharField(max_length = 30)
  5. file = models.FileField(upload_to = './upload/')
  6. date = models.DateTimeField(auto_now_add=True)

Model

  1. def UploadFile(request):
  2. uf = AssetForm.FileForm(request.POST,request.FILES)
  3. if uf.is_valid():
  4. upload = models.UploadFile()
  5. upload.userid = 1
  6. upload.file = uf.cleaned_data['ExcelFile']
  7. upload.save()
  8.  
  9. print upload.file

View

Form

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

  • 输入html
  • 验证用户输入
  1. #!/usr/bin/env python
  2. # -*- coding:utf-8 -*-
  3. import re
  4. from django import forms
  5. from django.core.exceptions import ValidationError
  6.  
  7. def mobile_validate(value):
  8. mobile_re = re.compile(r'^(13[0-9]|15[012356789]|17[678]|18[0-9]|14[57])[0-9]{8}$')
  9. if not mobile_re.match(value):
  10. raise ValidationError('手机号码格式错误')
  11.  
  12. class PublishForm(forms.Form):
  13.  
  14. user_type_choice = (
  15. (0, u'普通用户'),
  16. (1, u'高级用户'),
  17. )
  18.  
  19. user_type = forms.IntegerField(widget=forms.widgets.Select(choices=user_type_choice,
  20. attrs={'class': "form-control"}))
  21.  
  22. title = forms.CharField(max_length=20,
  23. min_length=5,
  24. error_messages={'required': u'标题不能为空',
  25. 'min_length': u'标题最少为5个字符',
  26. 'max_length': u'标题最多为20个字符'},
  27. widget=forms.TextInput(attrs={'class': "form-control",
  28. 'placeholder': u'标题5-20个字符'}))
  29.  
  30. memo = forms.CharField(required=False,
  31. max_length=256,
  32. widget=forms.widgets.Textarea(attrs={'class': "form-control no-radius", 'placeholder': u'详细描述', 'rows': 3}))
  33.  
  34. phone = forms.CharField(validators=[mobile_validate, ],
  35. error_messages={'required': u'手机不能为空'},
  36. widget=forms.TextInput(attrs={'class': "form-control",
  37. 'placeholder': u'手机号码'}))
  38.  
  39. email = forms.EmailField(required=False,
  40. error_messages={'required': u'邮箱不能为空','invalid': u'邮箱格式错误'},
  41. widget=forms.TextInput(attrs={'class': "form-control", 'placeholder': u'邮箱'}))

Form

  1. def publish(request):
  2. ret = {'status': False, 'data': '', 'error': '', 'summary': ''}
  3. if request.method == 'POST':
  4. request_form = PublishForm(request.POST)
  5. if request_form.is_valid():
  6. request_dict = request_form.clean()
  7. print request_dict
  8. ret['status'] = True
  9. else:
  10. error_msg = request_form.errors.as_json()
  11. ret['error'] = json.loads(error_msg)
  12. return HttpResponse(json.dumps(ret))

View

扩展:ModelForm

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

  1. class AdminModelForm(forms.ModelForm):
  2.  
  3. class Meta:
  4. model = models.Admin
  5. #fields = '__all__'
  6. fields = ('username', 'email')
  7.  
  8. widgets = {
  9. 'email' : forms.PasswordInput(attrs={'class':"alex"}),
  10. }

跨站请求伪造

一、简介

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、普通表单

  1. veiw中设置返回值:
  2.   return render_to_response('Account/Login.html',data,context_instance=RequestContext(request))  
  3. 或者
  4. return render(request, 'xxx.html', data)
  5.  
  6. html中设置Token:
  7.   {% csrf_token %}

2、Ajax

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

view.py

  1. from django.template.context import RequestContext
  2. # Create your views here.
  3.  
  4. def test(request):
  5.  
  6. if request.method == 'POST':
  7. print request.POST
  8. return HttpResponse('ok')
  9. return render_to_response('app01/test.html',context_instance=RequestContext(request))

text.html

  1. <!DOCTYPE html>
  2. <html>
  3. <head lang="en">
  4. <meta charset="UTF-8">
  5. <title></title>
  6. </head>
  7. <body>
  8. {% csrf_token %}
  9.  
  10. <input type="button" onclick="Do();" value="Do it"/>
  11.  
  12. <script src="/static/plugin/jquery/jquery-1.8.0.js"></script>
  13. <script src="/static/plugin/jquery/jquery.cookie.js"></script>
  14. <script type="text/javascript">
  15. var csrftoken = $.cookie('csrftoken');
  16.  
  17. function csrfSafeMethod(method) {
  18. // these HTTP methods do not require CSRF protection
  19. return (/^(GET|HEAD|OPTIONS|TRACE)$/.test(method));
  20. }
  21. $.ajaxSetup({
  22. beforeSend: function(xhr, settings) {
  23. if (!csrfSafeMethod(settings.type) && !this.crossDomain) {
  24. xhr.setRequestHeader("X-CSRFToken", csrftoken);
  25. }
  26. }
  27. });
  28. function Do(){
  29.  
  30. $.ajax({
  31. url:"/app01/test/",
  32. data:{id:1},
  33. type:'POST',
  34. success:function(data){
  35. console.log(data);
  36. }
  37. });
  38.  
  39. }
  40. </script>
  41. </body>
  42. </html>

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

Cookie

1、获取Cookie:

  1. request.COOKIES['key']
  2. request.get_signed_cookie(key, default=RAISE_ERROR, salt='', max_age=None)
  3. 参数:
  4. default: 默认值
  5. salt: 加密盐
  6. max_age: 后台控制过期时间

2、设置Cookie:

  1. rep = HttpResponse(...) rep render(request, ...)
  2.  
  3. rep.set_cookie(key,value,...)
  4. rep.set_signed_cookie(key,value,salt='加密盐',...)
  5. 参数:
  6. key,
  7. value='',
  8. max_age=None, 超时时间
  9. expires=None, 超时时间(IE requires expires, so set it if hasn't been already.)
  10. path='/', Cookie生效的路径,/ 表示根路径,特殊的:跟路径的cookie可以被任何url的页面访问
  11. domain=None, Cookie生效的域名
  12. secure=False, https传输
  13. httponly=False 只能http协议传输,无法被JavaScript获取(不是绝对,底层抓包可以获取到也可以被覆盖)

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

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

Session

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

  • 数据库(默认)
  • 缓存
  • 文件
  • 缓存+数据库
  • 加密cookie

1、数据库Session

  1. Django默认支持Session,并且默认是将Session数据存储在数据库中,即:django_session 表中。
  2.  
  3. a. 配置 settings.py
  4.  
  5. SESSION_ENGINE = 'django.contrib.sessions.backends.db' # 引擎(默认)
  6.  
  7. SESSION_COOKIE_NAME "sessionid" # Session的cookie保存在浏览器上时的key,即:sessionid=随机字符串(默认)
  8. SESSION_COOKIE_PATH "/" # Session的cookie保存的路径(默认)
  9. SESSION_COOKIE_DOMAIN = None # Session的cookie保存的域名(默认)
  10. SESSION_COOKIE_SECURE = False # 是否Https传输cookie(默认)
  11. SESSION_COOKIE_HTTPONLY = True # 是否Session的cookie只支持http传输(默认)
  12. SESSION_COOKIE_AGE = 1209600 # Session的cookie失效日期(2周)(默认)
  13. SESSION_EXPIRE_AT_BROWSER_CLOSE = False # 是否关闭浏览器使得Session过期(默认)
  14. SESSION_SAVE_EVERY_REQUEST = False # 是否每次请求都保存Session,默认修改之后才保存(默认)
  15.  
  16. b. 使用
  17.  
  18. def index(request):
  19. # 获取、设置、删除Session中数据
  20. request.session['k1']
  21. request.session.get('k1',None)
  22. request.session['k1'] = 123
  23. request.session.setdefault('k1',123) # 存在则不设置
  24. del request.session['k1']
  25.  
  26. # 所有 键、值、键值对
  27. request.session.keys()
  28. request.session.values()
  29. request.session.items()
  30. request.session.iterkeys()
  31. request.session.itervalues()
  32. request.session.iteritems()
  33.  
  34. # 用户session的随机字符串
  35. request.session.session_key
  36.  
  37. # 将所有Session失效日期小于当前日期的数据删除
  38. request.session.clear_expired()
  39.  
  40. # 检查 用户session的随机字符串 在数据库中是否
  41. request.session.exists("session_key")
  42.  
  43. # 删除当前用户的所有Session数据
  44. request.session.delete("session_key")
  45.  
  46. ...

2、缓存Session

  1. a. 配置 settings.py
  2.  
  3. SESSION_ENGINE = 'django.contrib.sessions.backends.cache' # 引擎
  4. SESSION_CACHE_ALIAS = 'default' # 使用的缓存别名(默认内存缓存,也可以是memcache),此处别名依赖缓存的设置
  5.  
  6. SESSION_COOKIE_NAME "sessionid" # Session的cookie保存在浏览器上时的key,即:sessionid=随机字符串
  7. SESSION_COOKIE_PATH "/" # Session的cookie保存的路径
  8. SESSION_COOKIE_DOMAIN = None # Session的cookie保存的域名
  9. SESSION_COOKIE_SECURE = False # 是否Https传输cookie
  10. SESSION_COOKIE_HTTPONLY = True # 是否Session的cookie只支持http传输
  11. SESSION_COOKIE_AGE = 1209600 # Session的cookie失效日期(2周)
  12. SESSION_EXPIRE_AT_BROWSER_CLOSE = False # 是否关闭浏览器使得Session过期
  13. SESSION_SAVE_EVERY_REQUEST = False # 是否每次请求都保存Session,默认修改之后才保存
  14.  
  15. b. 使用
  16.  
  17. 同上

3、文件Session

  1. a. 配置 settings.py
  2.  
  3. SESSION_ENGINE = 'django.contrib.sessions.backends.file' # 引擎
  4. SESSION_FILE_PATH = None # 缓存文件路径,如果为None,则使用tempfile模块获取一个临时地址tempfile.gettempdir() # 如:/var/folders/d3/j9tj0gz93dg06bmwxmhh6_xm0000gn/T
  5.  
  6. SESSION_COOKIE_NAME "sessionid" # Session的cookie保存在浏览器上时的key,即:sessionid=随机字符串
  7. SESSION_COOKIE_PATH "/" # Session的cookie保存的路径
  8. SESSION_COOKIE_DOMAIN = None # Session的cookie保存的域名
  9. SESSION_COOKIE_SECURE = False # 是否Https传输cookie
  10. SESSION_COOKIE_HTTPONLY = True # 是否Session的cookie只支持http传输
  11. SESSION_COOKIE_AGE = 1209600 # Session的cookie失效日期(2周)
  12. SESSION_EXPIRE_AT_BROWSER_CLOSE = False # 是否关闭浏览器使得Session过期
  13. SESSION_SAVE_EVERY_REQUEST = False # 是否每次请求都保存Session,默认修改之后才保存
  14.  
  15. b. 使用
  16.  
  17. 同上

4、缓存+数据库Session

  1. 数据库用于做持久化,缓存用于提高效率
  2.  
  3. a. 配置 settings.py
  4.  
  5. SESSION_ENGINE = 'django.contrib.sessions.backends.cached_db' # 引擎
  6.  
  7. b. 使用
  8.  
  9. 同上

5、加密cookie Session

  1. a. 配置 settings.py
  2.  
  3. SESSION_ENGINE = 'django.contrib.sessions.backends.signed_cookies' # 引擎
  4.  
  5. b. 使用
  6.  
  7. 同上

更多参考:猛击这里猛击这里

扩展:Session用户验证

  1. def login(func):
  2. def wrap(request, *args, **kwargs):
  3. # 如果未登陆,跳转到指定页面
  4. if request.path == '/test/':
  5. return redirect('http://www.baidu.com')
  6. return func(request, *args, **kwargs)
  7. return wrap

分页

一、Django内置分页

  1. Paginator

二、自定义分页

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

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

2、用户输入页码(第一页、第二页...)

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

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


需求又来了,需要在页面上显示分页的页面。如:[上一页][1][2][3][4][5][下一页]

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

2、用户输入页码(第一页、第二页...)

3、设定显示多少页号

4、获取当前数据总条数

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

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

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

8、输出分页html,如:[上一页][1][2][3][4][5][下一页]

  1. #!/usr/bin/env python
  2. # _*_coding:utf-8_*_
  3. from django.utils.safestring import mark_safe
  4.  
  5. class PageInfo(object):
  6. def __init__(self,current,totalItem,peritems=5):
  7. self.__current=current
  8. self.__peritems=peritems
  9. self.__totalItem=totalItem
  10. def From(self):
  11. return (self.__current-1)*self.__peritems
  12. def To(self):
  13. return self.__current*self.__peritems
  14. def TotalPage(self): #总页数
  15. result=divmod(self.__totalItem,self.__peritems)
  16. if result[1]==0:
  17. return result[0]
  18. else:
  19. return result[0]+1
  20.  
  21. def Custompager(baseurl,currentPage,totalpage): #基础页,当前页,总页数
  22. perPager=11
  23. #总页数<11
  24. #0 -- totalpage
  25. #总页数>11
  26. #当前页大于5 currentPage-5 -- currentPage+5
  27. #currentPage+5是否超过总页数,超过总页数,end就是总页数
  28. #当前页小于5 0 -- 11
  29. begin=0
  30. end=0
  31. if totalpage <= 11:
  32. begin=0
  33. end=totalpage
  34. else:
  35. if currentPage>5:
  36. begin=currentPage-5
  37. end=currentPage+5
  38. if end > totalpage:
  39. end=totalpage
  40. else:
  41. begin=0
  42. end=11
  43. pager_list=[]
  44. if currentPage<=1:
  45. first="<a href=''>首页</a>"
  46. else:
  47. first="<a href='%s%d'>首页</a>" % (baseurl,1)
  48. pager_list.append(first)
  49.  
  50. if currentPage<=1:
  51. prev="<a href=''>上一页</a>"
  52. else:
  53. prev="<a href='%s%d'>上一页</a>" % (baseurl,currentPage-1)
  54. pager_list.append(prev)
  55.  
  56. for i in range(begin+1,end+1):
  57. if i == currentPage:
  58. temp="<a href='%s%d' class='selected'>%d</a>" % (baseurl,i,i)
  59. else:
  60. temp="<a href='%s%d'>%d</a>" % (baseurl,i,i)
  61. pager_list.append(temp)
  62. if currentPage>=totalpage:
  63. next="<a href='#'>下一页</a>"
  64. else:
  65. next="<a href='%s%d'>下一页</a>" % (baseurl,currentPage+1)
  66. pager_list.append(next)
  67. if currentPage>=totalpage:
  68. last="<a href=''>末页</a>"
  69. else:
  70. last="<a href='%s%d'>末页</a>" % (baseurl,totalpage)
  71. pager_list.append(last)
  72. result=''.join(pager_list)
  73. 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、开发调试

  1. # 此为开始调试用,实际内部不做任何操作
  2. # 配置:
  3. CACHES = {
  4. 'default': {
  5. 'BACKEND': 'django.core.cache.backends.dummy.DummyCache', # 引擎
  6. 'TIMEOUT': 300, # 缓存超时时间(默认300,None表示永不过期,0表示立即过期)
  7. 'OPTIONS':{
  8. 'MAX_ENTRIES': 300, # 最大缓存个数(默认300)
  9. 'CULL_FREQUENCY': 3, # 缓存到达最大个数之后,剔除缓存个数的比例,即:1/CULL_FREQUENCY(默认3)
  10. },
  11. 'KEY_PREFIX': '', # 缓存key的前缀(默认空)
  12. 'VERSION': 1, # 缓存key的版本(默认1)
  13. 'KEY_FUNCTION' 函数名 # 生成key的函数(默认函数会生成为:【前缀:版本:key】)
  14. }
  15. }
  16.  
  17. # 自定义key
  18. def default_key_func(key, key_prefix, version):
  19. """
  20. Default function to generate keys.
  21.  
  22. Constructs the key used by all other methods. By default it prepends
  23. the `key_prefix'. KEY_FUNCTION can be used to specify an alternate
  24. function with custom key making behavior.
  25. """
  26. return '%s:%s:%s' % (key_prefix, version, key)
  27.  
  28. def get_key_func(key_func):
  29. """
  30. Function to decide which key function to use.
  31.  
  32. Defaults to ``default_key_func``.
  33. """
  34. if key_func is not None:
  35. if callable(key_func):
  36. return key_func
  37. else:
  38. return import_string(key_func)
  39. return default_key_func

b、内存

  1. # 此缓存将内容保存至内存的变量中
  2. # 配置:
  3. CACHES = {
  4. 'default': {
  5. 'BACKEND': 'django.core.cache.backends.locmem.LocMemCache',
  6. 'LOCATION': 'unique-snowflake',
  7. }
  8. }
  9.  
  10. # 注:其他配置同开发调试版本

c、文件

  1. # 此缓存将内容保存至文件
  2. # 配置:
  3.  
  4. CACHES = {
  5. 'default': {
  6. 'BACKEND': 'django.core.cache.backends.filebased.FileBasedCache',
  7. 'LOCATION': '/var/tmp/django_cache',
  8. }
  9. }
  10. # 注:其他配置同开发调试版本

d、数据库

  1. # 此缓存将内容保存至数据库
  2.  
  3. # 配置:
  4. CACHES = {
  5. 'default': {
  6. 'BACKEND': 'django.core.cache.backends.db.DatabaseCache',
  7. 'LOCATION': 'my_cache_table', # 数据库表
  8. }
  9. }
  10.  
  11. # 注:执行创建表命令 python manage.py createcachetable

e、Memcache缓存(python-memcached模块)

  1. # 此缓存使用python-memcached模块连接memcache
  2.  
  3. CACHES = {
  4. 'default': {
  5. 'BACKEND': 'django.core.cache.backends.memcached.MemcachedCache',
  6. 'LOCATION': '127.0.0.1:11211',
  7. }
  8. }
  9.  
  10. CACHES = {
  11. 'default': {
  12. 'BACKEND': 'django.core.cache.backends.memcached.MemcachedCache',
  13. 'LOCATION': 'unix:/tmp/memcached.sock',
  14. }
  15. }
  16.  
  17. CACHES = {
  18. 'default': {
  19. 'BACKEND': 'django.core.cache.backends.memcached.MemcachedCache',
  20. 'LOCATION': [
  21. '172.19.26.240:11211',
  22. '172.19.26.242:11211',
  23. ]
  24. }
  25. }

f、Memcache缓存(pylibmc模块)

  1. # 此缓存使用pylibmc模块连接memcache
  2.  
  3. CACHES = {
  4. 'default': {
  5. 'BACKEND': 'django.core.cache.backends.memcached.PyLibMCCache',
  6. 'LOCATION': '127.0.0.1:11211',
  7. }
  8. }
  9.  
  10. CACHES = {
  11. 'default': {
  12. 'BACKEND': 'django.core.cache.backends.memcached.PyLibMCCache',
  13. 'LOCATION': '/tmp/memcached.sock',
  14. }
  15. }
  16.  
  17. CACHES = {
  18. 'default': {
  19. 'BACKEND': 'django.core.cache.backends.memcached.PyLibMCCache',
  20. 'LOCATION': [
  21. '172.19.26.240:11211',
  22. '172.19.26.242:11211',
  23. ]
  24. }
  25. }

2、应用

a. 全站使用

  1. 使用中间件,经过一系列的认证等操作,如果内容在缓存中存在,则使用FetchFromCacheMiddleware获取内容并返回给用户,当返回给用户之前,判断缓存中是否已经存在,如果不存在则UpdateCacheMiddleware会将缓存保存至缓存,从而实现全站缓存
  2.  
  3. MIDDLEWARE = [
  4. 'django.middleware.cache.UpdateCacheMiddleware',
  5. # 其他中间件...
  6. 'django.middleware.cache.FetchFromCacheMiddleware',
  7. ]
  8.  
  9. CACHE_MIDDLEWARE_ALIAS = ""
  10. CACHE_MIDDLEWARE_SECONDS = ""
  11. CACHE_MIDDLEWARE_KEY_PREFIX = ""

b. 单独视图缓存

  1. 方式一:
  2. from django.views.decorators.cache import cache_page
  3.  
  4. @cache_page(60 * 15)
  5. def my_view(request):
  6. ...
  7.  
  8. 方式二:
  9. from django.views.decorators.cache import cache_page
  10.  
  11. urlpatterns = [
  12. url(r'^foo/([0-9]{1,2})/$', cache_page(60 * 15)(my_view)),
  13. ]

c、局部视图使用

  1. a. 引入TemplateTag
  2.  
  3. {% load cache %}
  4.  
  5. b. 使用缓存
  6.  
  7. {% cache 5000 缓存key %}
  8. 缓存内容
  9. {% endcache %}

更多:猛击这里

序列化

关于Django中的序列化主要应用在将数据库中检索的数据返回给客户端用户,特别的Ajax请求一般返回的为Json格式。

1、serializers

  1. from django.core import serializers
  2.  
  3. ret = models.BookType.objects.all()
  4.  
  5. data = serializers.serialize("json", ret)

2、json.dumps

  1. import json
  2.  
  3. #ret = models.BookType.objects.all().values('caption')
  4. ret = models.BookType.objects.all().values_list('caption')
  5.  
  6. ret=list(ret)
  7.  
  8. result = json.dumps(ret)

由于json.dumps时无法处理datetime日期,所以可以通过自定义处理器来做扩展,如:

  1. import json
  2. from datetime import date
  3. from datetime import datetime
  4.  
  5. class JsonCustomEncoder(json.JSONEncoder):
  6.  
  7. def default(self, field):
  8.  
  9. if isinstance(field, datetime):
  10. return o.strftime('%Y-%m-%d %H:%M:%S')
  11. elif isinstance(field, date):
  12. return o.strftime('%Y-%m-%d')
  13. else:
  14. return json.JSONEncoder.default(self, field)
  15.  
  16. # ds = json.dumps(d, cls=JsonCustomEncoder)

信号

Django中提供了“信号调度”,用于在框架执行操作时解耦。通俗来讲,就是一些动作发生的时候,信号允许特定的发送者去提醒一些接受者。

1、Django内置信号

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

对于Django内置的信号,仅需注册指定信号,当程序执行相应操作时,自动触发注册函数:

  1. from django.core.signals import request_finished
  2. from django.core.signals import request_started
  3. from django.core.signals import got_request_exception
  4.  
  5. from django.db.models.signals import class_prepared
  6. from django.db.models.signals import pre_init, post_init
  7. from django.db.models.signals import pre_save, post_save
  8. from django.db.models.signals import pre_delete, post_delete
  9. from django.db.models.signals import m2m_changed
  10. from django.db.models.signals import pre_migrate, post_migrate
  11.  
  12. from django.test.signals import setting_changed
  13. from django.test.signals import template_rendered
  14.  
  15. from django.db.backends.signals import connection_created
  16.  
  17. def callback(sender, **kwargs):
  18. print("xxoo_callback")
  19. print(sender,kwargs)
  20.  
  21. xxoo.connect(callback)
  22. # xxoo指上述导入的内容
  1. from django.core.signals import request_finished
  2. from django.dispatch import receiver
  3.  
  4. @receiver(request_finished)
  5. def my_callback(sender, **kwargs):
  6. print("Request finished!")

2、自定义信号

a. 定义信号

  1. import django.dispatch
  2. pizza_done = django.dispatch.Signal(providing_args=["toppings", "size"])

b. 注册信号

  1. def callback(sender, **kwargs):
  2. print("callback")
  3. print(sender,kwargs)
  4.  
  5. pizza_done.connect(callback)

c. 触发信号

  1. from 路径 import pizza_done
  2.  
  3. pizza_done.send(sender='seven',toppings=123, size=456)

由于内置信号的触发者已经集成到Django中,所以其会自动调用,而对于自定义信号则需要开发者在任意位置触发。

更多:猛击这里

 
 

Django【进阶篇 】的更多相关文章

  1. 02:Django进阶篇

    目录:Django其他篇 01:Django基础篇 02:Django进阶篇 03:Django数据库操作--->Model 04: Form 验证用户数据 & 生成html 05:Mo ...

  2. Django进阶篇【1】

    注:本篇是Django进阶篇章,适合人群:有Django基础,关于Django基础篇,将在下一章节中补充! 首先我们一起了解下Django整个请求生命周期: Django 请求流程,生命周期: 路由部 ...

  3. django 进阶篇

    models(模型) 创建数据库,设计表结构和字段 使用 MySQLdb 来连接数据库,并编写数据访问层代码 业务逻辑层去调用数据访问层执行数据库操作 import MySQLdb def GetLi ...

  4. python Django 进阶篇

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

  5. Python之路【第十七篇】Django进阶篇

    规范 确立规范的好处: 代码可读性高 方便代码的定位极其查找 为以后代码扩容带来便利 场景: 在多个APP的场景下,单个app的URL函数功能较多的时候,我们可以通过以下方法来解决. 把Views写成 ...

  6. django进阶篇

    原文连接:http://www.cnblogs.com/wupeiqi/articles/5246483.html Model 到目前为止,当我们的程序涉及到数据库相关操作时,我们一般都会这么搞: 创 ...

  7. Python学习-day20 django进阶篇

    Model 到目前为止,当我们的程序涉及到数据库相关操作时,我们一般都会这么搞: 创建数据库,设计表结构和字段 使用 MySQLdb 来连接数据库,并编写数据访问层代码 业务逻辑层去调用数据访问层执行 ...

  8. Django进阶篇(二)

    中间件 解析 django 中的中间件(middleware),在django中,中间件其实就是一个类,在请求到来和结束后, django会根据自己的规则在合适的时机执行中间件中相应的方法. 在dja ...

  9. Python之路【第十六篇续】Django进阶篇

    Django请求生命周期 首先:对于所有的web框架来说本质就是一个socket服务端,浏览器是socket客户端 路由系统 在Django的urls中我们可以根据一个URL对应一个函数名来定义路由规 ...

  10. Django进阶篇(一)

    Form django中的Form一般有两种功能: 1.输入html 2.验证用户输入 最简易的form验证: <!DOCTYPE html> <html lang="en ...

随机推荐

  1. bzoj1588

    splay #include<cstdio> #include<cstring> #include<algorithm> using namespace std; ...

  2. noip2016十连测round3

    A:平均数 题意:有一天,小 A 得到了一个长度为 n 的序列. 他把这个序列的所有连续子序列都列了出来,并对每一个子序列都求了其平均值,然后他把这些平均值写在纸上,并对它们进行排序,最后他报出了第 ...

  3. bzoj2503&poj3387[NEERC2006]IdealFrame

    其实只是把别人的题解强行扩写了 写这篇题解之前我不会的预备知识: 欧拉通路:从图中一个点出发不重复地遍历所有边的路径(可以停在另一个点) 欧拉回路:从图中一个点出发不重复地遍历所有边的回路(必须回到出 ...

  4. Protocol Framework - SNMP Tutorial

    30.4 Protocol Framework TCP/IP network management protocols2 divide the management problem into two ...

  5. Arcgis SDE10.1 和 Arcgis server10.1的授权文件license

    把下面内容复制进空白文本文档,改名和后缀为sde.ecp即可. 3dengine,101,ecp.arcgis.engine,none,WEJDFAZAM5FBAZ8LN115 3dserver,10 ...

  6. 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 ...

  7. CSS 实现背景透明 内容文字不透明 显示

    思路主要是 IE9+ 谷歌 火狐等使用rgba(0,0,0,0.5)来确定透明度 前三个值是RGB值 可以直接参考PS里对应的值 最后一个是透明度 例子 background:rgba(255,255 ...

  8. Json字符串和Json对象的简单总结

    JSON(JavaScript Object Notation) 是一种轻量级的数据交换格式.JSON成为理想的数据交换语言. 易于人阅读和编写,同时也易于机器解析和生成(一般用于提升网络传输速率). ...

  9. [Nhibernate]SchemaExport工具的使用(一)——通过映射文件修改数据表

    目录 写在前面 文档与系列文章 SchemaExport工具 SchemaUpdate工具 一个例子 总结 写在前面 上篇文章介绍了使用代码生成器的nhibernate模版来生成持久化类,映射文件等内 ...

  10. Android中finish掉其它的Activity

    在Android开发时,一般情况下我们如果需要关掉当前Activity非常容易,只需要一行代码 this.finish;即可.那么,如果是想要在当前Activity中关掉其它的Activity应该怎么 ...