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')
外键关联正向查看