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 命令更新数据库

 1 这是原来的表
 2 class UserINfo(models.Model):
 3     nickname = models.CharField(max_length=32)
 4     username = models.CharField(max_length=32)
 5     password = models.CharField(max_length=32)
 6     gender_list=(
 7         (1,'男'),
 8         (2,'女'),
 9     )
10     gender = models.IntegerField(choices=gender_list)
11     m = models.ManyToManyField('UserINfo')
12 -------------------------------------------------------------------------
13 这是新增的表
14 class User(models.Model):
15     new_id=models.IntegerField(null=True)
16     new_tabe= models.CharField(max_length=32)
17     new_content =models.CharField(max_length=64)
18     new_root = models.CharField(max_length=32)
19     content = models.ForeignKey('User',null=True,blank=True,related_name='xxx')

b.数据库表的删

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

 1 这是数据库的表
 2 class GTB(models.Model):
 3     g = models.ForeignKey('Boy',null=True)
 4     b = models.ForeignKey('Grily',null=True)
 5 
 6 -------------------------------------------------------------
 7 这是删除数据库表
 8 # class UserInfo(models.Model):
 9 #     nickname = models.CharField(max_length=32)
10 #     username = models.CharField(max_length=32)
11 #     password = models.CharField(max_length=32)
12 #     gender_list=(
13 #         (1,'男'),
14 #         (2,'女'),
15 #     )
16 #     gender = models.IntegerField(choices=gender_list)

c.数据库表的改

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

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

 1 这是数据库未进行修改的表
 2 class Boy(models.Model):
 3     username = models.CharField(max_length=32)
 4     nickname = models.CharField(max_length=32)
 5     password = models.CharField(max_length=32)
 6 
 7 
 8 ------------------------------------------------------------
 9 这是要进行更改数据的表
10 class Boy(models.Model):
11     username = models.CharField(max_length=32)
12     name = models.CharField(max_length=32)
13     password = models.CharField(max_length=32)

d.数据库表行的增

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

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

e.数据库表行的删

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

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

f.数据库表行的改

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

1 def index（request）：
2 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、单一路由对应

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

2、基于正则的路由

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

3、添加额外的参数

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

4、为路由映射设置名称

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() 方法

 1 class NewType(models.Model):
 2     caption = models.CharField(max_length=16)
 3 
 4 
 5     def get_absolute_url(self):
 6         """
 7         为每个对象生成一个URL
 8         应用：在对象列表中生成查看详细的URL，使用此方法即可！！！
 9         :return:
10         """
11         # return '/%s/%s' % (self._meta.db_table, self.id)
12         # 或
13         from django.urls import reverse
14         return reverse('NewType.Detail', kwargs={'nid': self.id})

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

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

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

6、命名空间

a. project.urls.py

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

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

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 中获取的数据插入到模版中，最后将信息返回给用户。

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

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

 1 import datetime
 2 from django import template
 3 import DjangoDemo.settings
 4  
 5 now = datetime.datetime.now()
 6 fp = open(settings.BASE_DIR+'/templates/Home/Index.html')
 7 t = template.Template(fp.read())
 8 fp.close()
 9 html = t.render(template.Context({'current_date': now}))
10 return HttpResponse(html

 1 from django.template.loader import get_template
 2 from django.template import Context
 3 from django.http import HttpResponse
 4 import datetime
 5  
 6 def current_datetime(request):
 7     now = datetime.datetime.now()
 8     t = get_template('current_datetime.html')
 9     html = t.render(Context({'current_date': now}))
10     return HttpResponse(html)

1 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 文件名

{% load xx %}

d、使用simple_tag

{% 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)

六、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)

七、extra

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

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

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

八、连表

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 1     # vv = models.UserType.objects.values('title','userinfo__name')
2 2     # print(vv)

e.元组正向查找

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

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

f.元组反向查找

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

1 1     # v4 = models.UserType.objects.all().values_list('title','userinfo__name')
2 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('....')

1  ss =models.UserInfo.objects.all().order_by('-id','age').reverse()
2  print(ss.query)
3 '''
4  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
5 
6 '''
7 
8 将设置的排序方式进行反转，本来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)
<br>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)

十六、其他相关操作

 1  models.UserInfo.objects.dates('ctime','day','DESC')
 2 根据时间进行某一部分进行去查找并截取指定内容 (参数 表行   时间格式  排方式)
 3 kind  只能是 year（年） month（年-月）day（年-月-日）
 4 order 只能是 ASC DESC   (排序方式)
 5 并获取转换后的时间
 6  year   年 01 01
 7 month  年 月 01
 8  day    年 月 日
 9 models.UserInfo.objects.datetimes('ctime','hour',tzinfo=pytz.UTC)
