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、单一路由对应
|
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() 方法
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对路由规则进行分类
|
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 中获取的数据插入到模版中，最后将信息返回给用户。
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 文件名
|
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)
六、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,])
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)
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：
|
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" οnclick="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 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;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})
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')
152
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
