python Django知识点总结

python Django知识点总结

一、Django创建项目：

CMD 终端：Django_admin startproject sitename(文件名)

其他常用命令：

其他常用命令：
通过类创建表--python manage.py makemigrations
--python manage.py migrate
其他命令：
python manage.py runserver 0.0.0.0
python manage.py stratapp appname
python manage.py suncdb
python manage.py createsuperuser

二、创建数据库（ORM）

a.数据库表的增

增:
在原来models.py文件中添加一个新的类（ORM---类就是表，对象是行）
在Terminal执行：--python manage.py makemigrations --python manage.py migrate 命令更新数据库

 这是原来的表
 class UserINfo(models.Model):
     nickname = models.CharField(max_length=32)
     username = models.CharField(max_length=32)
     password = models.CharField(max_length=32)
     gender_list=(
         (1,'男'),
         (2,'女'),
     )
     gender = models.IntegerField(choices=gender_list)
     m = models.ManyToManyField('UserINfo')
 -------------------------------------------------------------------------
 这是新增的表
 class User(models.Model):
     new_id=models.IntegerField(null=True)
     new_tabe= models.CharField(max_length=32)
     new_content =models.CharField(max_length=64)
     new_root = models.CharField(max_length=32)
     content = models.ForeignKey('User',null=True,blank=True,related_name='xxx')

增 演示

b.数据库表的删

删：
在原来创建表的py文件中把不要的表对应的类注释掉（ORM---类就是表，对象是行）
在Terminal执行：--python manage.py makemigrations
	   --python manage.py migrate
	   命令更新数据库

 这是数据库的表
 class GTB(models.Model):
     g = models.ForeignKey('Boy',null=True)
     b = models.ForeignKey('Grily',null=True)

 -------------------------------------------------------------
 这是删除数据库表
 # class UserInfo(models.Model):
 #     nickname = models.CharField(max_length=32)
 #     username = models.CharField(max_length=32)
 #     password = models.CharField(max_length=32)
 #     gender_list=(
 #         (1,'男'),
 #         (2,'女'),
 #     )
 #     gender = models.IntegerField(choices=gender_list)

删 演示

c.数据库表的改

改：
在原来创建表的py文件中把要进行的表对应的类进行调整（ORM---类就是表，对象是行）

在Terminal执行：--python manage.py makemigrations --python manage.py migrate 命令更新数据库

 这是数据库未进行修改的表
 class Boy(models.Model):
     username = models.CharField(max_length=32)
     nickname = models.CharField(max_length=32)
     password = models.CharField(max_length=32)

 ------------------------------------------------------------
 这是要进行更改数据的表
 class Boy(models.Model):
     username = models.CharField(max_length=32)
     name = models.CharField(max_length=32)
     password = models.CharField(max_length=32)

改 演示

d.数据库表行的增

创建一个url对应的函数，通过浏览器访问这个url触发相对应的函数
在函数中设置数据库行的增加命令
在对表的行进行增加时，参数是创建表时的每列名称以及对应的参数值
models.Body.objects.create(username='波多爱军',password=123,sex=1)

 def index(request):
     models.Body.objects.create(username='波多爱军',password=123,sex=1)
     models.Body.objects.create(username='苍爱军',password=123,sex=1)
     models.Body.objects.create(username='吉泽爱军',password=123,sex=1)
     models.Body.objects.create(username='田原爱军',password=123,sex=1)

行增加 演示

e.数据库表行的删

创建一个url对应的函数，通过浏览器访问这个url触发相对应的函数
在函数中设置数据库行的删除命令
在对表的行进行增加时，参数是创建表时的每列名称以及对应的参数值
models.Body.objects.delete（username=‘alex’）

 def index(request):
     models.Body.objects.delete(username='波多爱军',password=123,sex=1)

行删除 演示

f.数据库表行的改

