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

跨表查询总结：
    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()

基于对象关联查询：		
	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,....]
		
        反向查询,按表名_set：
        author_obj.book_set.all() : 与这个作者关联的所有书籍对象的集合

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

    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）：
	
 	    正向查询，按字段：
		models.Author.objects.filter(name="egon).values("ad__tel")
		
		反向查询：按表名：
		models.AuthorDetail.objects.filter(tel="151").values("author__name")
		
	if  多对多（Book----Author）：
	
    	正向查询，按字段：
		models.Book.objects.filter(title="python").values("authorList__name")     [{},{},{},{}]
		
		正向查询，按表名：
	    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
 
	聚合查询：
		querySet().aggregate(聚合函数)------返回的是一个字典，不再是一个querySet
	 
		Book.objects.all().aggregate(average_price=Avg('price'))
    
 
分组查询：
    querySet().annotate()　--- 返回的是querySet
	#统计每一个出版社中最便宜的书籍的价格
	sql:
	   select Min(price) from book group by publish_id;
	
	ORM:
	models.Book.objects.values("publish__name").annotate(Min("price"))
	
F查询 与 Q查询
	F()查询
	Django提供的F()来做两个字段的比较；
	Django支持F()对象之间以及 F()对象和常熟之间的加减乘除和取模操作；
	修改操作也可以使用F函数，比如将每一本书的价格提高7元；
	
	Q()查询
	filter()等方法中的关键字参数查询都是期进行“AND”的，。如果你需要执行更加复杂的查询（例如or语句），你可以使用Q对象。
	Q对象可以使用& 和| 操作符组合起来，当一个操作符在两个Q之间使用的时候，他会产生一个新的Q对象

http无法保存状态：此时cookie就诞生了
cookie：客户端浏览器保存的一组组的键值对：-------{"":"","":"","":""}
但是cookie的所有信息都在浏览器是上边了，这样很不安全，
此时cookie＋session就诞生了：
session：服务器上保存的用户信息

浏览器（一段代码展示，其实金和cookie差不多）：

url: http://127.0.0.1:8000/login/ get 
url: http://127.0.0.1:8000/login/ post user pwd

url: http://127.0.0.1:8000/home/

{"sessionID":"dfhasdjfhkjlcn4352kjdsfhkjsd"}

if post：

requset.session["IS_LOGON"]=True
requset.session["USER"]=username

return redirect("/home/")

Django： 
1 s="sdgsdfg4565dfgsdfgsdf" 
2 在django-session表中，添加一条记录
insert into django-session values (s,"{"IS_LOGON":True,"USER":egon}",12321)
3 obj.set_cookie("sessionID",s) {"sessionID":"sdgsdfg4565dfgsdfgsdf"} sdgsdfg4565dfgsdfgsdf:{d}

重定向：

/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

---