先看models

class Book(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="")publish = models.ForeignKey(to="Publish", default=1)author = models.ManyToManyField("Author")def __str__(self):return self.titleclass 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_setobj=Book.objects.fliter(title="python").first()
obj.publish

正向查询
查询id=1的书籍的出版社的名称

book_obj = Book.objects.filter(id=6).first()
print(book_obj.publish.name)

反向查询
查询苹果出版社出版了哪些书

publish_obj = Publish.objects.filter(name='图灵新知').first()
print(publish_obj.book_set.all()) # <QuerySet [<Book: go>, <Book: Django>]>for book in publish_obj.book_set.all():print(book.title)   #go   Django

多对多：

     正向查询，按字段
Book-------------------->Author<---------------------查询，按表名小写_set:book_setobj=Book.objects.fliter(title="python").first()
obj.author.all()  #  [obj,....]

正向查询
查询go所有作者的名字

book_obj = Book.objects.filter(title='go').first()
author_obj = book_obj.author.all()
for author in author_obj:print(author.name) #alex egon

反向查询
查询alex出版过的所有书籍名称

author_obj = Author.objects.filter(name="alex").first()
book_obj = author_obj.book_set.all()
for book in book_obj:print(book.title)  #go  python

一对一：

      正向查询，按字段
Book-------------------->Author<---------------------查询,按表名小写

查询alex的手机号

obj = Author.objects.filter(name="alex").first()
print(obj.authordetail.tel)

查询手机号为456的作者的名字

obj = AuthorDetail.objects.filter(tel=456).first()
print(obj.author.name)

基于queryset的跨表查询

正向查询，按字段A-------------------->B<---------------------查询,按表名小写

一对多：

正向查询
查询价格等于100的书籍的出版社的名称

ret = Book.objects.filter(price=222).values("title", "publish__name")
publish__name等于循环过程中"publish__name": book.publish.name
print(ret)
< QuerySet[{'title': '郭小倩', 'publish__name': '图灵新知'}] >

反向查询
查询苹果出版社出版了哪些书

obj = Publish.objects.filter(name="图灵新知").values("book__title")
print(obj)
< QuerySet[{'book__title': 'go'}, {'book__title': 'Django'}, {'book__title': '郭小倩'}] >

多对多：

正向查询
查询go所有作者的名字

obj = Book.objects.filter(title="go").values("author__name")
print(obj)
< QuerySet[{'author__name': 'alex'}, {'author__name': 'egon'}] > 有多本书有相同作者时后面可以加.distinct()去重

问：能查出几个结果
答：一本书叫go，两个作者那就是两个结果。两本书叫go，第一本两个作者，第二本一个作者，那最后总共查出三个结果

反向查询
查询alex出版过的所有书籍名称

obj = Author.objects.filter(name="alex").values("book__title")
print(obj)
<QuerySet [{'book__title': 'go'}, {'book__title': 'python'}]>

一对一：

反向查询
查询alex的手机号

obj = Author.objects.filter(name="alex").values("authordetail__tel")
print(obj) #<QuerySet [{'authordetail__tel': '123'}]>

正向查询
查询手机号为456的作者的名字

obj = AuthorDetail.objects.filter(tel="456").values("author__name")
print(obj) #<QuerySet [{'author__name': 'egon'}]>

练习，多次跨表

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

obj = AuthorDetail.objects.filter(tel__startswith="1").values("author__book__title", "author__book__publish__name")
print(obj)
<QuerySet [{'author__book__title': 'go', 'author__book__publish__name': '图灵新知'}, {'author__book__title': 'python', 'author__book__publish__name': '老男孩出版社'}]>

聚合与分组

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

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

聚合 aggregate

统计所有书籍的平均价格

ret = Book.objects.all().aggregate(Avg("price"))
print(ret) #{'price__avg': 416}

分组 annotate

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

ret = Publish.objects.all().annotate(c=Count("book")).values("name", "c")
print(ret)
< QuerySet[{'name': '图灵新知', 'c': 1}, {'name': '老男孩出版社', 'c': 2}] >

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

ret = Author.objects.all().annotate(price_avg=Avg("book__price")).values("name","price_avg")
print(ret)
< QuerySet[{'name': 'alex', 'price_avg': 100.0}, {'name': 'egon', 'price_avg': 574.5}, {'name': 'yuan','price_avg': 416.3333333333333}] >

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

ret = Book.objects.all().annotate(c=Count("author")).values("title", "c")
print(ret)
<QuerySet [{'title': 'dzm笔记', 'c': 2}, {'title': 'go', 'c': 2}, {'title': 'java', 'c': 2}]>

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

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

F查询与Q查询

from django.db.models import F, Q

F

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

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