10 128     #根据时间进行某一部分查找并截取指定内容，将时间转换为指定时区时间
11 kind只能是 year month day hour minute second
12 order只能是 ASC DESC  排序方式
13 tzinfo 时区对象
14 models.UserInfo.objects.datetimes('ctime','hour',tzinfo=pytz.timezone('Asia/Shanghai'))
15 ’''
16  安装 pythz pip3 install pytz
17  import pytz
18  pytz.all_timezones
19 pytz.timezone('Asia/Shanghai')
20  '''
21 def none(self):
22     #空QuesySet
23      pass
24  ss=models.UserInfo.objects.aggregate(k=Count('ut_id',distinct=True),n=Count('id'))
25 {'k': 3, 'n': 7}
26  print(ss)
27  ogj=[
28      models.UserInfo(name='alex'),
29      models.UserInfo(name='egon')
30 
31  ]
32  models.UserInfo.objects.bulk_create(ogj,10)
33 批量插入数据 10代表没次插入数量
34  obj,creted = models.UserInfo.objects.get_or_create(username='roo1',defaults={'email':'11111','u_id':2,'tid':3})
35 先查看如果存在就不执行创建的操作，如果不存在就会创建后边的数据
36  obj,creted = models.UserInfo.objects.update_or_create(username='roo1',defaults={'email':'11111','u_id':2,'tid':3})
37 先查如果存在就不执行更新，如果不存在就会创建后边的数据
38  id=[11,222,333]
39  models.UserInfo.objects.in_bulk(id)
40 根据主键ID进行查找
41  ss = models.UserInfo.objects.exists()
42 #查看是否有结果
43  print(ss)
44 return HttpResponse('....')

十七、cookie

cookie 是一保存在客户端浏览器上的键值对
个人理解cookie 工作原理：因为http是短连接，无状态的 用户通过浏览器访问服务端如果登录成功，服务端会给客户端浏览器发送一个cookie，下次再来访问时只要携带者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获取（不是绝对，底层抓包可以获取到也可以被覆盖）

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

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

Session个人理解　

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

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

二十一、分页

一、Django内置分页

 1 from django.shortcuts import render
 2 from django.core.paginator import Paginator, EmptyPage, PageNotAnInteger
 3 
 4 L = []
 5 for i in range(999):
 6     L.append(i)
 7 
 8 def index(request):
 9     current_page = request.GET.get('p')
10 
11     paginator = Paginator(L, 10)
12     # per_page: 每页显示条目数量
13     # count:    数据总个数
14     # num_pages:总页数
15     # page_range:总页数的索引范围，如: (1,10),(1,200)
16     # page:     page对象
17     try:
18         posts = paginator.page(current_page)
19         # has_next              是否有下一页
20         # next_page_number      下一页页码
21         # has_previous          是否有上一页
22         # previous_page_number  上一页页码
23         # object_list           分页之后的数据列表
24         # number                当前页
25         # paginator             paginator对象
26     except PageNotAnInteger:
27         posts = paginator.page(1)
28     except EmptyPage:
29         posts = paginator.page(paginator.num_pages)
30     return render(request, 'index.html', {'posts': posts})

 1 <!DOCTYPE html>
 2 <html>
 3 <head lang="en">
 4     <meta charset="UTF-8">
 5     <title></title>
 6 </head>
 7 <body>
 8 <ul>
 9     {% for item in posts %}
10         <li>{{ item }}</li>
11     {% endfor %}
12 </ul>
13 
14 <div class="pagination">
15       <span class="step-links">
16         {% if posts.has_previous %}
17             <a href="?p={{ posts.previous_page_number }}">Previous</a>
18         {% endif %}
19           <span class="current">
20             Page {{ posts.number }} of {{ posts.paginator.num_pages }}.
21           </span>
22           {% if posts.has_next %}
23               <a href="?p={{ posts.next_page_number }}">Next</a>
24           {% endif %}
25       </span>
26 
27 </div>
28 </body>
29 </html>

 1 from django.shortcuts import render
 2 from django.core.paginator import Paginator, EmptyPage, PageNotAnInteger
 3 
 4 
 5 class CustomPaginator(Paginator):
 6     def __init__(self, current_page, max_pager_num, *args, **kwargs):
 7         """
 8         :param current_page: 当前页
 9         :param max_pager_num:最多显示的页码个数
10         :param args:
11         :param kwargs:
12         :return:
13         """
14         self.current_page = int(current_page)
15         self.max_pager_num = max_pager_num
16         super(CustomPaginator, self).__init__(*args, **kwargs)
17 
18     def page_num_range(self):
19         # 当前页面
20         # self.current_page
21         # 总页数
22         # self.num_pages
23         # 最多显示的页码个数
24         # self.max_pager_num
25         print(1)
26         if self.num_pages < self.max_pager_num:
27             return range(1, self.num_pages + 1)
28         print(2)
29         part = int(self.max_pager_num / 2)
30         if self.current_page - part < 1:
31             return range(1, self.max_pager_num + 1)
32         print(3)
33         if self.current_page + part > self.num_pages:
34             return range(self.num_pages + 1 - self.max_pager_num, self.num_pages + 1)
35         print(4)
36         return range(self.current_page - part, self.current_page + part + 1)
37 
38 
39 L = []
40 for i in range(999):
41     L.append(i)
42 
43 def index(request):
44     current_page = request.GET.get('p')
45     paginator = CustomPaginator(current_page, 11, L, 10)
46     # per_page: 每页显示条目数量
47     # count:    数据总个数
48     # num_pages:总页数
49     # page_range:总页数的索引范围，如: (1,10),(1,200)
50     # page:     page对象
51     try:
52         posts = paginator.page(current_page)
53         # has_next              是否有下一页
54         # next_page_number      下一页页码
55         # has_previous          是否有上一页
56         # previous_page_number  上一页页码
57         # object_list           分页之后的数据列表
58         # number                当前页
59         # paginator             paginator对象
60     except PageNotAnInteger:
61         posts = paginator.page(1)
62     except EmptyPage:
63         posts = paginator.page(paginator.num_pages)
64 
65     return render(request, 'index.html', {'posts': posts})

 1 <!DOCTYPE html>
 2 <html>
 3 <head lang="en">
 4     <meta charset="UTF-8">
 5     <title></title>
 6 </head>
 7 <body>
 8 
 9 <ul>
10     {% for item in posts %}
11         <li>{{ item }}</li>
12     {% endfor %}
13 </ul>
14 
15 <div class="pagination">
16 <span class="step-links">
17 {% if posts.has_previous %}
18     <a href="?p={{ posts.previous_page_number }}">Previous</a>
19 {% endif %}
20 
21     {% for i in posts.paginator.page_num_range %}
22         <a href="?p={{ i }}">{{ i }}</a>
23     {% endfor %}
24 
25     {% if posts.has_next %}
26         <a href="?p={{ posts.next_page_number }}">Next</a>
27     {% endif %}
28 </span>
29 
30 <span class="current">
31 Page {{ posts.number }} of {{ posts.paginator.num_pages }}.
32 </span>
33 
34 </div>
35 </body>
36 </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;%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})

 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、重点来了，表已经创好了，数据也存在怎么查看相关联的信息啊？

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

1 def indexss(request):
2     tt=models.UserINfo.objects.filter(id=2).first()
3     xx = tt.userinfo_set.all()
4     ## 反向查看关系自关联的表
5     for i in xx:
6         print(i.nickname)
7     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')

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

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

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

 1 def indexss(request):
 2     xx =models.User.objects.filter(id=1).first()
 3     xs =models.User.objects.filter(id=2).first()
 4     tt =xx.xxx.all()
 5     ts =xs.xxx.all()
 6     for i in tt:
 7         print(i.new_content)
 8     for i in ts:
 9         print(i.new_content)
10     return HttpResponse('ok')

posted on 2018-03-15 12:24 不死孤狼阅读(240) 评论(0) 收藏举报

python Django知识点总结

一、Django创建项目：

二、创建数据库（ORM）

a.数据库表的增

b.数据库表的删

c.数据库表的改

d.数据库表行的增

e.数据库表行的删

f.数据库表行的改

g.数据库表行的查

三、路由系统

四、模板

五、F

六、Q

七、extra

八、连表

a.对象连表

b.字典连表

c.元组连表

七、正反向查找

a.对象正向查找

b.对象反向查找

c.字典正向查找

d.字典反向查找

e.元组正向查找

f.元组反向查找

九、排序

十、annotate（组合）

十一、转化成sql语句

十二、去重

十三、排除某列数据

十四、仅获取某列数据

十五、指定使用某数据库

十六、其他相关操作

十七、cookie

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

十九、crsf 跨站伪装请求

二十、session

Session个人理解

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

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

数据库 Session

缓存Session

文件Session

缓存+数据库Session

Cookie 中存放Session

Session 用户验证

二十一、分页

二十二、自关联

Fk（外键关联）

Session个人理解　

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