内容概要
1.关系对象映射ORM
2.admin的配置（选修）
3、all（）、values（）、value_list（）的对比
4、数据库操作（一对一、一对多、多对多）
5、HttpResponse和render的对比
1.关系对象映射ORM
一、用于实现面向对象编程语言里不同类型系统的数据之间的转换，换言之，就是用面向对象的方式去操作数据库的创建表以及增删改查等操作。
优点： 1 ORM使得我们的通用数据库交互变得简单易行，而且完全不用考虑该死的SQL语句。快速开发，由此而来。
2 可以避免一些新手程序猿写sql语句带来的性能问题。
缺点：1 性能有所牺牲，不过现在的各种ORM框架都在尝试各种方法，比如缓存，延迟加载登来减轻这个问题。效果很显著。
2 对于个别复杂查询，ORM仍然力不从心，为了解决这个问题，ORM一般也支持写raw sql。
3 通过QuerySet的query属性查询对应操作的sql语句
二、表(模型)的创建：
（1）、创建类，一个类指代一张表
（2）、创建字段，字段类型、长度、显示名称
一对一
一对多（外键）
多对多
（3）、生成同步数据库的脚本：python manage.py makemigrations
同步数据库: python manage.py migrate
例：
from django.db import models
class Publisher(models.Model):
name = models.CharField(max_length=30, verbose_name="名称")
address = models.CharField("地址", max_length=50)
city = models.CharField('城市',max_length=60)
state_province = models.CharField(max_length=30)
country = models.CharField(max_length=50)
website = models.URLField()
class Meta:
verbose_name = '出版商'
verbose_name_plural = verbose_name
def __str__(self):
return self.name
class Author(models.Model):
name = models.CharField(max_length=30)
def __str__(self):
return self.name
class AuthorDetail(models.Model):
sex = models.BooleanField(max_length=1, choices=((0, '男'),(1, '女'),))
email = models.EmailField()
address = models.CharField(max_length=50)
birthday = models.DateField()
author = models.OneToOneField(Author)
class Book(models.Model):
title = models.CharField(max_length=100)
authors = models.ManyToManyField(Author)
publisher = models.ForeignKey(Publisher)
publication_date = models.DateField()
price=models.DecimalField(max_digits=5,decimal_places=2,default=10)
def __str__(self):
return self.title
三、模型常用的字段类型参数：
<1> CharField
#字符串字段, 用于较短的字符串.
#CharField 要求必须有一个参数 maxlength, 用于从数据库层和Django校验层限制该字段所允许的最大字符数.
<2> IntegerField
#用于保存一个整数.
等等
四、Field重要参数
<1> null ： 数据库中字段是否可以为空
<2> blank： django的 Admin 中添加数据时是否可允许空值
<3> default：设定缺省值
等等
五、表的操作(增删改查)：
5.1、单表操作
--------基本操作：增删改查
1、增(create , save)
from app01.models import *
#create方式一: Author.objects.create(name='Alvin')
#create方式二: Author.objects.create(**{"name":"alex"})
#save方式一: author=Author(name="alvin")
author.save()
#save方式二: author=Author()
author.name="alvin"
author.save()
2、删（delete）
Book.objects.filter(id=1).delete()
(3, {'app01.Book_authors': 2, 'app01.Book': 1})
3、改（update和save）
#---------------- update方法直接设定对应属性----------------
models.Book.objects.filter(id=3).update(title="PHP")
#--------------- save方法会将所有属性重新设定一遍,效率低-----------
obj=models.Book.objects.filter(id=3)[0]
obj.title="Python"
obj.save()
4、查（filter，value等)
查询相关API：
# <1>filter(**kwargs): 它包含了与所给筛选条件相匹配的对象
# <2>all(): 查询所有结果
# <3>get(**kwargs): 返回与所给筛选条件相匹配的对象，返回结果有且只有一个，如果符合筛选条件的对象超过一个或者没有都会抛出错误。
#-----------下面的方法都是对查询的结果再进行处理:比如 objects.filter.values()--------
# <4>values(*field): 返回一个ValueQuerySet——一个特殊的QuerySet，运行后得到的并不是一系列 model的实例化对象，而是一个可迭代的字典序列
# <5>exclude(**kwargs): 它包含了与所给筛选条件不匹配的对象
# <6>order_by(*field): 对查询结果排序
# <7>reverse(): 对查询结果反向排序
# <8>distinct(): 从返回结果中剔除重复纪录
惰性机制：
所谓惰性机制：Publisher.objects.all()或者.filter()等都只是返回了一个QuerySet（查询结果集对象），它并不会马上执行sql，而是当调用QuerySet的时候才执行。
QuerySet特点：
<1> 可迭代的
<2> 可切片
--------进阶操作（双下划线）：大于、小于、in、contains、range、等
# 获取个数
#
# models.Tb1.objects.filter(name='seven').count()
# 大于，小于
#
# models.Tb1.objects.filter(id__gt=1) # 获取id大于1的值
# models.Tb1.objects.filter(id__gte=1) # 获取id大于等于1的值
# models.Tb1.objects.filter(id__lt=10) # 获取id小于10的值
# models.Tb1.objects.filter(id__lte=10) # 获取id小于10的值
# models.Tb1.objects.filter(id__lt=10, id__gt=1) # 获取id大于1 且 小于10的值
# in
#
# models.Tb1.objects.filter(id__in=[11, 22, 33]) # 获取id等于11、22、33的数据
# models.Tb1.objects.exclude(id__in=[11, 22, 33]) # not in
# isnull
# Entry.objects.filter(pub_date__isnull=True)
# contains
#
# models.Tb1.objects.filter(name__contains="ven")
# models.Tb1.objects.filter(name__icontains="ven") # icontains大小写不敏感
# models.Tb1.objects.exclude(name__icontains="ven")
# range
#
# models.Tb1.objects.filter(id__range=[1, 2]) # 范围bettwen and
# 其他类似
#
# startswith，istartswith, endswith, iendswith,
# order by
#
# models.Tb1.objects.filter(name='seven').order_by('id') # asc
# models.Tb1.objects.filter(name='seven').order_by('-id') # desc
# group by
#
# from django.db.models import Count, Min, Max, Sum
# models.Tb1.objects.filter(c1=1).values('id').annotate(c=Count('num'))
# SELECT "app01_tb1"."id", COUNT("app01_tb1"."num") AS "c" FROM "app01_tb1" WHERE "app01_tb1"."c1" = 1 GROUP BY "app01_tb1"."id"
# limit 、offset
#
# models.Tb1.objects.all()[10:20]
# regex正则匹配，iregex 不区分大小写
#
# Entry.objects.get(title__regex=r'^(An?|The) +')
# Entry.objects.get(title__iregex=r'^(an?|the) +')
# date
#
# Entry.objects.filter(pub_date__date=datetime.date(2005, 1, 1))
# Entry.objects.filter(pub_date__date__gt=datetime.date(2005, 1, 1))
# year
#
# Entry.objects.filter(pub_date__year=2005)
# Entry.objects.filter(pub_date__year__gte=2005)
# month
#
# Entry.objects.filter(pub_date__month=12)
# Entry.objects.filter(pub_date__month__gte=6)
# day
#
# Entry.objects.filter(pub_date__day=3)
# Entry.objects.filter(pub_date__day__gte=3)
# week_day
#
# Entry.objects.filter(pub_date__week_day=2)
# Entry.objects.filter(pub_date__week_day__gte=2)
# hour
#
# Event.objects.filter(timestamp__hour=23)
# Event.objects.filter(time__hour=5)
# Event.objects.filter(timestamp__hour__gte=12)
# minute
#
# Event.objects.filter(timestamp__minute=29)
# Event.objects.filter(time__minute=46)
# Event.objects.filter(timestamp__minute__gte=29)
# second
#
# Event.objects.filter(timestamp__second=31)
# Event.objects.filter(time__second=2)
# Event.objects.filter(timestamp__second__gte=31)
进阶操作--------其他操作：F、Q、原生SQL
# extra
#
# extra(self, select=None, where=None, params=None, tables=None, order_by=None, select_params=None)
# Entry.objects.extra(select={'new_id': "select col from sometable where othercol > %s"}, select_params=(1,))
# Entry.objects.extra(where=['headline=%s'], params=['Lennon'])
# Entry.objects.extra(where=["foo='a' OR bar = 'a'", "baz = 'a'"])
# Entry.objects.extra(select={'new_id': "select id from tb where id > %s"}, select_params=(1,), order_by=['-nid'])
# F
#
# from django.db.models import F
# models.Tb1.objects.update(num=F('num')+1)
# Q
#
# 方式一：
# Q(nid__gt=10)
# Q(nid=8) | Q(nid__gt=10)
# Q(Q(nid=8) | Q(nid__gt=10)) & Q(caption='root')
# 方式二：
# con = Q()
# q1 = Q()
# q1.connector = 'OR'
# q1.children.append(('id', 1))
# q1.children.append(('id', 10))
# q1.children.append(('id', 9))
# q2 = Q()
# q2.connector = 'OR'
# q2.children.append(('c1', 1))
# q2.children.append(('c1', 10))
# q2.children.append(('c1', 9))
# con.add(q1, 'AND')
# con.add(q2, 'AND')
#
# models.Tb1.objects.filter(con)
# 执行原生SQL
#
# from django.db import connection, connections
# cursor = connection.cursor() # cursor = connections['default'].cursor()
# cursor.execute("""SELECT * from auth_user where id = %s""", [1])
# row = cursor.fetchone()
其他操作
5.2、联表操作（利用双下划线和 _set 将表之间的操作连接起来）：
一对一
一对多 见博客第4点、
多对多 时见 http://www.cnblogs.com/tangtingmary/p/7994148.html 第12点。
2.admin的配置（选修）
admin是django强大功能之一，它能共从数据库中读取数据，呈现在页面中，进行管理。默认情况下，它的功能已经非常强大，如果你不需要复杂的功能，它已经够用，但是有时候，一些特殊的功能还需要定制，比如搜索功能，下面这一系列文章就逐步深入介绍如何定制适合自己的admin应用。
步骤：
1.在models中建几张表（类）
生成同步数据库的脚本：python manage.py makemigrations
同步数据库: python manage.py migrate
注意：在开发过程中，数据库同步误操作之后，难免会遇到后面不能同步成功的情况，解决这个问题的一个简单粗暴方法是把migrations目录下
的脚本（除__init__.py之外）全部删掉，再把数据库删掉之后创建一个新的数据库，数据库同步操作再重新做一遍。
2.创建超级管理员：python manage.py createsuperuser，设置好用户名和密码后便可登录http://127.0.0.1:8080/admin/啦！
3.在app01的admin.py中进行配置
一 认识ModelAdmin
管理界面的定制类，如需扩展特定的model界面需从该类继承。
二 注册medel类到admin的两种方式：
<1> 使用register的方法
|
1
|
admin.site.register(Book,MyAdmin)
|
<2> 使用register的装饰器
|
1
|
@admin
.register(Book)
|
三 掌握一些常用的设置技巧
- list_display: 指定要显示的字段
- search_fields: 指定搜索的字段
- list_filter: 指定列表过滤器
- ordering： 指定排序字段
实例：
from django.contrib import admin from app01.models import * #导入 # Register your models here. admin.site.register(Author)#该语句用来注册 admin.site.register(Publisher)#该语句用来注册 class MyAdmin(admin.ModelAdmin): list_display = ("title","price","publisher")#定制显示哪些字段 search_fields = ("title", "publisher")#搜索插件，可根据title和publisher来搜索 list_filter = ("publisher",)#过滤器 ordering = ("price",)#排序 # fieldsets = [ # (None, {'fields': ['title']}), # ('price information', {'fields': ['price', "publisher"], 'classes': ['collapse']}), # ] admin.site.register(Book,MyAdmin)#该语句用来注册，且将MyAdmin与Book绑定
3、all（）、values（）、value_list（）的对比
一对多操作：
获取所有的学生--------获取DB数据
class Classes(models.Model):
caption = models.CharField(max_length=32)
class Student(models.Model):
name = models.CharField(max_length=32)
email = models.CharField(max_length=32,null=True)
cls = models.ForeignKey('Classes')
原理讲解：
.all()result = models.Student.object.all()
# QuerySet类型, select * from ....
# [obj,obj,obj,]，Django内部有一个模块，可以转换
# obj.name, obj.email, obj.cls_id, obj.cls.id, obj.cls.caption.all().values（）result = models.Student.object.all().values('id','name','email', 'cls_id', 'cls__id', 'cls__caption')
# QuerySet, select id.. from ...
# list(result) -> QuerySet -> list， json.dumps()
# [ {'id': 1, 'name': ...,},{'id': 1, 'name': ...,},{'id': 1, 'name': ...,},{'id': 1, 'name': ...,} ]
.all().value_list（）result = models.Student.object.all().value_list('id','name','email', 'cls_id', 'cls__id', 'cls__caption')
# QuerySet, select id.. from ...
# list(result) -> QuerySet -> list， json.dumps()
# [ (1,'root'..),(1,'root'..),(1,'root'..),(1,'root'..),(1,'root'..) ]
# PS: QuerySet,无法直接使用json.dumps()序列化
# QuerySet
- Django内部有一个模块，可以转换
- values, value_list, 转换成 list(result)， json.dumps
获取数据：三种形式
请求数据：form(url)，ajax
all（）、values（）、value_list（）-------------------在模版语言显示数据(URL,Form表单的形式）
def index(request):
result = models.Student.object.all()
return render(request, 'index.html', {'reuslt': result})
{% for item in result%}
{{item.id}} - {{item.name}} - {{item.cls.id}} - {{item.cls.caption}}
{% endfor %}
def index(request):
result = models.Student.object.all().values('id','name','email', 'cls_id', 'cls__id', 'cls__caption')
# [ {'id': 1, 'name': ...,},{'id': 1, 'name': ...,},{'id': 1, 'name': ...,},{'id': 1, 'name': ...,} ]
return render(request, 'index.html', {'reuslt': result})
{% for item in result%}
{{item.id}} - {{item.name}} - {{item.cls__id}} - {{item.cls__caption}}
{% endfor %}
def index(request):
result = models.Student.object.all().value_list('id','name','email', 'cls_id', 'cls__id', 'cls__caption')
# QuerySet, select id.. from ...
# list(result) -> QuerySet -> list， json.dumps()
# [ (1,'root'..),(1,'root'..),(1,'root'..),(1,'root'..),(1,'root'..) ]
return render(request, 'index.html', {'reuslt': result})
{% for item in result%}
{{item.0}} - {{item.1}} - {{item.4}} - {{item.5}}
{% endfor %}
- Ajax请求
a.
$(function(){
$.ajax...
})
b.
def index(request):
result = models.Student.object.all()
# Django内部序列化工具
result = Django内部序列化工具
return HttpResponse(result)
def index(request):
result = models.Student.object.all().values('id','name','email', 'cls_id', 'cls__id', 'cls__caption')
result = list(result)
result_str = json.dumps(result)
return HttpResponse(result_str)
def index(request):
result = models.Student.object.all().value_list('id','name','email', 'cls_id', 'cls__id', 'cls__caption')
result = list(result)
result_str = json.dumps(result)
return HttpResponse(result_str)
c.
$.each(function(){
# 构建html标签
# 将标签添加到HTML指定位置
})
4、数据库操作（一对一、一对多、多对多）
- 单表操作
- all
- filter （过滤）内部也可以放字典
models.tb.objects.filter(id=123)
dic = {'id': 123, 'age__gt': 3}
models.tb.objects.filter(**dic)
- count
- order_by
...
- 一对多
1.（ForeignKey时，默认和主键id进行关联，也可以自定义nid（必须时唯一的unique=True）进行关联）
如：models.ForeignKey("Province", to_filed='nid')自定义和Province的nid进行关联
省
# id name
1 河北
2 广东
3 山东
class Province(models.Model):
name = models.CharField(max_length=32,)
# nid = models.Intergar(unique=True) # 唯一
市 省
# id name pro
1 东莞 2
2 深圳 2
3 惠州 2
4 河源 2
5 泰安 3
6 青岛 3
7 济南 3
8 张家口 1
9 邢台 1
class City(models.Model):
name = models.CharField(max_length=32)
pro = models.ForeignKey("Province", to_filed='id')（外键列，在数据库创建时的名称，自动会是pro_id，即【列名_id】)
---------------------------------------------------------------------
1、 正向查找（基于市查省份表，foreignkey在city里） （_ _id）
result = models.City.objects.all()
result[0].pro.name 跨表查询
models.City.objects.all().values('id','name','pro_id','pro__id','pro__name') 内部为字典#'pro__id','pro__name'是关联表里面的id和name
models.City.objects.all().values_list('id','name','pro_id','pro__id','pro__name') 内部为元祖
2、反向查找 （_set）
result = models.Province.objects.values('id','name', 'city__name')
result = models.Province.objects.all()
result[0] # 获取河北
result[0].city_set.all() # 获取河北下的所有市 张家口 、邢台
for pro in result:
a1 = pro.id
a2 = pro.name
a3 = pro.city_set.all()
print(a1,a2,a3)
=====> 多对多即使基于一对多来构造
-多对多（自己创建关系表或Django默认帮我们创建）
class Book(models.Model):
name =models.CharField(max_length=32)
class Author(models.Model):
name = models.CharField(max_length=32)
m = models.ManyToManyField('Book')
1.自己创建第三张表（后续操作方便）：
class Book(models.Model):
name = ..
class Author(models.Model):
name = ..
class A_to_B(models.Model): #这种方式就不能使用Django自带的clear、remove等方法
bid = ForeignKey(Book)
aid = ForeignKey(Author)
====> 所有操作：化简为 单表操作 和 一对多操作
2.默认生成第三张表
只能间接对第三张表进行操作（因为没有第三张表的类）
# 正向查找
# obj,人，金鑫
# obj = models.Author.objects.get(id=1)
#
# # 金鑫所有的著作全部获取到
# obj.m.all()
# 反向查找
# 金品买
# obj = models.Book.objects.get(id=1)
# # 金鑫，吴超
# obj.author_set.all()
# 10
# author_list = models.Author.objects.all()
# for author in author_list:
# print(author.name,author.m.all())
# author_list = models.Author.objects.values('id','name','m', "m__name")
# for item in author_list:
# print(item['id'],item['name'],'书籍ID:',item['m'],item['m__name'])
# 添加
# obj = models.Author.objects.get(id=1)
# 第三张表中增加一个对应关系
# 增加
# obj.m.add(5)
# obj.m.add(5,6)
# obj.m.add(*[4,5])
# 删除
# obj.m.remove(5)
# obj.m.remove(5,6)
# obj.m.remove(*[5,6])
# 清空
# obj.m.clear()
# 更新
# obj.m.set([1,2,3])
# 反向操作
# obj = models.Book.objects.get(id=1)
# obj.author_set.add(1)
# obj.author_set.add(1,2,3,4)
# ... 补充：
select_related 和 prefetch_related 函数优化查询
1. select_related()
对于一对一字段（OneToOneField）和外键字段（ForeignKey），可以使用select_related 来对QuerySet进行优化
作用和方法
在对QuerySet使用select_related()函数后，Django会获取相应外键对应的对象，从而在之后需要的时候不必再查询数据库了。以上例说明，如果我们需要打印数据库中的所有市及其所属省份，最直接的做法是：
>>> citys = City.objects.all()
>>> for c in citys:
... print c.province
...
这样会导致线性的SQL查询，如果对象数量n太多，每个对象中有k个外键字段的话，就会导致n*k+1次SQL查询。在本例中，因为有3个city对象就导致了4次SQL查询。
--------------------------------------------
如果我们使用select_related()函数：
>>> citys = City.objects.select_related().all()
>>> for c in citys:
... print c.province
...
就只有一次SQL查询，显然大大减少了SQL查询的次数：
这里我们可以看到，Django使用了INNER JOIN来获得省份的信息。小结
1.select_related主要针一对一和多对一关系进行优化。
2.select_related使用SQL的JOIN语句进行优化，通过减少SQL查询的次数来进行优化、提高性能。
3.可以通过可变长参数指定需要select_related的字段名。也可以通过使用双下划线“__”连接字段名来实现指定的递归查询。没有指定的字段不会缓存，没有指定的深度不会缓存，如果要访问的话Django会再次进行SQL查询。
4.也可以通过depth参数指定递归的深度，Django会自动缓存指定深度内所有的字段。如果要访问指定深度外的字段，Django会再次进行SQL查询。
5.也接受无参数的调用，Django会尽可能深的递归查询所有的字段。但注意有Django递归的限制和性能的浪费。
6.Django >= 1.7，链式调用的select_related相当于使用可变长参数。Django < 1.7，链式调用会导致前边的select_related失效，只保留最后一个。
2. prefetch_related()
对于多对多字段（ManyToManyField）和一对多字段，可以使用prefetch_related()来进行优化。或许你会说，没有一个叫OneToManyField的东西啊。实际上 ，ForeignKey就是一个多对一的字段，而被ForeignKey关联的字段就是一对多字段了。
作用和方法
prefetch_related()和select_related()的设计目的很相似，都是为了减少SQL查询的数量，但是实现的方式不一样。后者是通过JOIN语句，在SQL查询内解决问题。但是对于多对多关系，使用SQL语句解决就显得有些不太明智，因为JOIN得到的表将会很长，会导致SQL语句运行时间的增加和内存占用的增加。若有n个对象，每个对象的多对多字段对应Mi条，就会生成Σ(n)Mi 行的结果表。prefetch_related()的解决方法是，分别查询每个表，然后用Python处理他们之间的关系。继续以上边的例子进行说明，如果我们要获得张三所有去过的城市，使用prefetch_related()应该是这么做：
最佳实践：
1.prefetch_related主要针一对多和多对多关系进行优化。
2.prefetch_related通过分别获取各个表的内容，然后用Python处理他们之间的关系来进行优化。
3.可以通过可变长参数指定需要select_related的字段名。指定方式和特征与select_related是相同的。
4.在Django >= 1.7可以通过Prefetch对象来实现复杂查询，但低版本的Django好像只能自己实现。
5.作为prefetch_related的参数，Prefetch对象和字符串可以混用。
6.prefetch_related的链式调用会将对应的prefetch添加进去，而非替换，似乎没有基于不同版本上区别。
7.可以通过传入None来清空之前的prefetch_related。
小结
- 因为select_related()总是在单次SQL查询中解决问题，而prefetch_related()会对每个相关表进行SQL查询，因此select_related()的效率通常比后者高。
- 鉴于第一条，尽可能的用select_related()解决问题。只有在select_related()不能解决问题的时候再去想prefetch_related()。
- 你可以在一个QuerySet中同时使用select_related()和prefetch_related()，从而减少SQL查询的次数。
- 只有prefetch_related()之前的select_related()是有效的，之后的将会被无视掉。
5、HttpResponse和render的对比
HttpResponse，传入的数据，直接返回给用户
render(request,'a.html', {'k':123})
1、找到html模版，open函数打开获取到内存
2、Django的模版引擎： html模版的内容 + 数据 => 渲染（替换） ===》 最终字符串
3、HttpResponse(最终字符串)
6、补充
a.
def index(request):
request.POST.get('k')
# checkbox--name相同,、select（多选时）可用getlist
request.POST.getlist('k')
b.模板语言里面（.html）调用方法不需要加括号
参考博客：
http://www.cnblogs.com/wupeiqi/articles/5246483.html
http://www.cnblogs.com/yuanchenqi/articles/6083427.html
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