创建一个url对应的函数，通过浏览器访问这个url触发相对应的函数
在函数中设置数据库行的修改命令
在对表的行进行增加时，参数是创建表时的每列名称以及对应的参数值
models.Body.objects.filter(username='alex).update(username='波多爱军')

 def index（request）：
 models.Body.objects.filter(username='波多爱军',password=123,sex=1).update(username='波多爱军',password=233,sex=2)

行 修改

g.数据库表行的查

models.Body.objects.filter(username='alex).all()

1 def gets(request):
 2 #     models.UserInfo.objects.all()
 3 #     # 查看全部行的数据
 4
 5 #     models.UserInfo.objects.filter(id=2)
 6 #     #查看id等于2的哪行数据
 7
 8 #     models.UserInfo.objects.first()
 9 #     #查看第一个数据
10
11 #     models.UserInfo.objects.last()
12 #     #查看最后一个数据
13
14 #     models.UserInfo.objects.exclude(id=4)
15 #     #查看id不等于4的所有内容
16
17 #     models.UserInfo.objects.filter(name='seven').count()
18 #     #获取名字等于seven的总数
19
20 #     models.UserInfo.objects.get(name='seven')
21 #     #获取名字等于seven的单个对象
22
23 #     models.UserInfo.objects.filter(id_gt=1)
24 #     #查看id大于1的行内容
25
26 #     models.UserInfo.objects.filter(id_lt=2)
27 #     #查看id小于2的行内容
28
29 #     models.UserInfo.objects.filter(id_gte=1)
30 #     #查看id大于等于1的行内容
31
32 #     models.UserInfo.objects.filter(id_let=5)
33 #     #查看id小于等于5的行内容
34
35 #     models.UserInfo.objects.filter(id_lt=10,id_gt=1)
36 #     #查看id大于1且id小于10的行内容
37
38 #     models.UserInfo.objects.filter(id__in=[11,33,44])
39 #     #查看id在不在列表中
40
41 #     models.UserInfo.objects.exclude(id_in=[11,33,44])
42 #     #查看id不在列表中的的数据内容
43
44 #     models.UserInfo.objects.filter(pud_date__isnull=True)
45 #     #查看pud_date不是为空
46
47 #     models.UserInfo.objects.filter(name__contains='alex')
48 #     #查看名字中列中包含alex的数据内容
49
50 #     models.UserInfo.objects.exclude(name__icontains='alex')
51 #     #查看名字中列中包含alex（大小写不敏感）的数据内容
52
53 #     models.UserInfo.objects.filter(ut_id__range=[1,5])
54 #     #范围（bettwen  end）
55
56 #     models.UserInfo.objects.filter(name__startswith='alex')
57 #     #查看名字以alex开头的数据行
58
59 #     models.UserInfo.objects.filter(name__istartswith='alex')
60 #     #查看名字以alex开头（大小写不敏感）的数据行
61
62 #     models.UserInfo.objects.filter(name__endswith='egon')
63 #     #查看名字以egon结尾的数据行
64
65 #     models.UserInfo.objects.filter(name__iendswith='egon')
66 #     #查看名字以egon（大小写不敏感）的数据行
67
68 #     models.UserInfo.objects.all().order_by('-id')
69 #     #以降序进行排列查看
70
71 #     models.UserInfo.objects.all().order_by('id')
72 #     #以升序进行排列查看（默认使用升序）
73
74 #     models.UserInfo.objects.all()[1:4]
75 #     #分页limit offset 起始位置和结束位置

行 查看

三、路由系统

1、单一路由对应

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

2、基于正则的路由

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

3、添加额外的参数

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

4、为路由映射设置名称

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

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

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

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

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

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

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

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

6、命名空间

a. project.urls.py

1 2 3 4 5 6

from django.conf.urls import url,include urlpatterns = [     url(r'^a/', include('app01.urls', namespace='author-polls')),     url(r'^b/', include('app01.urls', namespace='publisher-polls')), ]

b. app01.urls.py

1 2 3 4 5 6 7

from django.conf.urls import url from app01 import views app_name = 'app01' urlpatterns = [     url(r'^(?P<pk>\d+)/$', views.detail, name='detail') ]

c. app01.views.py

1 2 3

def detail(request, pk):     print(request.resolver_match)     return HttpResponse(pk)

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

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

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

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

四、模板

1、模版的执行

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

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

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

 import datetime
 from django import template
 import DjangoDemo.settings

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

 from django.template.loader import get_template
 from django.template import Context
 from django.http import HttpResponse
 import datetime

 def current_datetime(request):
     now = datetime.datetime.now()
     t = get_template('current_datetime.html')
     html = t.render(Context({'current_date': now}))
     return HttpResponse(html)

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

2、模版语言

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

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

3、自定义simple_tag

a、在app中创建templatetags模块

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

#!/usr/bin/env python
#coding:utf-8
from django import template
from django.utils.safestring import mark_safe

register = template.Library()

@register.simple_tag
def my_simple_time(v1,v2,v3):
    return  v1 + v2 + v3

@register.simple_tag
def my_input(id,arg):
    result = "<input type='text' id='%s' class='%s' />" %(id,arg,)
    return mark_safe(result)

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

1	{% load xx %}

d、使用simple_tag

1 2	{% my_simple_time 1 2 3%} {% my_input 'id_username' 'hide'%}

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

INSTALLED_APPS = (
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'app01',
)

五、F

====F更新时对比之前的内容(在原来的值中更新)====
models.UserInfo.objects.all().update(age=F('age')+1)

1 # from django.db.models import F
2 # models.UserInfo.objects.all().update(age=F('age')+1)

F 演示

六、Q

====Q用于构造复杂查询条件====
    # Q(nid__gt=10)
    # #创建一个Q
    # Q(nid=8) | Q(nid__gt=10)
    # #俩个Q是或的关系
    # Q(nid=8) & Q(nid__gt=10)
    # #俩个Q是与的关系
    # Q(nid=8) | Q(nid__gt=10) & Q(nid=7)
    # #Q8 和 Q7 或 Q10 和 Q7的关系

1 #方法一：
 2     # Q(nid__gt=10)
 3     # #创建一个Q
 4     # Q(nid=8) | Q(nid__gt=10)
 5     # #俩个Q是或的关系
 6     # Q(nid=8) & Q(nid__gt=10)
 7     # #俩个Q是与的关系
 8     # Q(nid=8) | Q(nid__gt=10) & Q(nid=7)
 9     # #Q8 和 Q7 或 Q10 和 Q7的关系
10
11 #方法二：
12     # from django.db.models import Q
13     # q1=Q()
14     # q1.connector='OR'
15     # q1.children.append(('id_gt',1))
16     # q1.children.append(('id',10))
17     # q1.children.append(('id',9))
18     #
19     # q2=Q()
20     # q2.connector='OR'
21     # q2.children.append(('c1',2))
22     # q2.children.append(('c1',10))
23     # q2.children.append(('c1',9))
24     #
25     # q3=Q()
26     # q3.connector='AND'
27     # q3.children.append(('id',1))
28     # q3.children.append(('id',2))
29     # q2.add(q3,'OR')
30     #
31     # con=Q()
32     # con.add(q1,'AND')
33     # con.add(q2,'AND')
34     #
35     # models.UserInfo.objects.filter(con)

Q 演示

七、extra

======================extra是一种扩展方式========================
models.UserInfo.objects.extra(where=['headline=%s'],params=[1,])

def extra(self,select=None,where=None,params=None,tables=None,order_by=None,select_params=None)
    where ---------params
    select ----------select_params

 1 # def gets(request):
 2 #     models.UserInfo.objects.extra(where=['headline=%s'],params=[1,])
 3 #     #where 和 params 配合使用
 4 #     models.UserInfo.objects.extra(where=["foo='a' OR bar='a',baz='a"])
 5 #     #查询条件是foo和baz等于a   或者bar和baz等a
 6 #     models.UserInfo.objects.extra(select={'new_id':"select id from tb where id>%s"},select_params=(1,),order_by=['-nid'])
 7 #     #查询id大于1并以降序排列

extra 演示

八、连表

a.对象连表

1     # models.UserInfo.objects.all()
2     #查看UserIinfo表的所有行
3     # models.UserInfo.objects.filter(id=2)
4     ##查看UserInfo表id等于2的哪一行内容
5     # result = models.UserInfo.objects.all()
6     ##通过此方式返回一个列表中存放的是对象（object）
7     # for row in result:
8     #     print(row.name,row.id,row.age,row.ut.title)
9         ##以是对象的方式进行连表

b.字典连表

1     # models.UserInfo.objects.all()
2     ## 查看表的所有行
3     # models.UserInfo.objects.filter(id=1)
4     ##查看表的id是1的行
5     # result=models.UserInfo.objects.all().values('id','name','ut__title')
6     ##通过此方式连表返回个列表，列表中存放的是字典对象（dict）
7     # for row in result:
8     #     print(row)

c.元组连表

1     # models.UserInfo.objects.all()
2     ## 查看表的所有行
3     # models.UserInfo.objects.filter(id=2)
4     ##查看表的id是2的行
5     # result=models.UserInfo.objects.all().values_list('id','name','ut__title')
6     ##通过此方式连表返回个列表，列表中存放的是元组对象（tuple）
7     # for row in result:
8     #     print(row)

七、正反向查找

a.对象正向查找

============================对象正向查找=========================

1 result = models.UserInfo.objects.all()
2    for obj in result:
3          print(obj.name,obj.age,obj.ut_id,obj.ut.title)
4        #打印obj对象的名字，对象的年龄，对象的外键，ut设置外键的列就是相当于ut表对应的主键（现在拿到就是ut那个表可以拿ut对应的一行所有内容）
5     result = models.UserInfo.objects.all().first()
6      ##获取表中所有的行但只是拿第一个对象，也就是第一行
7      print(result.name,result.age,result.ut)

对象 正向查找

b.对象反向查找

============================对象反向查找=========================

1     # obj = models.UserType.objects.all().last()
2     # print('用户类型',obj)
3     # for row in obj.userinfo_set.all():
4     #     print(row.name,row.age)

对象反向查找

c.字典正向查找

============================字典正向查找=========================

1     # models.UserInfo.objects.filter(id__gt=7).delete()
2     #v=models.UserInfo.objects.all().values('name','age','ut__title')
3     # print(v)

字典正向查找

d.字典反向查找

============================字典反向查找=========================

 1     # vv = models.UserType.objects.values('title','userinfo__name')
 2     # print(vv)

字典反向查找

e.元组正向查找

============================元组正向查找=========================

 1     # v3 = models.UserInfo.objects.all().values_list('name','age','ut__title')
 2     # print(v3)

元组正向查找

f.元组反向查找

============================元组反向查找=========================

 1     # v4 = models.UserType.objects.all().values_list('title','userinfo__name')
 2     # print(v4)

元组反向查找

九、排序

1     # user_list = models.UserInfo.objects.all().order_by('-id')
2     # ##排序默认的升序，order_by（'-id'）是降序
3     # for i in user_list:
4     #     print(i.name,i.id)
5     # return HttpResponse('....')

  ss =models.UserInfo.objects.all().order_by('-id','age').reverse()
  print(ss.query)
 '''
  SELECT "appo1_userinfo"."id", "appo1_userinfo"."name", "appo1_userinfo"."age", "appo1_userinfo"."ut_id" FROM "appo1_userinfo" ORDER BY "appo1_userinfo"."id" ASC, "appo1_userinfo"."age" DESC

 '''

 将设置的排序方式进行反转，本来id是降序，age是升序，反转后id 是升序，age是降序

排序 演示

十、annotate（组合）

def annotate(self,*args,**kwargs):
    #用于实现聚合group by查询
    from django.db.models import Count,Avg,Max,Min,Sum
     v = models.UserInfo.objects.values('ut_id').annotate(wsa=Count('ut_id'))
    print(v.query)
'''
SELECT "appo1_userinfo"."ut_id", COUNT("appo1_userinfo"."ut_id") AS "uid" FROM "appo1_userinfo" GROUP BY "appo1_userinfo"."ut_id"

 '''

十一、转化成sql语句

v = models.UserInfo.objects.values('ut_id').annotate(wws=Count('ut_id')).filter(ut_id__gt=2)
 print(v.query)

SELECT "appo1_userinfo"."ut_id", COUNT("appo1_userinfo"."ut_id") AS "wws" FROM "appo1_userinfo" WHERE "appo1_userinfo"."ut_id" > 2 GROUP BY "appo1_userinfo"."ut_id"

十二、去重

 v= models.UserInfo.objects.values('ut_id').distinct()
#进行去重
 print(v.query)

 '''
SELECT DISTINCT "appo1_userinfo"."ut_id" FROM "appo1_userinfo"
 '''

#注:只有在PostgresSQL中才能使用distinct进行去重
#如果是PostgresSQL
# models.UserInfo.objects.distinct('nid')

十三、排除某列数据

# ss=models.UserInfo.objects.defer('age','ut_id')
# #映射中排除某列数据
# for i in ss:
#     print(i.id)

十四、仅获取某列数据

 # sss=models.UserInfo.objects.all().only('age')
 #仅取某列数据
 # for i in sss:
 #     print(i.age)

十五、指定使用某数据库

models.UserInfo.objects.using('dbx')
指定使用的数据库，参数为存放数据中的数据库名
ss=models.UserInfo.objects.raw('select * from appo1_userinfo')
print(ss)

十六、其他相关操作

  models.UserInfo.objects.dates('ctime','day','DESC')
 根据时间进行某一部分进行去查找并截取指定内容 (参数 表行   时间格式  排方式)
 kind  只能是 year（年） month（年-月）day（年-月-日）
 order 只能是 ASC DESC   (排序方式)
 并获取转换后的时间
  year   年 01 01
 month  年 月 01
  day    年 月 日
 models.UserInfo.objects.datetimes('ctime','hour',tzinfo=pytz.UTC)
 128     #根据时间进行某一部分查找并截取指定内容，将时间转换为指定时区时间
 kind只能是 year month day hour minute second
 order只能是 ASC DESC  排序方式
 tzinfo 时区对象
 models.UserInfo.objects.datetimes('ctime','hour',tzinfo=pytz.timezone('Asia/Shanghai'))
 ’''
  安装 pythz pip3 install pytz
  import pytz
  pytz.all_timezones
 pytz.timezone('Asia/Shanghai')
  '''
 def none(self):
     #空QuesySet
      pass
  ss=models.UserInfo.objects.aggregate(k=Count('ut_id',distinct=True),n=Count('id'))
 {'k': 3, 'n': 7}
  print(ss)
  ogj=[
      models.UserInfo(name='alex'),
      models.UserInfo(name='egon')

  ]
  models.UserInfo.objects.bulk_create(ogj,10)
 批量插入数据 10代表没次插入数量
  obj,creted = models.UserInfo.objects.get_or_create(username='roo1',defaults={'email':'11111','u_id':2,'tid':3})
 先查看如果存在就不执行创建的操作，如果不存在就会创建后边的数据
  obj,creted = models.UserInfo.objects.update_or_create(username='roo1',defaults={'email':'11111','u_id':2,'tid':3})
 先查如果存在就不执行更新，如果不存在就会创建后边的数据
  id=[11,222,333]
  models.UserInfo.objects.in_bulk(id)
 根据主键ID进行查找
  ss = models.UserInfo.objects.exists()
 #查看是否有结果
  print(ss)
 return HttpResponse('....')

十七、cookie

cookie 是一保存在客户端浏览器上的键值对
个人理解cookie 工作原理：因为http是短连接，无状态的 用户通过浏览器访问服务端如果登录成功，服务端会给客户端浏览器发送一个cookie，下次再来访问时只要携带者cookie就不需要再次进行登录

1、获取Cookie：

1 2 3 4 5 6

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

2、设置Cookie：

1 2 3 4 5 6 7 8 9 10 11 12 13

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获取（不是绝对，底层抓包可以获取到也可以被覆盖）

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

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

十八、xss（跨站脚本攻击）

xss 攻击：是通过用户的信任来进行注释，比如在评论里写一堆HTML标签，成功提交后会保存数据库中或者本地文件中，当别的用户在点开查看的时候，之前用户填写的评论也会通过字符串发送到浏览器，如果在html页面上设置【|safe】那么你就成功的被注释了
他可以获取你的相关信息，如果你在html页面中设置了safe 在HTML也是可及进行关键词判断，防止被注释！（Django本身就进行了XSS攻击防范的）

十九、crsf 跨站伪装请求

个人理解：crsf是防止跨站伪装请求，用户如果访问服务端，服务端会发送一端字符串给客户端浏览器，如果在次有请求时服务端会检测客户端浏览器上有没有 服务端发送的随机字符串，如果有就可以进行访问，如果没有就不能进行访问　

一、简介

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>

二十、session

1 2 3 4

Session是什么？ Session 是保存在服务端的数据 Cookie是什么？ Cookie是保存在客户端浏览器上的键值对

Session个人理解　

1 2 3 4 5

个人Session理解说明： Session就是在存再服务端的数据，每次有人来访问网页Session会检测用户是否带Session发送的随机字符串，如果有随机字符串Session就自己会查看自己以字典形式保存在内存的数据，字典键就是Session生成的随机字符串，字典的值就是用户的信息。 整体总结： Session是依赖于Cookie的一种会话保持，Session会向第一次成功访问的用户发送一个随机的字符串，以便以后用户登录可以准确的定位到用户是谁，用户的相关信息。 需要注意一点，每个用户之间都是独立的字典，不会出现用户信息混乱状况，使用Session的好处，用户查看不到敏感信息

1 2 3 4 5 6

个人Cookie理解说明： Cookie是存在客户端浏览器上的键值对 Cookie的可以用于用户登录验证，投票 整体总结： Cookie会向第一次成功登陆页面的用户发送一个键值对，如果下次登陆服务端会检测用户是否携带Cookie如果携带就可以直接进行访问不需要再进用户验证。 Cookie可以设置过期时间 和哪些用户可以进行访问

Session　保存在服务端的数据（本质是键值对）

配置文件中可以指定存储位置

数据库 Session

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

a. 配置 settings.py

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

    SESSION_COOKIE_NAME ＝ "sessionid"                       # Session的cookie保存在浏览器上时的key，即：sessionid＝随机字符串（默认）
    SESSION_COOKIE_PATH ＝ "/"                               # Session的cookie保存的路径（默认）
    SESSION_COOKIE_DOMAIN = None                             # Session的cookie保存的域名（默认）
    SESSION_COOKIE_SECURE = False                            # 是否Https传输cookie（默认）
    SESSION_COOKIE_HTTPONLY = True                           # 是否Session的cookie只支持http传输（默认）
    SESSION_COOKIE_AGE = 1209600                             # Session的cookie失效日期（2周）（默认）
    SESSION_EXPIRE_AT_BROWSER_CLOSE = False                  # 是否关闭浏览器使得Session过期（默认）
    SESSION_SAVE_EVERY_REQUEST = False                       # 是否每次请求都保存Session，默认修改之后才保存（默认）

b. 使用

    def index(request):
        # 获取、设置、删除Session中数据
        request.session['k1']
        request.session.get('k1',None)
        request.session['k1'] = 123
        request.session.setdefault('k1',123) # 存在则不设置
        del request.session['k1']

        # 所有 键、值、键值对
        request.session.keys()
        request.session.values()
        request.session.items()
        request.session.iterkeys()
        request.session.itervalues()
        request.session.iteritems()

        # 用户session的随机字符串
        request.session.session_key

        # 将所有Session失效日期小于当前日期的数据删除
        request.session.clear_expired()

        # 检查 用户session的随机字符串 在数据库中是否
        request.session.exists("session_key")

        # 删除当前用户的所有Session数据
        request.session.delete("session_key")

        request.session.set_expiry(value)
            * 如果value是个整数，session会在些秒数后失效。
            * 如果value是个datatime或timedelta，session就会在这个时间后失效。
            * 如果value是0,用户关闭浏览器session就会失效。
            * 如果value是None,session会依赖全局session失效策略。

缓存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. 使用

    同上

文件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. 使用

    同上

缓存+数据库Session

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

a. 配置 settings.py

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

b. 使用

    同上

缓冲+数据库  先是去数据库中查找，没有就去数据库中查找

Cookie 中存放Session

a. 配置 settings.py

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

b. 使用

    同上

这样的存放方式  相当于没有使用Session

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内置分页

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

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

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

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

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

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

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

HTML

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

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

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

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

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

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

扩展 分页

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

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

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

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

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

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

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

扩展分页 HTML

二、自定义分页

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

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

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

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

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

---

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

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

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

3、设定显示多少页号

4、获取当前数据总条数

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

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

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

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

 1     ##============================================django自定义分页不能对页数进行限定============================
 2
 3 # class PageInfo(object):
 4 #
 5 #     def __init__(self,current_page,per_page,all_count,show_page=11):
 6 #         try:
 7 #             self.current_page = int(current_page)
 8 #         except Exception as e:
 9 #             self.current_page=1
10 #         self.per_page=per_page
11 #         self.all_count=all_count
12 #         a,b =divmod(all_count,per_page)
13 #         if b:
14 #            a = a+1
15 #         self.all_pager = a
16 #         self.show_page=show_page
17 #
18 #     def start(self):
19 #         return (self.current_page -1)* self.per_page
20 #
21 #     def end(self):
22 #         return self.current_page * self.per_page
23 #
24 #     def pager(self):
25 #         # v='<a href="/custom.html?page=1">1</a>'
26 #         # return v
27 #         page_list=[]
28 #         half=(self.show_page-1)/2
29 #         begin=self.current_page - half
30 #         stop=self.current_page +half +1
31 #         for i in range(int(begin),int(stop)):
32 #             if self.current_page == i:
33 #                 temp="<a style='display:inline-block;padding:5px;margin:5px;background-color:red' href='/custom.html?page=%s'>%s</a>"%(i,i,)
34 #             else:
35 #                 temp = "<a style='display:inline-block;padding:5px;margin:5px;' href='/custom.html?page=%s'>%s</a>" % (
36 #                 i, i,)
37 #             page_list.append(temp)
38 #
39 #         return ''.join(page_list)
40 # def custom(request):
41 #     #表示用户当前想要访问的页码
42 #     all_count = models.UserInfo.objects.all().count()
43 #     #每页显示的个数
44 #     page_info=PageInfo(request.GET.get('page'),10,all_count)
45 #     user_list = models.UserInfo.objects.all()[page_info.start():page_info.end()]
46 #     return render(request,'custom.html',{'user_list':user_list,'page_info':page_info})

Django分页（不能控制页数）

 1 from django.core.paginator import Paginator,Page
  2 class PageInfo(object):
  3
  4     def __init__(self,current_page,per_page,all_count,show_page=11):
  5         ##类的变量参数
  6         try:
  7         #捕捉异常
  8             self.current_page = int(current_page)
  9         #如果能正常转换成整型就赋值给self.current_page
 10         except Exception as e:
 11         #不能正常转换成整型就赋值成数字1
 12             self.current_page=1
 13         #设置多少条数据分为一个一页
 14         self.per_page=per_page
 15         #获取数据库中所有的数据能分为多少页
 16         self.all_count=all_count
 17         #进行分页计算（数据库总数/多少天数据进行分页）能除开等到结果就像是（12,0）把12赋值给a，把0赋值给b
 18         a,b =divmod(all_count,per_page)
 19         #如果b为真
 20         if b:
 21         #a 等于a+1
 22            a = a+1
 23         #求出总共要分的页数赋值给self.all_pager
 24         self.all_pager = a
 25         #把传入的show_page值赋值给self.show_page
 26         self.show_page=show_page
 27
 28     def start(self):
 29         #定义函数  设定起始位
 30         return (self.current_page -1)* self.per_page
 31         #返回当前页数减1 乘每页多少数据
 32     def end(self):
 33         # 定义函数  设定停止位
 34         return self.current_page * self.per_page
 35         # 返回当前页数减乘每页多少数据
 36     def pager(self):
 37         #定义函数
 38         # v='<a href="/custom.html?page=1">1</a>'
 39         # return v
 40         page_list=[]
 41         #创建列表
 42         half=(self.show_page-1)/2
 43         #获取页码的中间值
 44         if self.all_pager < self.show_page:
 45         #如果数据库的数小于设定的页码数
 46             begin=1
 47         #起始位设定为1
 48             stop=self.all_pager+1
 49         #停止为设定为数据库的数加上1（因为切片是顾头不顾尾）
 50         else:
 51         #否则
 52             if self.current_page <= half:
 53         #如果当前页码小于等于页码中间值
 54                 begin=1
 55         #起始位设定为1
 56                 stop=self.show_page+1
 57         #停止位设定为页码数加1（因为切片是顾头不顾尾）
 58             else:
 59         #否则
 60                 if self.current_page + half > self.all_pager:
 61         #如果当前页码加上中间的页码大于数据库的总页码数
 62                     begin=self.all_pager-10
 63         #起始值设定为数据库总数减10
 64                     stop=self.all_pager+1
 65         #停止值设定为数据库总数加1（因为切片是顾头不顾尾）
 66                 else:
 67         #否则
 68                     begin=self.current_page-half
 69         #起始位设定为当前页码减中间页码
 70                     stop=self.current_page+half+1
 71         #停止位设定为当前页码加中间页码加1（因为切片是顾头不顾尾）
 72         if self.current_page==self.all_pager:
 73             up = "<li><a href='#'>下一页</a></li>"
 74         else:
 75             up = "<li><a href='/custom.html?page=%s'>下一页</a></li>" % (self.current_page+1)
 76         page_list.append(up)
 77         for i in range(int(begin),int(stop)):
 78         #进行循环范围是（起始位，停止位）
 79             if self.current_page == i:
 80         #如果当前页码等于循环的i时
 81                 temp="<li class='active'><a  href='/custom.html?page=%s'>%s</a></li>"%(i,i,)
 82         #自定义一个a标签设置简单样式 并添加背景颜色作为当前页码标识
 83             else:
 84         #否则
 85                 temp = "<li><a href='/custom.html?page=%s'>%s</a></li>" % (
 86                 i, i,)
 87         #自定义一个a标签设置简单样式
 88             page_list.append(temp)
 89         #把每循环的a标签都添加到page_list列表中
 90         if self.current_page==1:
 91             nex = "<li><a href='#'>上一页</a></li>"
 92         else:
 93             nex = "<li><a href='/custom.html?page=%s'>上一页</a></li>" % (self.current_page-1)
 94         page_list.append(nex)
 95         return ''.join(page_list)
 96         #把列摆中的内容进行拼接（因为返回的是字符串）
 97 # def custom(request):
 98 #     #从数据库中获取所有数据
 99 #     all_count = models.UserInfo.objects.all().count()
100 #     #实例化一个对象并进行传值
101 #     page_info=PageInfo(request.GET.get('page'),10,all_count)
102 #     #从数据库中获取数据设置起始和结束位置
103 #     user_list = models.UserInfo.objects.all()[page_info.start():page_info.end()]
104 #     #返回到HTML标签中并传入参数
105 #     return render(request,'custom.html',{'user_list':user_list,'page_info':page_info})
106
107 ##==================================================总结=================================================================
108 '''
109 1.获取到数据中最大的页码数
110 2.设定一页显示多少数据
111 3.在用数据库总数除以要显示的内容数量（如果余数不等于零需要多添加一页）
112 4.设定一页中显示多少页码按钮
113 5.获取一页页码中中间的页码数
114 6.判断数据库的页码是不是小于设定一页中显示页码按钮的数（如果小于就重写停止值，不小于就往下判断）
115 7.判断当前页码数小于等于设定页码的中间值（重写起始值为1）
116 8.当前页码值不小于等于页码的中间值（重写起始值为中间值-5，结束值+6，因为切片是顾头不顾尾）
117 9.判断当前页码加上中间页码数是不是大于数据库总数（大于重写起始值为数据库总数-10，结束值为数据库总数+1，因为切片是顾头不顾尾）
118 10.通过python向HTML页面中传一个函数名，在HTML中函数名.方法执行（不能加括号执行）
119 11.|safe  表明是安全参数可以正常渲染
120 12.判断当前页码数是不是等于1（如果等于1不执行上一步按钮）
121 13.判断当前页码数是不是等于数据库总数（如果等于不执行下一步按钮）
122 '''

自定义分页

二十二、自关联

1、自关联，通过名字大概就知道是一张表要关联它自己本身，如果按照以前学的知识创表时肯定不能成功，这就要运用到今天新学的知识点。

related_name

2、想想，咱们以前关联表时都是在创建一个关系表里边设置外键，自关联也一样。

class UserInfo(models.Model):
    nickname = models.CharField(max_length=32)
    username = models.CharField(max_length=32)
    password = models.CharField(max_length=32)
    gender_list=(
        (1,'男'),
        (2,'女'),
    )
    gender = models.IntegerField(choices=gender_list)

class UtU(models.Model):
    g=models.ForeignKey('UserInfo',null=True,related_name='boy')
    b=models.ForeignKey('UserInfo',null=True,related_name='grily')

    重点在于related_name 这样就相当于给他们设置了别名，数据库就不会分不清谁是谁的关联

3、重点来了，表已经创好了，数据也存在怎么查看相关联的信息啊？

 def indexs(request):
     tt= models.UserInfo.objects.filter(id=2).first()
     print(tt)
     # 获取Boy表中id等于2的obj对象（Boy的obj对象）
     xx =tt.grily.all()
     # 获取UTU表中的所有和Boy对象相关的所有对象
     print(xx)
     for i in xx:
         print(i.g.nickname)
         # 循环获取UTU对象g外键对应的名称
     return HttpResponse('ok')

正向查看自关联的信息

 def indexss(request):
     tt=models.UserINfo.objects.filter(id=2).first()
     xx = tt.userinfo_set.all()
     ## 反向查看关系自关联的表
     for i in xx:
         print(i.nickname)
     return HttpResponse('ok')

反向查看自关联的信息

4、我们在通过ManyToManyField自动创建一个自关联的关系表。

class UserINfo(models.Model):
    nickname = models.CharField(max_length=32)
    username = models.CharField(max_length=32)
    password = models.CharField(max_length=32)
    gender_list=(
        (1,'男'),
        (2,'女'),
    )
    gender = models.IntegerField(choices=gender_list)
    m = models.ManyToManyField('UserINfo')

 def indexsz(request):
     tt = models.UserINfo.objects.filter(id=2).first()
     # 正向查看自关联表的内容
     xx =tt.m.all()
     # 获取到和UserINfo相关的UserINfo对象
     for i in xx:
         print(i.nickname)
     return HttpResponse('ok')

正向查看ManyToManyField自关联的信息

 def indexs(request):
     tt =models.UserINfo.objects.filter(id=2).first()
     ss=tt.userinfo_set.all()
     print(ss)
     for i in ss:
         print(i.nickname)

反向查看ManyToManyField自关联的信息

Fk（外键关联）

外键关联就是表（本身）设置一个外键，这个外键要关联的列是这个表（本身）的自增id

class User(models.Model):
    new_id=models.IntegerField(null=True)
    new_tabe= models.CharField(max_length=32)
    new_content =models.CharField(max_length=64)
    new_root = models.CharField(max_length=32)
    content = models.ForeignKey('User',null=True,blank=True,related_name='xxx')

 def indexss(request):
     xx =models.User.objects.filter(id=1).first()
     xs =models.User.objects.filter(id=2).first()
     tt =xx.xxx.all()
     ts =xs.xxx.all()
     for i in tt:
         print(i.new_content)
     for i in ts:
         print(i.new_content)
     return HttpResponse('ok')

外键关联正向查看