第1章课堂笔记

class (models.Model):

title=models.CharField(max_length=32)

price=models.DecimalField(max_digits=6,decimal_places=2)

create_time=models.DateField()

memo=models.CharField(max_length=32,default="")

# book_obj.publish: 与这本书籍关联的出版社对象

publish=models.ForeignKey(to="Publish",default=1)

# book_obj.author.all(): 与这本书关联的作者对象集合,Queryset []

author=models.ManyToManyField("Author")

def __str__(self):

return self.title

class Publish(models.Model):

name=models.CharField(max_length=32)

email=models.CharField(max_length=32)

class Author(models.Model):

name=models.CharField(max_length=32)

def __str__(self):return self.name

基于对象查询（子查询）

一对多

正向查询，按字段

Book-------------------->Publish

<---------------------

反向查询,按表名小写_set:book_set

obj=Book.objects.fliter(title="python").first()

obj.publish

多对多

正向查询，按字段

Book-------------------->Author

<---------------------

查询,按表名小写_set:book_set

obj=Book.objects.fliter(title="python").first()

obj.author.all() # [obj,....]

一对一：

正向查询，按字段

Book-------------------->Author

<---------------------

查询,按表名小写

基于queryset查询

正向查询，按字段

A-------------------->B

<---------------------

查询,按表名小写

聚合和分组

book

id title publish

1 php 苹果

2 python 苹果

3 go 橘子

sql： select publish,Count(*) from Book group by publish

#查询每一个出版社出版的书籍个数

# ret=Publish.objects.all().annotate(c=Count("book")).values("name","c")

# print(ret)

# 查询每一个作者出版的书籍的平均价格

ret=Author.objects.all().annotate(price_avg=Avg("book__price")).values("name","price_avg")

print(ret)

#查询每一本书籍名称以及作者的个数

ret=Book.objects.all().annotate(c=Count("author")).values("title","c")

print(ret)

# 查询价格大于200的每一本书籍名称以及作者的个数

ret = Book.objects.filter(price__gt=200).annotate(c=Count("author")).values("title", "c")

print(ret)

F查询与Q查询

# F

from django.db.models import F,Q

ret=Book.objects.filter(comment_num__gt=F("poll_num"))

print(ret)

ret=Book.objects.filter(comment_num__gt=F("read_num")*10)

print(ret)

Book.objects.all().update(price=F("price")+100)

# Q

ret=Book.objects.filter(title__startswith="java",price__gt=200)

print(ret)

ret = Book.objects.filter(Q(title__startswith="java")|~Q(price__lt=200))

print(ret)

Ajax

请求形式：

地址栏 get

form

get

post

a标签 get

ajax

get

post

cookie session

http协议：

基于请求响应

短连接

无状态保存

用户认证

form组件

中间件

作业1：

基于ajax和cookie实现登录验证

作业2;

查询练习题

Book publish

id title publish_id id name email addr

1 php 1 1 AAA 123 beijing

2 python 1

Bookpublish

id title publish_id id name email addr

1 php 1 1 AAA 123 beijing

2 python 1 1 AAA 123 beijing

SELECT "app01_book"."title", "app01_publish"."name" FROM "app01_authordetail" INNER JOIN "app01_author" ON ("app01_authordetail"."author_id" = "app01_author"."id") LEFT OUTER JOIN "app01_book_author" ON ("app01_author"."id" = "app01_book_author"."author_id") LEFT OUTER JOIN "app01_book" ON ("app01_book_author"."book_id" = "app01_book"."id") LEFT OUTER JOIN "app01_publish" ON ("app01_book"."publish_id" = "app01_publish"."id") WHERE "app01_authordetail"."tel" LIKE '1%' ESCAPE '\' LIMIT 21; args=('1%',)

Author

id name tel addr email

1 alex 123 beijing 123

2 egon 456 beijing 456

AuthorDetail

id gf_name xingzuo xuexing author_id

1 xxx 天蝎 A 1

2 杠娘双鱼 O 2

第2章 Django之ORM跨表操作（聚合查询，分组查询，F和Q查询等）

2.1 创建表

书籍模型：书籍有书名和出版日期，一本书可能会有多个作者，一个作者也可以写多本书，所以作者和书籍的关系就是多对多的关联关系(many-to-many);

　　　　一本书只应该由一个出版商出版，所以出版商和书籍是一对多关联关系(one-to-many)。

创建一对一的关系：OneToOne("要绑定关系的表名")

创建一对多的关系：ForeignKey("要绑定关系的表名")

创建多对多的关系：ManyToMany("要绑定关系的表名") 会自动创建第三张表

class Book(models.Model):

nid = models.AutoField(primary_key=True) # 自增id(可以不写，默认会有自增id)

title = models.CharField(max_length=32)

publishDdata = models.DateField() # 出版日期

price = models.DecimalField(max_digits=5, decimal_places=2) # 一共5位，保留两位小数

#一个出版社有多本书，关联字段要写在多的一方

# 不用命名为publish_id，因为django为我们自动就加上了_id

publish = models.ForeignKey("Publish") #foreignkey（表名）建立的一对多关系

# publish是实例对象关联的出版社对象

authorlist = models.ManyToManyField("Author") #建立的多对多的关系

def __str__(self): #__str__方法使用来吧对象转换成字符串的，你返回啥内容就打印啥

return self.title

class Publish(models.Model):

#不写id的时候数据库会自动给你增加自增id

name =models.CharField(max_length=32)

addr = models.CharField(max_length=32)

def __str__(self):

return self.name

class Author(models.Model):

name = models.CharField(max_length=32)

age = models.IntegerField()

class AuthorDeital(models.Model):

tel = models.IntegerField()

addr = models.CharField(max_length=32)

author = models.OneToOneField("Author") #建立的一对一的关系

注意：临时添加的字段，首先你得考虑之前的数据有没有。设置一个默认值。

　　　 wordNum = models.IntegerField（default=0）

通过logging可以查看翻译成的sql语句