查询评论数大于点赞数的书籍

ret = Book.objects.filter(comment_num__gt=F("poll_num"))
print(ret)
<QuerySet [<Book: dzm笔记>, <Book: java>]>

评论数大于10倍阅读数的书籍

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

把所有的书籍的价格都增加100元

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

以java开头且价格大于200的书

ret = Book.objects.filter(title__startswith="java", price__gt=200) #逗号描述的是与的意思
print(ret)
< QuerySet[ < Book: java >] >

Q

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

查询以java开头或价格大于200的书籍

ret = Book.objects.filter(Q(title__startswith="java")|Q(price__gt=200))
print(ret)
< QuerySet[ < Book: dzm笔记 >, < Book: java >] >

注意，下面这种逗号和Q混合使用的情况下，逗号左右代表着且的关系，Q要放在逗号的左侧

ret = Book.objects.filter(Q(title__startswith="java")|Q(price__gt=200),create_time__year=2018)

Ajax

Ajax简介

异步交互：客户端发出一个请求后，无需等待服务器响应结束，就可以发出第二个请求。
AJAX除了异步的特点外，还有一个就是：浏览器页面局部刷新；（这一特点给用户的感受是在不知不觉中完成请求和响应过程）

示例代码1

实例（用户名是否已被注册）
在注册表单中，当用户填写了用户名后，把光标移开后，会自动向服务器发送异步请求。服务器返回true或false，返回true表示这个用户名已经被注册过，返回false表示没有注册过。
客户端得到服务器返回的结果后，确定是否在用户名文本框后显示“用户名已被注册”的错误信息！

urls中

urlpatterns = [url(r'^user_valid/', user_valid),
]

views中

from .models import *
def user_valid(request):name = request.GET.get("name")ret = Author.objects.filter(name=name)res = {"state":True, "msg":""}if ret:res["state"] = Falseres["msg"] = "该用户已存在"import jsonreturn HttpResponse(json.dumps(res))   # 因为要通过网络传输，所以要转换成json

templates中

<script>$("#user").blur(function () {$.ajax({url:"/user_valid/",type:"get",data:{"name":$("#user").val()},  # 发送过去的的数据success:function (data) {       # data就是从views中接收到的数据，此时的data是一个json形式的对象，{state: true, msg: ""}var data=JSON.parse(data)    # 使用JSON.parse 将 JSON 字符串转换为对象if (!data.state){        #取对象中的state值$(".error").html(data.msg).css("color", "red")}}})})
</script>

示例代码2 POST请求

templates中

{% csrf_token %} # 加入<script>$("#user").blur(function () {$.ajax({url:"/user_valid/",type:"post",data:{"name":$("#user").val(),'csrfmiddlewaretoken':$("[name='csrfmiddlewaretoken']").val() # 加入csrf},success:function (data) {var data=JSON.parse(data)console.log(data);if (!data.state){$(".error").html(data.msg).css("color", "red")}}})})
</script>

示例代码3 跳转到新网页

            success:function (data) {var data=JSON.parse(data)if (data.msg){location.href="/index/";

Cookie

Cookie是存放在客户端浏览器上的，以key, value 的形式保存

Cookie的语法

获取Cookie

request.COOKIES.get('key') 或 request.COOKIES['key'] ：这就是个字典，获取值使用字典的操作
举例：

ret = request.COOKIES.get("is_login_dzm")

设置Cookie

设置就是在把对象返回给客户端之前，先拿到这个对象：rep = render(request, ...) 或 rep = return HttpResponse(...) ，
拿到之后设置：rep.set_cookie(key,value) 参数不止这两个，所有参数如下：

key ：键
value='' ：值
max_age=None ：超时时间，单位是秒。不设置就是浏览器关闭就马上失效
expires=None ：超时时间节点，设置一个具体的日期。rep.set_cookie(key, value, expires=datetime.datetime.strptime('2018-4-11 11:23:00', '%Y-%m-%d %H:%M:%S')) ，记得先 import datetime 模块
path='/' ：Cookie生效的路径，/ 表示根路径，根路径的cookie可以被任何url的页面访问
domain=None ：Cookie生效的域名
secure=False ：https传输，如果网站是https的，写cookie的时候把这个参数设置为True
httponly=Fals ：只能http协议传输，无法被JavaScript获取（不是绝对，底层抓包可以获取到也可以被覆盖）。document.cookie 获取不到设置了这个参数的cookie。
如果要注销，清除cookie，那么就 rep.set_cookie(key) ，给你的key设置个空值，并且超时时间设置为马上失效。

举例：

import json
obj = HttpResponse(json.dumps(res))
obj.set_cookie("is_login_dzm", True)
obj.set_cookie("username", user)
return obj