LOGGING = {

'version': 1,

'disable_existing_loggers': False,

'handlers': {

'console':{

'level':'DEBUG',

'class':'logging.StreamHandler',

'loggers': {

'django.db.backends': {

'handlers': ['console'],

'propagate': True,

'level':'DEBUG',

}

注意事项：

1、表的名称myapp_modelName，是根据模型中的元数据自动生成的，也可以覆写为别的名称　　

2、id 字段是自动添加的

3、对于外键字段，Django 会在字段名上添加"_id" 来创建数据库中的列名

4、这个例子中的CREATE TABLE SQL 语句使用PostgreSQL 语法格式，要注意的是Django 会根据settings 中指定的数据库类型来使用相应的SQL 语句。

5、定义好模型之后，你需要告诉Django _使用_这些模型。你要做的就是修改配置文件中的INSTALL_APPSZ中设置，在其中添加models.py所在应用的名称。

6、外键字段 ForeignKey 有一个 null=True 的设置(它允许外键接受空值 NULL)，你可以赋给它空值 None 。

字段选项

每个字段有一些特有的参数，例如，CharField需要max_length参数来指定VARCHAR数据库字段的大小。还有一些适用于所有字段的通用参数。这些参数在文档中有详细定义，这里我们只简单介绍一些最常用的：

1)null

如果为True，Django 将用NULL 来在数据库中存储空值。默认值是 False.

(1)blank

如果为True，该字段允许不填。默认为False。

要注意，这与 null 不同。null纯粹是数据库范畴的，而 blank 是数据验证范畴的。

如果一个字段的blank=True，表单的验证将允许该字段是空值。如果字段的blank=False，该字段就是必填的。

(2)default

字段的默认值。可以是一个值或者可调用对象。如果可调用，每有新对象被创建它都会被调用。

(3)primary_key

如果为True，那么这个字段就是模型的主键。如果你没有指定任何一个字段的primary_key=True，

Django 就会自动添加一个IntegerField字段做为主键，所以除非你想覆盖默认的主键行为，

否则没必要设置任何一个字段的primary_key=True。

(4)unique

如果该值设置为 True, 这个数据字段的值在整张表中必须是唯一的

(5)choices

由二元组组成的一个可迭代对象（例如，列表或元组），用来给字段提供选择项。如果设置了choices ，
默认的表单将是一个选择框而不是标准的文本框，而且这个选择框的选项就是choices 中的选项。

这是一个关于 choices 列表的例子：

YEAR_IN_SCHOOL_CHOICES = (

('FR', 'Freshman'),

('SO', 'Sophomore'),

('JR', 'Junior'),

('SR', 'Senior'),

('GR', 'Graduate'),

)

每个元组中的第一个元素，是存储在数据库中的值；第二个元素是在管理界面或 ModelChoiceField 中用作显示的内容。
在一个给定的 model 类的实例中，想得到某个 choices 字段的显示值，就调用 get_FOO_display 方法(这里的 FOO 就是 choices 字段的名称 )。例如：

from django.db import models

class Person(models.Model):

SHIRT_SIZES = (

('S', 'Small'),

('M', 'Medium'),

('L', 'Large'),

)

name = models.CharField(max_length=60)

shirt_size = models.CharField(max_length=1, choices=SHIRT_SIZES)

>>> p = Person(name="Fred Flintstone", shirt_size="L")

>>> p.save()

>>> p.shirt_size

'L'

>>> p.get_shirt_size_display()

'Large

一旦你建立好数据模型之后，django会自动生成一套数据库抽象的API，可以让你执行关于表记录的增删改查的操作。

2.2 添加记录

2.2.1 一对多添加记录：

# 一对多的添加

# 方式一:如果是这样直接指定publish_id字段去添加值，前提是你的主表里面必须有数据

# 主表：没有被关联的（因为book表是要依赖于publish这个表的）也就是publish表

# 子表：关联的表

models.Book.objects.create(title="追风筝的人",publishDdata="2015-5-8",price="111",publish_id=1)

# 方式二:推荐

pub_obj = models.Publish.objects.filter(name="人民出版社")[0]

print(pub_obj)

models.Book.objects.create(title = "简爱",publishDdata="2000-6-6",price="222",publish=pub_obj)

# 方式三：save

pubObj= models.Publish.objects.get(name="人民出版社") #只有一个的时候用get,拿到的直接就是一个对象

bookObj = models.Book(title = "真正的勇士",publishDdata="2015-9-9",price="50",publish=pubObj)

bookObj.save()

2.2.2 多对多添加记录：

　　书和作者是多对多的关系：一个书可以有多个作者，一个作者可以出版多本书

　　步骤：先找到书对象

　　　　　再找到需要的作者对象

　　　　　给书对象绑定作者对象（用add方法），也就是绑定多对多的关系

# 多对多的添加的两种方式

# 方式一：

# 先创建一本书：

pub_obj=models.Publish.objects.filter(name="万能出版社").first()

book_obj = models.Book.objects.create(title="醉玲珑",publishDdata="2015-4-10",price="222",publish=pub_obj)

# #通过作者的名字django默认找到id

haiyan_obj = models.Author.objects.filter(name="haiyan")[0]

egon_obj = models.Author.objects.filter(name="egon")[0]

xiaoxiao_obj = models.Author.objects.filter(name="xiaoxiao")[0]

# 绑定多对多的关系、

book_obj.authorlist.add(haiyan_obj, egon_obj, xiaoxiao_obj)

# 方式二=========,查出所有的作者

pub_obj = models.Publish.objects.filter(name="万能出版社").first()

book_obj = models.Book.objects.create(title="醉玲珑", publishDdata="2015-4-10", price="222", publish=pub_obj)

authers = models.Author.objects.all()

# #绑定多对多关系

book_obj.authorlist.add(*authers)

2.2.3 解除绑定

解除绑定：remove： # 将某个特定的对象从被关联对象集合中去除。 ====== book_obj.authors.remove(*[])

# 解除多对多的关系（remove）

book_obj=models.Book.objects.filter(title="醉玲珑").last() #找到书对象

authers=models.Author.objects.filter(id__lt=3) #找到符合条件的作者对象

book_obj.authorlist.remove(*authers) #因为清除的是多条，得加个*

2.2.4 清除绑定

清除绑定：clear” #清空被关联对象集合。

# 清除关系方法(clear)

book_obj= models.Book.objects.filter(title="红楼梦")

for book_obj_item in book_obj:#把所有红楼梦的都给清空了

book_obj_item.authorlist.clear()

2.2.5 总结：remove和clear的区别

　　remove：得把你要清除的数据筛选出来，然后移除
　　clear：不用查，直接就把数据都清空了。
　　各有应用场景

2.3 基于对象的查询记录（相当于sql语句的where子查询）

2.3.1 一对一查询记录

一对一查询记录：author和authordetile是一对一的关系

正向查询（按字段author）

反向查询（按表名authordeital）：因为是一对一的关系了，就不用_set了。

# 一对一的查询

# 正向查询：手机号为13245的作者的姓名

deital_obj = models.AuthorDeital.objects.filter(tel="13245").first()

print(deital_obj.author.name)

# 反向查询：查询egon的手机号

egon_obj = models.Author.objects.filter(name="egon").first()

print(egon_obj.authordeital.tel)

2.3.2 一对多查询记录：

正向查询(按字段：publish)：

反向查询(按表名：book_set)：

# 正向查询：查询真正的勇士这本书的出版社的地址

book_obj = models.Book.objects.filter(title="真正的勇士")[0] # 找对象

print("======", book_obj.publish) # 拿到的是关联出版社的对象

print(book_obj.publish.addr)

# 反向查询：查询人民出版社出版过的所有的书的价格和名字

pub_obj = models.Publish.objects.filter(name="人民出版社")[0]

book_dic = pub_obj.book_set.all().values("price", "title")[0]

print(book_dic)

print(book_dic["price"])
# 查询人民出版社出版过的所有书籍

publish=models.Publish.objects.get(name="人民出版社") #get得到的直接是一个对象，不过get只能查看有一条记录的

book_list=publish.book_set.all() # 与人民出版社关联的所有书籍对象集合

for book_obj in book_list:

print(book_obj.title)

注意这里用for循环或是用values,vauleslist都是可以的。

2.3.3 多对多查询记录：

正向查询（按字段authorlist）

反向查询（按表名book_set）

# 多对多的查询

# 正向查询：查询追风筝的人的这本书的所有的作者的姓名和年龄

book_obj = models.Book.objects.filter(title="红楼梦")[0]

print(book_obj.authorlist.all().values("name", "age")) # 这本书关联的所有作者对象的集合

# 反向查询：查询作者是haiyan的这个人出了哪几本书的信息

haiyan_obj = models.Author.objects.filter(name="haiyan")[0]

print("bookinfo====", haiyan_obj.book_set.all().first().title) # 与该作者关联的所有书对象的集合

return HttpResponse("ok")

你可以通过在 ForeignKey() 和ManyToManyField的定义中设置 related_name 的值来覆写 FOO_set 的名称。例如，如果 Article model 中做一下更改： publish = ForeignKey(Blog, related_name='bookList')，那么接下来就会如我们看到这般：

# 查询人民出版社出版过的所有书籍

publish=Publish.objects.get(name="人民出版社")

book_list=publish.bookList.all() # 与人民出版社关联的所有书籍对象集合

2.4 基于双下划线的跨表查询

Django 还提供了一种直观而高效的方式在查询(lookups)中表示关联关系，它能自动确认 SQL JOIN 联系。要做跨关系查询，就使用两个下划线来链接模型(model)间关联字段的名称，直到最终链接到你想要的 model 为止。(相当于用sql语句用join连接的方式，可以在settings里面设置，可查看sql语句)

2.4.1 一对多查询：

练习1、查询人民出版社出版过的所有的书的价格和名字

# 基于双下划线的方式查询1================一对多

# 第一种查法

ret = models.Publish.objects.filter(name="人民出版社").values("book__price","book__title")

print(ret)

# 第二种查法

ret2 = models.Book.objects.filter(publish__name="人民出版社").values("price","title")

print(ret2)

练习2、查询linux这本书的出版社的地址:filer先过滤，，values显示要求的字段

第一种查法

ret = models.Book.objects.filter(title="linux").values("publish__addr")

print(ret)

第二种查法

ret2 = models.Publish.objects.filter(book__title="linux").values("addr")

print(ret2)

2.4.2 多对多查询：

练习1、查询egon出过的所有书的名字

#方式一
ret = models.Author.objects.filter(name="egon").values("book__title")

print(ret)
#方式二：两种方式也就是逻辑不一样

ret2 = models.Book.objects.filter(authorlist__name="egon").values("title")

print(ret2)

练习2、查询手机号以151开头的作者出版过的所有书的名称以及出版社的名称

# 方式一：

author_obj = models.AuthorDeital.objects.filter(tel__startswith="151").first()

print(author_obj.author.book_set.all().values("title","publish__name"))

# 方式二：

ret = models.Book.objects.filter(authorlist__author_deital__tel__startswith="151").values("title","publish__name")

print(ret)

2.5 聚合查询与分组查询（很重要！！！）

2.5.1 聚合查询

聚合查询：aggregate(*args, **kwargs)，只对一个组进行聚合

from django.db.models import Avg,Sum,Count,Max,Min
# 1、查询所有图书的平均价格

print(models.Book.objects.all().aggregate(Avg("price")))

aggregate()是QuerySet 的一个终止子句（也就是返回的不再是一个QuerySet集合的时候），意思是说，它返回一个包含一些键值对的字典。键的名称是聚合值的标识符，值是计算出来的聚合值。键的名称是按照字段和聚合函数的名称自动生成出来的。如果你想要为聚合值指定一个名称，可以向聚合子句提供它。

from django.db.models import Avg,Sum,Count,Max,Min

# 1、查询所有图书的平均价格

print(models.Book.objects.all().aggregate(avgprice = Avg("price")))

如果你希望生成不止一个聚合，你可以向aggregate()子句中添加另一个参数。所以，如果你也想知道所有图书价格的最大值和最小值，可以这样查询：

print(models.Book.objects.all().aggregate(Avg("price"),Max("price"),Min("price")))
#打印的结果是： {'price__avg': 174.33333333333334, 'price__max': Decimal('366.00'), 'price__min': Decimal('12.00')}

2.5.2 分组查询

分组查询 :annotate()：为QuerySet中每一个对象都生成一个独立的汇总值。

是对分组完之后的结果进行的聚合

1、统计每一本书的作者个数

# 方式一：

print(models.Book.objects.all().annotate(authorNum = Count("authorlist__name")).values("authorNum"))

# 方式二：

booklist =models.Book.objects.all().annotate(authorNum=Count("authorlist__name"))

for book_obj in booklist:

print(book_obj.title,book_obj.authorNum)

2、统计每一个出版社最便宜的书

# 2、统计每一个出版社的最便宜的书

# 方式一：

print(models.Book.objects.values("publish__name").annotate(nMinPrice=Min('price'))) 注意：values内的字段即group by的字段，，也就是分组条件

# 方式二：

print(models.Publish.objects.all().annotate(minprice=Min("book__price")).values("name","minprice"))

# 方式三

publishlist = models.Publish.objects.annotate(minprice = Min("book__price"))

for publish_obj in publishlist:

print(publish_obj.name,publish_obj.minprice)

3、统计每一本以py开头的书籍的作者个数：

print(models.Book.objects.filter(title__startswith="py").annotate(authNum = Count("authorlist__name")).values("authNum"))

(4)统计不止一个作者的图书：

print(models.Book.objects.annotate(num_authors=Count('authorlist__name')).filter(num_authors__gt=1).values("title","num_authors"))

(5)根据一本图书作者数量的多少对查询集QuerySet进行排序:

print(models.Book.objects.all().annotate(authorsNum=Count("authorlist__name")).order_by("authorsNum"))

(6)查询各个作者出的书的总价格:

# 方式一

print(models.Author.objects.all().annotate(priceSum = Sum("book__price")).values("name","priceSum"))

# 方式二

print(models.Book.objects.values("authorlist__name").annotate(priceSum=Sum("price")).values("authorlist__name","priceSum"))

2.6 F查询和Q查询

2.6.1 F查询

F查询：

在上面所有的例子中，我们构造的过滤器都只是将字段值与某个常量做比较。如果我们要对两个字段的值做比较，那该怎么做呢？

Django 提供 F() 来做这样的比较。F() 的实例可以在查询中引用字段，来比较同一个 model 实例中两个不同字段的值。

1、查看评论数大于阅读数的书

from django.db.models import F,Q

print(models.Book.objects.filter(commentNum__gt=F("readNum")))

2、修改操作也可以使用F函数,比如将id大于1的所有的书的价格涨价100元

print(models.Book.objects.filter(nid__gt=1).update(price=F("price")+100))

3、Django 支持 F() 对象之间以及 F() 对象和常数之间的加减乘除和取模的操作。

# 查询评论数大于收藏数2倍的书籍

models.Book.objects.filter(commnetNum__lt=F('keepNum')*2)

2.6.2 Q查询

Q查询：

filter() 等方法中的关键字参数查询都是一起进行“AND” 的。 如果你需要执行更复杂的查询（例如OR 语句），你可以使用Q 对象。

1、查询id大于1并且评论数大于100的书

print(models.Book.objects.filter(nid__gt=1,commentNum__gt=100))

print(models.Book.objects.filter(nid__gt=1).filter(commentNum__gt=100))

print(models.Book.objects.filter(Q(nid__gt=1)&Q(commentNum__gt=100)))

2、查询评论数大于100或者阅读数小于200的书

print(models.Book.objects.filter(Q(commentNum__gt=100)|Q(readNum__lt=200)))
Q 对象可以使用& 和| 操作符组合起来。当一个操作符在两个Q 对象上使用时，它产生一个新的Q 对象。

3、查询年份等于2017年或者价格大于200的书

print(models.Book.objects.filter(Q(publishDdata__year=2017)|Q(price__gt=200)))

4、查询年份不是2017年或者价格大于200的书

print(models.Book.objects.filter(~Q(publishDdata__year=2017)&Q(price__gt=200)))

注意：

查询函数可以混合使用Q 对象和关键字参数。所有提供给查询函数的参数（关键字参数或Q 对象）都将"AND”在一起。但是，如果出现Q 对象，它必须位于所有关键字参数的前面。例如：

bookList=models.Book.objects.filter(Q(publishDate__year=2016) | Q(publishDate__year=2017),

title__icontains="python"

)

2.7 关于查询知识点总结

models.Book.objects.filter(**kwargs): querySet [obj1,obj2]
models.Book.objects.filter(**kwargs).values(*args) : querySet [{},{},{}]
models.Book.objects.filter(**kwargs).values_list(title) : querySet [(),(),()]

跨表查询总结：

2.7.1 创建表

class Book(models.Model):

　　title = models.CharField(max_length=32)

　　publish=models.ForeignKey("Publish") # 创建一对多的外键字段

　　authorList=models.ManyToManyField("Author") # 多对多的关系，自动创建关系表

class Publish(models.Model):

　　name = models.CharField(max_length=32)

　　addr = models.CharField(max_length=32)

class Author(models.Model):

　　name=models.CharField(max_length=32)

　　age=models.IntegerField()

　　ad=models.models.OneToOneField("AuthorDetail") #创建一对一的关系

class AuthorDetail(models.Model):

　　tel=models.IntegerField()

2.7.2 基于对象关联查询：

if 一对多查询（Book--Publish）：

　　正向查询，按字段：

　　book_obj.publish : 与这本书关联的出版社对象 book_obj.publish.addr: 与这本书关联的出版社的地址

　　反向查询，按表名_set

　　publish_obj.book_set: 与这个出版社关联的书籍对象集合 publish_obj.book_set.all() ：[obj1,obj2,....]

if 一对一查询（Author---AuthorDetail）：

　　正向查询，按字段：

　　author_obj.ad : 与这个作者关联的作者详细信息对象

　　反向查询：按表名：

　　author_detail_obj.author ：与这个作者详细对象关联的作者对象

if 多对多（Book----Author）：

　　正向查询，按字段：

　　book_obj.authorList.all(): 与这本书关联的所有这作者对象的集合 [obj1,obj2,....]

　　book_obj.authorList.all().values("name"): 如果想查单个值的时候可以这样查

　　反向查询,按表名_set：

　　author_obj.book_set.all() : 与这个作者关联的所有书籍对象的集合

　 book_obj.book_set.all().values("name"): 如果想查单个值的时候可以这样查

2.7.3 基于双下滑线的跨表查询：

if 一对多查询（Book--Publish）：

　　正向查询，按字段：

　# 查询linux这本书的出版社的名字：

　　models.Book.objects.all().filter(title="linux").values("publish__name")

反向查询：按表名：

# 查询人民出版社出版过的所有书籍的名字

　　models.Publish.objects.filter(name="人民出版社出版").values("book__title")

if 一对一查询（Author---AuthorDetail）：

　　正向查询，按字段：

#查询egon的手机号

　　models.Author.objects.filter(name="egon").values("ad__tel")

　反向查询：按表名：

#查询手机号是151的作者

　　models.AuthorDetail.objects.filter(tel="151").values("author__name")

if 多对多（Book----Author）：

　　正向查询，按字段：

#查询python这本书的作者的名字

　　models.Book.objects.filter(title="python").values("authorList__name") [{},{},{},{}]

　　正向查询，按表名：

#查询alex出版过的出的价格

models.Author.objects.filter(name="alex").values("book__price")

注意：

publish=models.ForeignKey("Publish",related_name="bookList")
authorlist=models.ManyToManyField("Author",related_name="bookList")
ad=models.models.OneToOneField("AuthorDetail"，related_name="authorInfo")
反向查询的时候都用：related_name的值

2.7.4 聚合查询：

querySet().aggregate(聚合函数)------返回的是一个字典，不再是一个querySet
Book.objects.all().aggregate(average_price=Avg('price'))

2.7.5 分组查询：

querySet().annotate()　--- 返回的是querySet
#统计每一个出版社中最便宜的书籍的价格

sql: select Min(price) from book group by publish_id;

ORM:　　models.Book.objects.values("publish__name").annotate(Min("price"))

第3章初始Ajax

3.1 Ajax准备知识：json

说起json，我们大家都了解，就是python中的json模块，那么json模块具体是什么呢？那我们现在详细的来说明一下

1、json(Javascript Obiect Notation,JS对象标记)是一种轻量级的数据交换格式。

它基于 ECMAScript (w3c制定的js规范)的一个子集，采用完全独立于编程语言的文本格式来存储和表示数据。

简洁和清晰的层次结构使得 JSON 成为理想的数据交换语言。易于人阅读和编写，同时也易于机器解析和生成，并有效地提升网络传输效率。

2、json其实是从js中拿出来的一个对象，也可以说json是js的一个子集。

需要知道的：json的格式来源于js的格式

1、js支持单引号，也支持双引号，也可以没有引号

//在js中吧{}这样的类型叫做对象，js中没有字典一说

data = {

'name':'haiyan',

"name":"haiyan",

name:"haiyan"

} //js对象默认会把自己的键当成字符串处理，所以可以加引号也可以不加

2、json的格式：

1、json只认双引号的

2、json一定是一个字符串

3、下面我们看看哪些是合格的字符串，那些不是？

合格的json对象：

["one", "two", "three"]

{ "one": 1, "two": 2, "three": 3 }

{"names": ["张三", "李四"] }

[ { "name": "张三"}, {"name": "李四"} ]

不合格的json对象：

{ name: "张三", 'age': 32 } // 属性名必须使用双引号

[32, 64, 128, 0xFFF] // 不能使用十六进制值

{ "name": "张三", "age": undefined } // 不能使用undefined

{ "name": "张三",

"birthday": new Date('Fri, 26 Aug 2011 07:13:10 GMT'),

"getName": function() {return this.name;} // 不能使用函数和日期对象

}

3.1.1 python中的序列化(dumps)与反序列化(loads)

+++++++++++++++python中的序列化(dumps)与反序列化(loads)++++++++++++++

import json

i = 10

s = "dsfdsf"

l = [11,22,33]

dic = {"name":"haiyna","age":22}

b = True

# #吧基本数据类型转换成字符串的形式

print(json.dumps(i),type(json.dumps(i))) #10 <class 'str'>

print(json.dumps(s),type(json.dumps(s))) #"dsfdsf" <class 'str'>

print(json.dumps(l),type(json.dumps(l))) #[11, 22, 33] <class 'str'>

print(json.dumps(dic),type(json.dumps(dic))) #{"name": "haiyna", "age": 22} <class 'str'>

print(json.dumps(b),type(json.dumps(b))) #true <class 'str'>

# ===============json反序列化=============

d = {"a":1,"b":"fdgfd"}

data = json.dumps(d)

print(data,type(data))

f = open("a.txt","w")

f.write(data) #注意这会写进去的字符串时双引号的格式

f.close()

# ===============json序列化=============

f = open("a.txt","r")

datat = f.read()

print(datat,type(datat)) #{"a": 1, "b": "fdgfd"} <class 'str'>

data = json.loads(datat)

print(data,type(data)) #{'a': 1, 'b': 'fdgfd'} <class 'dict'>

3.1.2 JS中的序列化(stringify)与反序列化(parse)

+++++++++++++++JS中的序列化(stringify)与反序列化(parse)++++++++++++++++++

JSON.stringify():用于将一个JavaScript对象转换为JSON字符串

JSON.parse():用于将一个JSON字符串转换为JavaScript对象

//===========js中的json序列化===========

s = '{"name":1}';

var data = JSON.parse(s);

console.log(data);

console.log(typeof data); //object

//===========js中的json的反序列化=======

s2={'name':'yuan'};

console.log(JSON.stringify(s2),typeof JSON.stringify(s2)) //string

</script>

3.2 JSON和XML的比较

1、XML也是存数据的一种格式，也是一种标记语言。它是利用节点进行查找的

2、JSON 格式于2001年由 Douglas Crockford 提出，目的就是取代繁琐笨重的 XML 格式。

JSON 格式有两个显著的优点：书写简单，一目了然；符合 JavaScript 原生语法，可以由解释引擎直接处理，不用另外添加解析代码。所以，JSON迅速被接受，已经成为各大网站交换数据的标准格式，并被写入ECMAScript 5，成为标准的一部分。

XML和JSON都使用结构化方法来标记数据，下面来做一个简单的比较。

3.2.1 用XML表示中国部分省市数据如下：

<?xml version="1.0" encoding="utf-8"?>

</cities>

</province>

</cities>

</province>

</cities>

</province>

</cities>

</province>

</country>

3.2.2 用JSON表示如下：

{

"name": "中国",

"province": [{

"name": "黑龙江",

"cities": {

"city": ["哈尔滨", "大庆"]

}

}, {

"name": "广东",

"cities": {

"city": ["广州", "深圳", "珠海"]

}

}, {

"name": "台湾",

"cities": {

"city": ["台北", "高雄"]

}

}, {

"name": "新疆",

"cities": {

"city": ["乌鲁木齐"]

}

}]

}

可以看到，JSON 简单的语法格式和清晰的层次结构明显要比 XML 容易阅读，并且在数据交换方面，由于 JSON 所使用的字符要比 XML 少得多，可以大大得节约传输数据所占用得带宽。

3.2.3 注意：

JSON格式取代了xml给网络传输带来了很大的便利,但是却没有了xml的一目了然,尤其是json数据很长的时候,我们会陷入繁琐复杂的数据节点查找中。

但是国人的一款在线工具 BeJson 、SoJson在线工具让众多程序员、新接触JSON格式的程序员更快的了解JSON的结构，更快的精确定位JSON格式错误。

3.3 Ajax简介

3.3.1 简单介绍

我们以前知道的前端向后端发送数据的方式有：

　　GET：地址栏、a标签、Form表单

　　POST：Form表单

那么现在我们在学习一种：那就是ajax

ajax：也是前端向后端发送数据的一种方式

AJAX（Asynchronous Javascript And XML）翻译成中文就是“异步Javascript和XML”。即使用Javascript语言与服务器进行异步交互，传输的数据为XML（当然，传输的数据不只是XML）。

同步交互：客户端发出一个请求后，需要等待服务器响应结束后，才能发出第二个请求；
异步交互：客户端发出一个请求后，无需等待服务器响应结束，就可以发出第二个请求。

Ajax的特点：

　　异步交互：　当请求发出后，浏览器还可以进行其他操作，无需等待服务器的响应！

　　局部刷新：整个过程中页面没有刷新，只是刷新页面中的局部位置而已！

js的局部刷新：

<!DOCTYPE html>

<head>

<title>Title</title>

<style>

.error{

color:red

}

</style>

</head>

<body>

</form>

$(".Form :submit").click(function(){

flag=true;

$("Form .v1").each(function(){

var value=$(this).val();

if (value.trim().length==0){

var mark=$(this).attr("mark");

var $span=$("<span>");

$span.html(mark+"不能为空!");

$span.prop("class","error");

$(this).after($span);

setTimeout(function(){

$span.remove();

},800);

flag=false;

return flag;

}

});

return flag

});

</script>

</body>

</html>

3.3.2 ajax的创建应用场景

当我们在百度中输入一个“老”字后，会马上出现一个下拉列表！列表中显示的是包含“老”字的4个关键字。

其实这里就使用了AJAX技术！当文件框发生了输入变化时，浏览器会使用AJAX技术向服务器发送一个请求，查询包含“老”字的前10个关键字，然后服务器会把查询到的结果响应给浏览器，最后浏览器把这4个关键字显示在下拉列表中。

整个过程中页面没有刷新，只是刷新页面中的局部位置而已！
当请求发出后，浏览器还可以进行其他操作，无需等待服务器的响应！

当输入用户名后，把光标移动到其他表单项上时，浏览器会使用AJAX技术向服务器发出请求，服务器会查询名为zhangSan的用户是否存在，最终服务器返回true表示名为lemontree7777777的用户已经存在了，浏览器在得到结果后显示“用户名已被注册！”。

整个过程中页面没有刷新，只是局部刷新了；
在请求发出后，浏览器不用等待服务器响应结果就可以进行其他操作；

3.3.3 ajax的优点，特点也就是优点

优点：

AJAX使用Javascript技术向服务器发送异步请求；

AJAX无须刷新整个页面；

因为服务器响应内容不再是整个页面，而是页面中的局部，所以AJAX性能高；

3.4 jQuery实现的ajax

3.4.1 tishi.html

<!DOCTYPE html>

<head>

<title>Title</title>

</head>

<body>

<hr>

$(".Ajax_send").click(function () {

// ajax请求

$.ajax({

url:"/tishi_ajax/", //请求路径

type:"GET", //请求方式

//吧js对象转成json字符串

data:JSON.stringify({

name:$(":text").val(),

pwd:$(":password").val()

}), // 请求数据，是js数据 ?name=yuan&pwd=123

contentType:"application/json", //告诉服务器发的是json的格式

success:function (data) {

var data=JSON.parse(data); //js中的反序列化

console.log(data);

console.log(typeof data);

// $(".error").html(data)

if(!data["flag"]){ //为False的情况

$(".login_error").html("用户名或者密码错误")

}

})

</script>

</body>

</html>

3.4.2 view

def tishi_ajax(request):

username=request.GET.get("name")

password=request.GET.get("pwd")

response={"flag":False}

if username=="yuan" and password=="123":

response["flag"]=True

import json

import time

return HttpResponse(json.dumps(response))

def tishi(request):

return render(request,"tishi.html")

{% load staticfiles %}

<!DOCTYPE html>

<head>

<title>Title</title>

</head>

<body>

//$.ajax的两种使用方式:

//$.ajax(settings);

//$.ajax(url,[settings]);

$(".send_Ajax").click(function(){

$.ajax({

url:"/handle_Ajax/",

type:"POST",

data:{username:"Yuan",password:123},

　　　　　　　　　//==================成功的时候要执行的代码==================

success:function(data){

alert(data)

//=================== error的时候要执行的代码============

error: function (jqXHR, textStatus, err) {

// jqXHR: jQuery增强的xhr

// textStatus: 请求完成状态

// err: 底层通过throw抛出的异常对象，值与错误类型有关

console.log(arguments);

//=================== complete（无论成功还是失败，都要执行的代码）============

complete: function (jqXHR, textStatus) {

// jqXHR: jQuery增强的xhr

// textStatus: 请求完成状态 success | error

console.log('statusCode: %d, statusText: %s', jqXHR.status, jqXHR.statusText);

console.log('textStatus: %s', textStatus);

//=================== statusCode============

statusCode: {

'403': function (jqXHR, textStatus, err) {

console.log(arguments); //注意：后端模拟errror方式：HttpResponse.status_code=500

'400': function () {

}

})

</script>

</body>

</html>

3.5 ajax参数

3.5.1 请求参数

######################------------data---------################

data: 当前ajax请求要携带的数据，是一个json的object对象，ajax方法就会默认地把它编码成某种格式

(urlencoded:?a=1&b=2)发送给服务端；此外，ajax默认以get方式发送请求。

function testData() {

$.ajax("/test",{ //此时的data是一个json形式的对象

data:{

a:1,

b:2

}

}); //?a=1&b=2

######################------------processData---------################

processData：声明当前的data数据是否进行转码或预处理，默认为true，即预处理；if为false，

那么对data：{a:1,b:2}会调用json对象的toString()方法，即{a:1,b:2}.toString()

,最后得到一个［object，Object］形式的结果。

######################------------contentType---------################

contentType：默认值: "application/x-www-form-urlencoded"。发送信息至服务器时内容编码类型。

用来指明当前请求的数据编码格式；urlencoded:?a=1&b=2；如果想以其他方式提交数据，

比如contentType:"application/json"，即向服务器发送一个json字符串：

$.ajax("/ajax_get",{

data:JSON.stringify({

a:22,

b:33

}),

contentType:"application/json",

type:"POST",

}); //{a: 22, b: 33}

注意：contentType:"application/json"一旦设定，data必须是json字符串，不能是json对象

######################------------traditional---------################

traditional：一般是我们的data数据有数组时会用到：data:{a:22,b:33,c:["x","y"]},

traditional为false会对数据进行深层次迭代；

3.5.2 响应参数

dataType：预期服务器返回的数据类型,服务器端返回的数据会根据这个值解析后，传递给回调函数。

默认不需要显性指定这个属性，ajax会根据服务器返回的content Type来进行转换；

比如我们的服务器响应的content Type为json格式，这时ajax方法就会对响应的内容

进行一个json格式的转换，if转换成功，我们在success的回调函数里就会得到一个json格式

的对象；转换失败就会触发error这个回调函数。如果我们明确地指定目标类型，就可以使用

data Type。

dataType的可用值：html｜xml｜json｜text｜script

见下dataType实例

3.5.3 示例：

from django.shortcuts import render,HttpResponse

from django.views.decorators.csrf import csrf_exempt

# Create your views here.

import json

def login(request):

return render(request,'Ajax.html')

def ajax_get(request):

l=['alex','little alex']

dic={"name":"alex","pwd":123}

#return HttpResponse(l) #元素直接转成字符串alexlittle alex

#return HttpResponse(dic) #字典的键直接转成字符串namepwd

return HttpResponse(json.dumps(l))

return HttpResponse(json.dumps(dic))# 传到前端的是json字符串,要想使用,需要JSON.parse(data)

//---------------------------------------------------

function testData() {

$.ajax('ajax_get', {

success: function (data) {

console.log(data);

console.log(typeof(data));

//console.log(data.name);

//JSON.parse(data);

//console.log(data.name);

//dataType:"json",

}

)}

注解:Response Headers的content Type为text/html,所以返回的是String;但如果我们想要一个json对象

设定dataType:"json"即可,相当于告诉ajax方法把服务器返回的数据转成json对象发送到前端.结果为object

当然，

return HttpResponse(json.dumps(a),content_type="application/json")

这样就不需要设定dataType:"json"了。

content_type="application/json"和content_type="json"是一样的！

第4章 ajax补充--------FormData等

4.1 回顾上节知识点

4.1.1 什么是json字符串？

轻量级的数据交换格式

4.1.2 定时器：关于setTimeout

setTimeout(foo,3000) # 3000表示3秒，foo表示一个函数，3秒后执行foo函数

<!DOCTYPE html>

<head>

<title>Title</title>

<style>

.login_error{

color: red;

}

</style>

</head>

<body>

<hr>

{% csrf_token %}

$(".Ajax_send").click(function () {

function foo() {

$(".login_error").html(""); //3秒后清空

}

//方式一

$.ajaxSetup({

data:{csrfmiddlewaretoken:'{{ csrf_token }}'}

});

// ajax请求

$.ajax({

url:"/get_ajax/", //请求路径

type:"POST", //请求方式

//吧js对象转成json字符串

data:{

{# 方式三#}

{# csrfmiddlewaretoken:$("[name='csrfmiddlewaretoken']").val(),#}

name:$(":text").val(),

pwd:$(":password").val()

success:function (data) {

var data=JSON.parse(data); //js中的反序列化

console.log(data);

console.log(typeof data);

if(!data["flag"]){ //为False的情况

$(".login_error").html("用户名或者密码错误");

setTimeout(foo,3000)

}

})

</script>

</body>

</html>

4.1.3 ajax的参数补充

- type不写的话默认是GET

　　- dataType和ContentType：

　　　　dataType: 浏览器发给服务器希望返回的数据类型。。如果我们明确地指定目标类型，就可以使用data Type。

　　　　ContentType:
　　　　　　请求头里有：浏览器告诉服务器内容的类型
　　　　　　响应头里也有：服务器响应浏览器的内容

4.1.4 JS和JQuery对象之间的转换

jQuery对象加[0]就转换成了dom对象

dom对象加$符就转换成了jquery对象

4.1.5 processDate 默认为True ，预处理；如果改为False，不做预处理

4.2 csrf跨站请求伪造

如果把type:"GET" 改为type:"POST" 会报一个Forbidden的错

解决办法有三种：

4.2.1 方式一：

$.ajaxSetup({

data:{csrfmiddlewaretoken:'{{ csrf_token }}'}

});

注意：要放在ajax请求的前面，在发送之前组装一组字符串，在第一步render的时候就发了

所以有局限性：

如果把JS代码放到静态文件中，不会渲染，不会执行{{csrf_token}},只能在HTML页面中使用

4.2.2 方式二：自己组装一组键值对（推荐）

<form>
{% csrf_token %}
</form>

data:{

csrfmiddlewaretoken:$("[name='csrfmiddlewaretoken']").val(),

name:$(":text").val(),

pwd:$(":password").val()

4.2.3 方式三：自己设置头信息

$.ajax({

url:"/serialize/",

type:"POST",

headers:{"X-CSRFToken":$.cookie('csrftoken')},

})

4.3 jQuery.serialize()

4.3.1 介绍

serialize()函数用于序列化一组表单元素，将表单内容编码为用于提交的字符串。

serialize()函数常用于将表单内容序列化，以便用于AJAX提交。

该函数主要根据用于提交的有效表单控件的name和value，将它们拼接为一个可直接用于表单提交的文本字符串，该字符串已经过标准的URL编码处理(字符集编码为UTF-8)。

该函数不会序列化不需要提交的表单控件，这和常规的表单提交行为是一致的。例如：不在<form>标签内的表单控件不会被提交、没有name属性的表单控件不会被提交、带有disabled属性的表单控件不会被提交、没有被选中的表单控件不会被提交。

与常规表单提交不一样的是：常规表单一般会提交带有name的按钮控件，而serialize()函数不会序列化带有name的按钮控件。更多详情请点击这里。

语法：

jQueryObject.serialize( )

serialize()函数的返回值为String类型，返回将表单元素编码后的可用于表单提交的文本字符串。

请参考下面这段初始HTML代码：

</select>

<input name="sex" type="radio" checked="checked" value="1" />男

<input name="sex" type="radio" value="0" />女

<input name="hobby" type="checkbox" checked="checked" value="1" />游泳

<input name="hobby" type="checkbox" checked="checked" value="2" />跑步

<input name="hobby" type="checkbox" value="3" />羽毛球

</form>

对<form>元素进行序列化可以直接序列化其内部的所有表单元素。

// 序列化<form>内的所有表单元素

// 序列化后的结果：uid=1&username=%E5%BC%A0%E4%B8%89&password=123456&grade=3&sex=1&hobby=1&hobby=2

alert( $("form").serialize() );

我们也可以直接对部分表单元素进行序列化。

// 序列化所有的text、select、checkbox表单元素

// 序列化后的结果：username=%E5%BC%A0%E4%B8%89&password=123456&grade=3&hobby=1&hobby=2

alert( $(":text, select, :checkbox").serialize() );

4.3.2 示例：

##############################serialize.html#######################################

<!DOCTYPE html>

<head>

<title>Title</title>

</head>

<body>

</select>

<input name="sex" type="radio" checked="checked" value="1" />男

<input name="sex" type="radio" value="0" />女

<input name="hobby" type="checkbox" checked="checked" value="1" />游泳

<input name="hobby" type="checkbox" checked="checked" value="2" />跑步

<input name="hobby" type="checkbox" value="3" />羽毛球

</form>

$("#btn").click(function () {

{# 方式一#}

//$.ajaxSetup({

// data:{csrfmiddlewaretoken:'{{ csrf_token }}'}

//});

$.ajax({

url:"/serialize/",

type:"POST",

{# 方式三#}

headers:{"X-CSRFToken":$.cookie('csrftoken')},

//data:$("form").serialize(), //序列form表单所有的

data:$(":text,:password,:checkbox").serialize(), //序列自己选择的

success:function (data) {

var data=JSON.parse(data); //js中的反序列化

console.log(data);

console.log(typeof data);

$(".error").html(data);

}

})

</script>

</body>

</html>

###############################views.py##################################

def serialize(request):

# form = request.POST

# print(form)

name = request.POST.get("username")

password = request.POST.get("password")

checked = request.POST.getlist("hobby")

print(name,password,checked)

return HttpResponse(json.dumps(name))

当有好多input的时候，就得一一对应的吧所有的数据发过去的，这样显得麻烦，我们用序列化

jQuery.serialize()

data:$("form").serialize(), //序列form表单所有的

data:$(":text,:password,:checkbox").serialize(), //序列自己选择的

在服务端获取数据

form = request.POST

print(form) #获取所有

name = request.POST.get("username")

password = request.POST.get("password")

checked = request.POST.getlist("hobby")

print(name,password,checked)#获取单个

4.4 上传文件

4.4.1 Form表单上传文件

文件和其他的数据类型不一样，是一个二进制的形式
Form上传文件的时候切记要加上：enctype="multipart/form-data"

formupload.html

{% csrf_token %}

</form>

view.py

def formupload(request):

if request.method == "POST":

username = request.POST.get("username")

password = request.POST.get("password")

# file = request.FILES #拿到的是一个句柄

file_obj = request.FILES.get("file")

print(file_obj,file_obj.name)

print(type(file_obj),type(file_obj.name)) #<class 'django.core.files.uploadedfile.InMemoryUploadedFile'> <class 'str'>

with open(file_obj.name,"wb") as f:

for i in file_obj:

f.write(i)

return HttpResponse("上传成功...")

return render(request,"formupload.html")

4.4.2 Ajax上传文件（利用FormData）

Ajax上传文件（利用FormData）：既可以处理二进制，又可以处理字典，列表啊等

FormData是什么呢？

XMLHttpRequest Level 2添加了一个新的接口FormData.利用FormData对象,我们可以通过JavaScript用一些键值对来模拟一系列表单控件,我们还可以使用XMLHttpRequest的send()方法来异步的提交这个"表单".比起普通的ajax,使用FormData的最大优点就是我们可以异步上传一个二进制文件.

所有主流浏览器的较新版本都已经支持这个对象了，比如Chrome 7+、Firefox 4+、IE 10+、Opera 12+、Safari 5+。

注意：下文中的几个需要解释的

$("#upload") 拿到的是一个集合

$("#upload")[0] 就是一个dom对象

$("#upload")[0].files 拿到的是一个filelist

$("#upload")[0].files[0] 拿到的是当前最近的文件对象

要是使用FormData一定要加上：

一定要加上：

　　contentType：false
　　processDate：false #不做预处理

ajaxupload.html

<!DOCTYPE html>

<head>

<title>Title</title>

</head>

<body>

$(".btnnn").click(function () {

var formData=new FormData();

formData.append("username",$(":text").val());

formData.append("file",$("#upload")[0].files[0]);

$.ajax({

url:"/get_upload/",

type:"POST",

headers:{"X-CSRFToken":$.cookie('csrftoken')},

data:formData,

contentType:false,

processData:false,

success:function (data) {

$(".tishi").html("上传成功")

}

})

</script>

</body>

</html>

view.py

def ajaxupload(request):

return render(request,"ajaxupload.html")

def get_upload(request):

if request.method == "POST":

print("FIFLE", request.FILES)

file_obj = request.FILES.get("file")

print(file_obj.name, "-----")

file_obj = request.FILES.get("file")

with open(file_obj.name, "wb") as f:

for i in file_obj:

f.write(i)

return HttpResponse("上传成功")

第5章 cookie和session

5.1 HTTP协议详细介绍

5.1.1 HTTP简介

HTTP协议是Hyper Text Transfer Protocol（超文本传输协议）的缩写,是用于从万维网（WWW:World Wide Web ）服务器传输超文本到本地浏览器的传送协议。

HTTP是一个基于TCP/IP通信协议来传递数据（HTML 文件, 图片文件, 查询结果等）。

HTTP是一个属于应用层的面向对象的协议，由于其简捷、快速的方式，适用于分布式超媒体信息系统。它于1990年提出，经过几年的使用与发展，得到不断地完善和扩展。目前在WWW中使用的是HTTP/1.0的第六版，HTTP/1.1的规范化工作正在进行之中，而且HTTP-NG(Next Generation of HTTP)的建议已经提出。

HTTP协议工作于客户端-服务端架构为上。浏览器作为HTTP客户端通过URL向HTTP服务端即WEB服务器发送所有请求。Web服务器根据接收到的请求后，向客户端发送响应信息。

5.1.2 HTTP特点

1、简单快速：客户向服务器请求服务时，只需传送请求方法和路径。请求方法常用的有GET、HEAD、POST。每种方法规定了客户与服务器联系的类型不同。由于HTTP协议简单，使得HTTP服务器的程序规模小，因而通信速度很快。

2、灵活：HTTP允许传输任意类型的数据对象。正在传输的类型由Content-Type加以标记。

3.无连接：无连接的含义是限制每次连接只处理一个请求。服务器处理完客户的请求，并收到客户的应答后，即断开连接。采用这种方式可以节省传输时间。

4.无状态：HTTP协议是无状态协议。无状态是指协议对于事务处理没有记忆能力。缺少状态意味着如果后续处理需要前面的信息，则它必须重传，这样可能导致每次连接传送的数据量增大。另一方面，在服务器不需要先前信息时它的应答就较快。

5.2 HTTP请求协议

请求协议遵照以下格式：

请求首行； // 请求方式请求路径协议和版本，例如：GET /index.html HTTP/1.1

请求头信息； // 请求头名称:请求头内容，即为key:value格式，例如：Host:localhost

空行； // 用来与请求体分隔开

请求体。 // GET没有请求体，只有POST有请求体。

浏览器发送给服务器的内容就这个格式的，如果不是这个格式服务器将无法解读！在HTTP协议中，请求有很多请求方法，其中最为常用的就是GET和POST。

5.2.1 get请求

GET /562f25980001b1b106000338.jpg HTTP/1.1

Host img.mukewang.com

User-Agent Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/51.0.2704.106 Safari/537.36

Accept image/webp,image/*,*/*;q=0.8

Referer http://www.imooc.com/

Accept-Encoding gzip, deflate, sdch

Accept-Language zh-CN,zh;q=0.8

HTTP默认的请求方法就是GET
* 没有请求体
* 数据量有限制！
* GET请求数据会暴露在浏览器的地址栏中

GET请求常用的操作：
1. 在浏览器的地址栏中直接给出URL，那么就一定是GET请求
2. 点击页面上的超链接也一定是GET请求
3. 提交表单时，表单默认使用GET请求，但可以设置为POST

请求头：

1、Host

请求的web服务器域名地址

2、User-Agent

HTTP客户端运行的浏览器类型的详细信息。通过该头部信息，web服务器可以判断出http请求的客户端的浏览器的类型。

3、Accept

指定客户端能够接收的内容类型，内容类型的先后次序表示客户都接收的先后次序

4、Accept-Lanuage

指定HTTP客户端浏览器用来展示返回信息优先选择的语言

5、Accept-Encoding

指定客户端浏览器可以支持的web服务器返回内容压缩编码类型。表示允许服务器在将输出内容发送到客户端以前进行压缩，以节约带宽。
而这里设置的就是客户端浏览器所能够支持的返回压缩格式。

6、Accept-Charset

HTTP客户端浏览器可以接受的字符编码集

7、Content-Type

显示此HTTP请求提交的内容类型。一般只有post提交时才需要设置该属性

有关Content-Type属性值有如下两种编码类型：

（1）“application/x-www-form-urlencoded”：表单数据向服务器提交时所采用的编码类型，默认的缺省值就是“application/x-www-form-urlencoded”。
然而，在向服务器发送大量的文本、包含非ASCII字符的文本或二进制数据时这种编码方式效率很低。

（2）“multipart/form-data”：在文件上载时，所使用的编码类型应当是“multipart/form-data”，它既可以发送文本数据，也支持二进制数据上载。

当提交为表单数据时，可以使用“application/x-www-form-urlencoded”；当提交的是文件时，就需要使用“multipart/form-data”编码类型。

8、Keep-Alive

表示是否需要持久连接。如果web服务器端看到这里的值为“Keep-Alive”，或者看到请求使用的是HTTP 1.1（HTTP 1.1默认进行持久连接），它就可以利用持久连接的优点

5.2.2 post请求

POST / HTTP1.1

Host:www.wrox.com

User-Agent:Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; SV1; .NET CLR 2.0.50727; .NET CLR 3.0.04506.648; .NET CLR 3.5.21022)

Content-Type:application/x-www-form-urlencoded

Content-Length:40

Connection: Keep-Alive

name=Professional%20Ajax&publisher=Wiley

第一部分：请求行，第一行明了是post请求，以及http1.1版本。
第二部分：请求头部，第二行至第六行。
第三部分：空行，第七行的空行。
第四部分：请求数据，第八行。

5.3 HTTP响应协议

5.3.1 响应格式

一般情况下，服务器接收并处理客户端发过来的请求后会返回一个HTTP的响应消息。

HTTP响应也由四个部分组成，分别是：状态行、消息报头、空行和响应正文。

http响应消息格式.jpg

5.3.2 例子

HTTP/1.1 200 OK

Date: Fri, 22 May 2009 06:07:21 GMT

Content-Type: text/html; charset=UTF-8

<html>

<body>

</body>

</html>

第一部分：状态行，由HTTP协议版本号， 状态码， 状态消息 三部分组成。

第一行为状态行，（HTTP/1.1）表明HTTP版本为1.1版本，状态码为200，状态消息为（ok）

第二部分：消息报头，用来说明客户端要使用的一些附加信息

第二行和第三行为消息报头，

Date:生成响应的日期和时间；Content-Type:指定了MIME类型的HTML(text/html),编码类型是UTF-8

第三部分：空行，消息报头后面的空行是必须的

第四部分：响应正文，服务器返回给客户端的文本信息。

空行后面的html部分为响应正文。

5.3.3 响应状态码

状态代码有三位数字组成，第一个数字定义了响应的类别，共分五种类别:

1xx：指示信息--表示请求已接收，继续处理

2xx：成功--表示请求已被成功接收、理解、接受

3xx：重定向--要完成请求必须进行更进一步的操作

4xx：客户端错误--请求有语法错误或请求无法实现

5xx：服务器端错误--服务器未能实现合法的请求

常见状态码：

200 OK //客户端请求成功

400 Bad Request //客户端请求有语法错误，不能被服务器所理解

401 Unauthorized //请求未经授权，这个状态代码必须和WWW-Authenticate报头域一起使用

403 Forbidden //服务器收到请求，但是拒绝提供服务

404 Not Found //请求资源不存在，eg：输入了错误的URL

500 Internal Server Error //服务器发生不可预期的错误

503 Server Unavailable //服务器当前不能处理客户端的请求，一段时间后可能恢复正常

5.4 GET和POST请求的区别

GET请求

GET /books/?sex=man&name=Professional HTTP/1.1

Host: www.wrox.com

User-Agent: Mozilla/5.0 (Windows; U; Windows NT 5.1; en-US; rv:1.7.6)

Gecko/20050225 Firefox/1.0.1

Connection: Keep-Alive

注意最后一行是空行

POST请求

POST / HTTP/1.1

Host: www.wrox.com

User-Agent: Mozilla/5.0 (Windows; U; Windows NT 5.1; en-US; rv:1.7.6)

Gecko/20050225 Firefox/1.0.1

Content-Type: application/x-www-form-urlencoded

Content-Length: 40

Connection: Keep-Alive

name=Professional%20Ajax&publisher=Wiley

1、GET提交，请求的数据会附在URL之后（就是把数据放置在HTTP协议头中），以?分割URL和传输数据，多个参数用&连接；例如：login.action?name=hyddd&password=idontknow&verify=%E4%BD%A0 %E5%A5%BD。如果数据是英文字母/数字，原样发送，如果是空格，转换为+，如果是中文/其他字符，则直接把字符串用BASE64加密，得出如： %E4%BD%A0%E5%A5%BD，其中％XX中的XX为该符号以16进制表示的ASCII。

POST提交：把提交的数据放置在是HTTP包的包体中。上文示例中红色字体标明的就是实际的传输数据

因此，GET提交的数据会在地址栏中显示出来，而POST提交，地址栏不会改变

2、传输数据的大小：首先声明：HTTP协议没有对传输的数据大小进行限制，HTTP协议规范也没有对URL长度进行限制。

而在实际开发中存在的限制主要有：

GET:特定浏览器和服务器对URL长度有限制，例如 IE对URL长度的限制是2083字节(2K+35)。对于其他浏览器，如Netscape、FireFox等，理论上没有长度限制，其限制取决于操作系统的支持。

因此对于GET提交时，传输数据就会受到URL长度的限制。

POST:由于不是通过URL传值，理论上数据不受限。但实际各个WEB服务器会规定对post提交数据大小进行限制，Apache、IIS6都有各自的配置。

GET和POST的区别：

1、 GET提交的数据会放在URL之后，以?分割URL和传输数据，参数之间以&相连，如EditPosts.aspx?name=test1&id=123456. POST方法是把提交的数据放在HTTP包的Body中.

2、 GET提交的数据大小有限制（因为浏览器对URL的长度有限制），而POST方法提交的数据没有限制.

3、 GET方式需要使用Request.QueryString来取得变量的值，而POST方式通过Request.Form来获取变量的值。

4、 GET方式提交数据，会带来安全问题，比如一个登录页面，通过GET方式提交数据时，用户名和密码将出现在URL上，如果页面可以被缓存或者其他人可以访问这台机器，就可以从历史记录获得该用户的账号和密码.

5.5 web应用与web框架

5.5.1 web应用

对于所有的Web应用，本质上其实就是一个socket服务端，用户的浏览器其实就是一个socket客户端。

import socket

def handle_request(client):

buf = client.recv(1024)

client.send("HTTP/1.1 200 OK\r\n\r\n".encode("utf8"))

client.send("<h1 style='color:red'>Hello, yuan</h1>".encode("utf8"))

def main():

sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

sock.bind(('localhost',8001))

sock.listen(5)

while True:

connection, address = sock.accept()

handle_request(connection)

connection.close()

if __name__ == '__main__':

main()

最简单的Web应用就是先把HTML用文件保存好，用一个现成的HTTP服务器软件，接收用户请求，从文件中读取HTML，返回。

如果要动态生成HTML，就需要把上述步骤自己来实现。不过，接受HTTP请求、解析HTTP请求、发送HTTP响应都是苦力活，如果我们自己来写这些底层代码，还没开始写动态HTML呢，就得花个把月去读HTTP规范。

正确的做法是底层代码由专门的服务器软件实现，我们用Python专注于生成HTML文档。因为我们不希望接触到TCP连接、HTTP原始请求和响应格式，所以，需要一个统一的接口，让我们专心用Python编写Web业务。

这个接口就是WSGI：Web Server Gateway Interface。

5.5.2 wsgiref

from wsgiref.simple_server import make_server

def application(environ, start_response):

start_response('200 OK', [('Content-Type', 'text/html')])

return [b'<h1>Hello, web!</h1>']

httpd = make_server('', 8080, application)

print('Serving HTTP on port 8000...')

# 开始监听HTTP请求:

httpd.serve_forever()

5.6 DIY一个自己的web框架

5.6.1 manage.py

from wsgiref.simple_server import make_server

# request response

from app01.views import *

from app01 import urls

def routers():

URLpattern=urls.URLpattern

return URLpattern

def applications(environ,start_response):

path=environ.get("PATH_INFO")

print("path",path)

start_response('200 OK', [('Content-Type', 'text/html'),('Charset', 'utf8')])

urlpattern=routers()

func=None

for item in urlpattern:

if path==item[0]:

func=item[1]

break

if func:

return [func(environ)]

else:

return [b"<h1>404!<h1>"]

# return [b"<h1>hello world<h1>"]

if __name__ == '__main__':

t=make_server("",8810,applications)

print("server is working...")

t.serve_forever()

5.6.2 urls

from app01.views import *

URLpattern = (

("/login/", login),

)

5.6.3 views

import pymysql

from urllib.parse import parse_qs

def login(request):

if request.get("REQUEST_METHOD")=="POST":

print("+++++",request)

#当请求方式是GET时

# user_union,pwd_union=request.get("QUERY_STRING").split("&")

# _,user=user_union.split("=")

# _,pwd=pwd_union.split("=")

# 环境变量 CONTENT_LENGTH 可能是空值或者值丢失

try:

request_body_size = int(request.get('CONTENT_LENGTH', 0))

except (ValueError):

request_body_size = 0

# 当请求方式是POST时, 变量将会被放在存在域wsgi.input文件中的HTTP请求信息中, 由WSGI 服务器一起发送.

request_body = request['wsgi.input'].read(request_body_size)

d = parse_qs(request_body)

user=d.get(b"user")[0].decode("utf8")

pwd=d.get(b"pwd")[0].decode("utf8")

print("user",user,pwd)

#连接数据库

conn = pymysql.connect(host='',port= 3306,user = 'root',passwd='',db='s6') #db：库名

#创建游标

cur = conn.cursor()

SQL="select * from userinfo2 WHERE NAME ='%s' AND PASSWORD ='%s'"%(user,pwd)

cur.execute(SQL)

if cur.fetchone():

f=open("templates/backend.html","rb")

data=f.read()

data=(data.decode("utf8"))%user

return data.encode("utf8")

else:

return b"user or pwd is wrong"

else:

f = open("templates/login.html", "rb")

data = f.read()

f.close()

return data

5.6.4 models

import pymysql

#连接数据库

conn = pymysql.connect(host='',port= 3306,user = 'root',passwd='',db='s6') #db：库名

#创建游标

cur = conn.cursor()

# sql='''

# create table userinfo2(

# id INT PRIMARY KEY ,

# name VARCHAR(32) ,

# password VARCHAR(32)

# )

# '''

# cur.execute(sql)

# cur.executemany("insert into userinfo2 values(%s,%s,%s)", [(1,"yuan","123"),

# (2,"alex","456"),

# (3,"egon","789")])

cur.execute("select * from userinfo2 WHERE NAME='yuan' AND PASSWORD ='123'")

#提交

conn.commit()

#关闭指针对象

cur.close()

#关闭连接对象

conn.close()

5.7 cookie和session的介绍

cookie不属于http协议范围，由于http协议无法保持状态，但实际情况，我们却又需要“保持状态”，因此cookie就是在这样一个场景下诞生。

cookie的工作原理是：由服务器产生内容，浏览器收到请求后保存在本地；当浏览器再次访问时，浏览器会自动带上cookie，这样服务器就能通过cookie的内容来判断这个是“谁”了。

cookie虽然在一定程度上解决了“保持状态”的需求，但是由于cookie本身最大支持4096字节，以及cookie本身保存在客户端，可能被拦截或窃取，因此就需要有一种新的东西，它能支持更多的字节，并且他保存在服务器，有较高的安全性。这就是session。

问题来了，基于http协议的无状态特征，服务器根本就不知道访问者是“谁”。那么上述的cookie就起到桥接的作用。

我们可以给每个客户端的cookie分配一个唯一的id，这样用户在访问时，通过cookie，服务器就知道来的人是“谁”。然后我们再根据不同的cookie的id，在服务器上保存一段时间的私密资料，如“账号密码”等等。

总结而言：cookie弥补了http无状态的不足，让服务器知道来的人是“谁”；但是cookie以文本的形式保存在本地，自身安全性较差；所以我们就通过cookie识别不同的用户，对应的在session里保存私密的信息以及超过4096字节的文本。

另外，上述所说的cookie和session其实是共通性的东西，不限于语言和框架

5.8 登录应用原理

前几节的介绍中我们已经有能力制作一个登陆页面，在验证了用户名和密码的正确性后跳转到后台的页面。但是测试后也发现，如果绕过登陆页面。直接输入后台的url地址也可以直接访问的。这个显然是不合理的。其实我们缺失的就是cookie和session配合的验证。有了这个验证过程，我们就可以实现和其他网站一样必须登录才能进入后台页面了。

先说一下这种认证的机制。每当我们使用一款浏览器访问一个登陆页面的时候，一旦我们通过了认证。服务器端就会发送一组随机唯一的字符串（假设是123abc）到浏览器端，这个被存储在浏览端的东西就叫cookie。而服务器端也会自己存储一下用户当前的状态，比如login=true，username=hahaha之类的用户信息。但是这种存储是以字典形式存储的，字典的唯一key就是刚才发给用户的唯一的cookie值。那么如果在服务器端查看session信息的话，理论上就会看到如下样子的字典

{'123abc':{'login':true,'username:hahaha'}}

因为每个cookie都是唯一的，所以我们在电脑上换个浏览器再登陆同一个网站也需要再次验证。那么为什么说我们只是理论上看到这样子的字典呢？因为处于安全性的考虑，其实对于上面那个大字典不光key值123abc是被加密的，value值{'login':true,'username:hahaha'}在服务器端也是一样被加密的。所以我们服务器上就算打开session信息看到的也是类似与以下样子的东西

{'123abc':dasdasdasd1231231da1231231}

5.9 cookie的简单使用

5.9.1 获取Cookie

request.COOKIES.get("islogin",None) #如果有就获取，没有就默认为none

5.9.2 设置Cookie

obj = redirect("/index/")

obj.set_cookie("islogin",True) #设置cookie值，注意这里的参数，一个是键，一个是值

obj.set_cookie("haiyan","344",20) #20代表过期时间

obj.set_cookie("username", username)

5.9.3 删除Cookie

obj.delete_cookie("cookie_key",path="/",domain=name)

5.10 登录认证示例：

需要知道几点

一共有三次请求
　　注意：form表单的action走的路径还是/login/
　　　　　第一次请求：url:http://127.0.0.1:8080/login get请求
　　　　第一次请求：url:http://127.0.0.1:8080/login post请求 user pasw
　　　　第一次请求：url:http://127.0.0.1:8080/index post请求携带着cookie的了
　　　　所以在index页面中就会取到cookie,因为这是的index里面已经有cookie了

5.10.1 urls.py

from app01 import views

urlpatterns = [

url(r'^admin/', admin.site.urls),

url(r'^login/', views.login),

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

]

5.10.2 views.py

from django.shortcuts import render,redirect,HttpResponse

from app01 import models

# Create your views here.

def login(request):

if request.method=="POST":

print("所有请求数据",request.POST)

username = request.POST.get("username")

password = request.POST.get("password")

# 查看数据库中的用户名和密码，对比用户输入的是否是数据库中的值

ret = models.UserInfo.objects.filter(username=username,password=password)

if ret: #如果用户名和密码都正确，则登录成功

print(request.COOKIES) #{'csrftoken': '1EaTcdQlxdwtR0eXu4uDqEHElEpOlDRJoSAd7TfA7cBDxAyxADVPbIKaZk6J0DVB'}

# 由于http协议是无状态的，你这次登录完就不知道是谁登录了，当别人知道你的主页url,就都可以登录了。那样就没有隐私了

# 这就得用到cookie了

obj = redirect("/index/")

obj.set_cookie("islogin",True) #设置cookie值，注意这里的参数，一个是键，一个是值

obj.set_cookie("haiyan","344",20) #20代表过期时间

obj.set_cookie("username", username)

return obj

else:

return render(request,"login.html")

else:

return render(request,"login.html")

def index(request):

is_login = request.COOKIES.get("islogin",None) #得到cookie,有就得到，没有就得到none

if is_login:

username = request.COOKIES.get("username")

print(username)

return render(request,"index.html",{"username":username})

else: #如果没有拿到值，就一直在登录页面就进不去

return redirect("/login/")

5.10.3 models.py

class UserInfo(models.Model):

username =models.CharField(max_length=32)

password =models.CharField(max_length=32)

5.10.4 login.html

<!DOCTYPE html>

<head>

<style>

.c1{

margin-top: 100px;

}

.btn{

width: 130px;

}

.c2{

margin-left: 40px;

}

</style>

</head>

<body>

{% csrf_token %}

</div>

<input type="password" class="form-control" name="password" id="password"

placeholder="Password">

</div>

</div>

</form>

</div>

</body>

</html>

5.10.5 index.html

<!DOCTYPE html>

<head>

<title>Title</title>

</head>

<body>

<h1>hello{{ username }}</h1>

</body>

</html>

5.10.6 cookie存储到客户端优缺点

优点：数据存储在客户端。减轻服务端的压力，提高网站的性能

缺点：安全性不高，在客户端很容易被查看或破解用户会话信息

5.11 session的简单使用

5.11.1 基本操作(需要掌握的)

1、设置session值

　　　　request.session["session_name"]="admin"

2、获取session值

　　　　session_name = request.session("session_name")

3、删除session值

　　　　del request.session["session_name"] 删除一组键值对

　　　　request.session.flush() 删除一条记录

4、检测是否操作session值

　　　　if "session_name" is request.session:

其他操作

5、get(key, default=None)

fav_color = request.session.get('fav_color', 'red')

6、pop(key)

fav_color = request.session.pop('fav_color')

7、keys()

8、items()

9、setdefault()

10、flush() 删除当前的会话数据并删除会话的Cookie。

这用于确保前面的会话数据不可以再次被用户的浏览器访问

例如，django.contrib.auth.logout() 函数中就会调用它。

11 用户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失效策略。

5.11.2 流程解析图

由于cookie会把所有的信息都保存在客户端，也就是浏览器上，这样会导致不安全，所以引用了session，但是只是单单的session也不好用，必须session和cookie配合这去用。

session会把信息保存在服务端。

session原理分析流程：

{"sessionID":"dfhasdjfhkjlcn4352kjdsfhkjsd"}

if post:

　　request.session["is_login"]=True

　　request.session["user"]=username

　　return redirect("/index/”)

Django会做三件事：

　　1、创建随机字符串。假如s="sdgsdfg4565dfgsdfgsdf"

　　2、在django-session表中，添加一条记录

　　　　django-session有三个字段，分别是：session_key，session_data，expire_data

　　　 SQL: 语句： insert into django-session values (s,"{"IS_LOGON":True,"USER":egon}",12321)

　　3、给浏览器设置sessionID： obj.set_cookie("sessionID",s)

执行完之后重定向：

/home/ ----> {"sessionID":"fasdlkfjsakdl324ada2adhdjlka99"}

request.session.get("IS_LOGON",None)

在django-session表中，进行查询：

s=requset.COOKIE.get("sessionID")
select session-data from django-session where session-key=s

5.11.3 示例

views.py

def log_in(request):

if request.method=="POST":

username=request.POST['user']

password=request.POST['pwd']

user=UserInfo.objects.filter(username=username,password=password)

if user:

#设置session内部的字典内容

request.session['is_login']='true'

request.session['username']=username

#登录成功就将url重定向到后台的url

return redirect('/backend/')

#登录不成功或第一访问就停留在登录页面

return render(request,'login.html')

def backend(request):

print(request.session,"------cookie")

print(request.COOKIES,'-------session')

"""

这里必须用读取字典的get()方法把is_login的value缺省设置为False，

当用户访问backend这个url先尝试获取这个浏览器对应的session中的

is_login的值。如果对方登录成功的话，在login里就已经把is_login

的值修改为了True,反之这个值就是False的

"""

is_login=request.session.get('is_login',False)

#如果为真，就说明用户是正常登陆的

if is_login:

#获取字典的内容并传入页面文件

cookie_content=request.COOKIES

session_content=request.session

username=request.session['username']

return render(request,'backend.html',locals())

else:

"""

如果访问的时候没有携带正确的session，

就直接被重定向url回login页面

"""

return redirect('/login/')

def log_out(request):

"""

直接通过request.session['is_login']回去返回的时候，

如果is_login对应的value值不存在会导致程序异常。所以

需要做异常处理

"""

try:

#删除is_login对应的value值

del request.session['is_login']

# OR---->request.session.flush() # 删除django-session表中的对应一行记录

except KeyError:

pass

#点击注销之后，直接重定向回登录页面

return redirect('/login/')

template

===================================login.html==================

<!DOCTYPE html>

<head>

<title>Title</title>

</head>

<body>

</form>

</body>

</html>

===================================backend.html==================

<!DOCTYPE html>

<head>

<title>Title</title>

</head>

<body>

<h3>hello {{ username }}</h3>

</body>

</html>

5.11.4 session存储的相关配置

(1)默认的是数据库配置：

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，默认修改之后才保存（默认）

（2）缓存配置

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，默认修改之后才保存

（3）文件配置

a. 配置 settings.py

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

SESSION_FILE_PATH = None # 缓存文件路径，如果为None，则使用tempfile模块获取一个临时地址tempfile.gettempdir()

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，默认修改之后才保存

day17-python项目Django之跨表查询及Ajax、cookie和session

第1章 课堂笔记

第2章 Django之ORM跨表操作（聚合查询，分组查询，F和Q查询等）

2.1 创建表

2.2 添加记录

2.2.1 一对多添加记录：

2.2.2 多对多添加记录：

2.2.3 解除绑定

2.2.4 清除绑定

2.2.5 总结：remove和clear的区别

2.3 基于对象的查询记录（相当于sql语句的where子查询）

2.3.1 一对一查询记录

2.3.2 一对多查询记录：

2.3.3 多对多查询记录：

2.4 基于双下划线的跨表查询

2.4.1 一对多查询：

2.4.2 多对多查询：

2.5 聚合查询与分组查询（很重要！！！）

2.5.1 聚合查询

2.5.2 分组查询

2.6 F查询和Q查询

2.6.1 F查询

2.6.2 Q查询

2.7 关于查询知识点总结

2.7.1 创建表

2.7.2 基于对象关联查询：

2.7.3 基于双下滑线的跨表查询：

2.7.4 聚合查询：

2.7.5 分组查询：

第3章 初始Ajax

3.1 Ajax准备知识：json

3.1.1 python中的序列化(dumps)与反序列化(loads)

3.1.2 JS中的序列化(stringify)与反序列化(parse)

3.2 JSON和XML的比较

3.2.1 用XML表示中国部分省市数据如下：

3.2.2 用JSON表示如下：

3.2.3 注意：

3.3 Ajax简介

3.3.1 简单介绍

3.3.2 ajax的创建应用场景

3.3.3 ajax的优点，特点也就是优点

3.4 jQuery实现的ajax

3.4.1 tishi.html

3.4.2 view

3.5 ajax参数

3.5.1 请求参数

3.5.2 响应参数

3.5.3 示例：

第4章 ajax补充--------FormData等

4.1 回顾上节知识点

4.1.1 什么是json字符串？

4.1.2 定时器：关于setTimeout

4.1.3 ajax的参数补充

4.1.4 JS和JQuery对象之间的转换

4.1.5 processDate 默认为True ，预处理； 如果改为False，不做预处理

4.2 csrf跨站请求伪造

4.2.1 方式一：

4.2.2 方式二：自己组装一组键值对 （ 推荐）

4.2.3 方式三：自己设置头信息

4.3 jQuery.serialize()

4.3.1 介绍

4.3.2 示例：

4.4 上传文件

4.4.1 Form表单上传文件

4.4.2 Ajax上传文件（利用FormData）

第5章 cookie和session

5.1 HTTP协议详细介绍

5.1.1 HTTP简介

5.1.2 HTTP特点

5.2 HTTP请求协议

5.2.1 get请求

5.2.2 post请求

5.3 HTTP响应协议

5.3.1 响应格式

5.3.2 例子

5.3.3 响应状态码

5.4 GET和POST请求的区别

5.5 web应用与web框架

5.5.1 web应用

5.5.2 wsgiref

第1章课堂笔记

第3章初始Ajax

4.1.5 processDate 默认为True ，预处理；如果改为False，不做预处理

4.2.2 方式二：自己组装一组键值对（推荐）