昨日内容回顾
多表方案： 如何确定表关系呢？ 表关系是在2张表之间建立的，没有超过2个表的情况。 那么相互之间有2条关系线，先来判断一对多的关系。 如果其中一张表的记录能够对应另外一张表的多条记录，那么关系线成立！ 如果只有一条线成立，那么就是一对多的关系。 如果有2条线成立，那么就是多对多的关系。 比如book和publish。一本书不能对应多个出版社(常规是这样的,否则就盗版了),那么不成立。 一个出版社可以对应多本书，关系线成立。所以book和publish表的关系是一对多的关系 多对多的关系，就是2张表互相对应多条记录。 比如book和author。一本书可以有多个作者，一个作者可以写多本！ 一对一的关系，就很简单了，彼此唯一。 比如author和authordetail是一对一的关系。 一对多： book和publish表的关系是一对多的关系 一旦确定一对多的关系：在多的表中创建关联字段 # 与Publish建立一对多的关系,外键字段建立在多的一方 publish=models.ForeignKey(to="Publish",to_field="id",on_delete=models.CASCADE) #创建的字段名为publish_id。它会自动加_id后缀 多对多： book和author是多对多的关系 一旦确定多对多的关系：创建第三张关系表 # 与Author表建立多对多的关系,ManyToManyField可以建在两个模型中的任意一个，自动创建第三张表 authors=models.ManyToManyField(to="Author") #注意：表名为应用名+book类名小写+authors，也就是book_authors。 #它只有3个字段,分别是主键id,book_id,author_id。 #book_id和author_id分别表示book表和author表的主键id 一对一： author和authordetail是一对一的关系 一旦确定一对一的关系 ： 创建关联字段(任意一张表创建都可以) #但是一般，我们会判断谁是重要的，谁是次要的。在重要的表上面创建关联字段！比如author #由于authordetail表是author表的延伸，所以在author表创建关联字段 # 与AuthorDetail建立一对一的关系 ad=models.OneToOneField(to="AuthorDetail",to_field="id",on_delete=models.CASCADE,) #创建的字段名为ad_id，它会自动加_id后缀。一对一关联字段，必须设置唯一属性！
一、django多表添加
昨天已经把5张表，都创建出来了。models.py里面有4个模型，其中第5张表，是book表和author表的关系表。
由book类的authors属性来创建了关系表，表名为：应用名+book+'_'+authors。
修改urls.py，添加add路径
from app01 import views urlpatterns = [ path('admin/', admin.site.urls), path('add/', views.add), ]
由于pycharm对sqlite数据库的时间字段，添加时，会自动转换为时间戳。
这样很不好，所以我使用navicat来连接。
新建一个连接
找到表publish
添加2条记录
添加表记录
create(**kwargs) 建立新对象
返回值是添加的model对象
一对一
举例：添加一条作者信息
姓名=hong，年龄=25，女朋友=唐安琪，电话=1314
def add(request): #先添加作者详细信息 hong_gf = AuthorDetail.objects.create(gf="唐安琪",tel=1314) #再添加作者，因为它依赖AuthorDetail表 hong = Author.objects.create(name="hong",age="25",ad=hong_gf) print(hong) return HttpResponse('添加成功')
注意：因为author的ad属性是关联authordetail表，必须添加authordetail表，才能添加author表。
ad必须接收一个model对象。可以从这个model对象中，获取插入的id值。
刷新页面，查看authordetail表，发现多了一条记录
查看author表，发现多了一条记录
一对多
方式1（推荐）
修改views.py，增加add视图函数
from django.shortcuts import render,HttpResponse from app01.models import Book # Create your views here. def add(request): #publish_id就是Book类的publish属性。它的字段为publish_id book = Book.objects.create(title='西游记',price=100,pub_date="1743-4-12",publish_id=2) print(book.title) #打印title return HttpResponse('添加成功')
访问url：http://127.0.0.1:8000/add/
查看book表记录，发现多了一条
方式2
添加一本书《三国演义》，指定出版社为西瓜出版社
首要要导入Publish
def add(request): xigua = Publish.objects.filter(name="西瓜出版社").first() #model对象 book = Book.objects.create(title='三国演义',price=300,pub_date="1643-4-12",publish=xigua) print(book.title) #打印标题 print(book.publish) # 与这本书籍关联的出版社对象 print(type(book.publish)) # 打印属性 print(book.publish.id) # 出版社id print(book.publish.name) # 出版社name return HttpResponse('添加成功')
注意：xigua它是一个model对象，它表示publish表的一条记录
create里面的publish只能接收publish表的model对象，不能接收别的表model对象！
查看models.py的Book类的publish属性
publish=models.ForeignKey(to="Publish",to_field="id",on_delete=models.CASCADE)
注意：它只能接收publish表的id字段。
所以执行sql时，它相当于publish_id=xigua.id。
这种添加方式，有严格的限制，必须接收publish的model对象才可以的。不推荐使用
查看控制台信息：
三国演义 [29/Jun/2018 16:47:44] "GET /add/ HTTP/1.1" 200 12 Publish object (1) <class 'app01.models.Publish'> 1 西瓜出版社
book.publish 是与这本书籍关联的出版社对象
那么就可以得到出版社的id和name属性值
查看表记录，发现多了一条
现在书籍和作者还没有绑定关系，先增加作者详细记录
修改authordetail表，增加2条记录
修改author表，增加2条记录
多对多
现在需要在book表里面插入一本书《python》，这本书有2个作者。那么book_authors应该有2条记录
它应该是这样的
id book_id author_id
1 3 1
2 3 2
那么如何将这2条记录，插入进去呢？
修改add视图函数，注意导入author类
先插入一条记录
book = Book.objects.create(title='python',price=122,pub_date="2012-12-12",publish_id=1)
再获取2个作者
xiao = Author.objects.filter(name="xiao").first() zhang = Author.objects.filter(name="zhang").first()
最后插入2条记录，注意：下面2行代码是不能执行的，它是伪代码！
book_authors.objects.create(book_id=book.id,author_id=xiao.id)
book_authors.objects.create(book_id=book.id, author_id=zhang.id)
上面2行代码表示在book_authors表中添加2条记录，只增加book_id和author_id。
那么问题来了，book_authors这张表是用orm创建的
但是orm的models.py里面找不到book_authors这张表的模型类。如果存在的话，那肯定没有问题的。
因为第3张表，是在book类里面的authors属性，用ManyToManyField创建的
因为一本书，对应的不止一个作者，所以不能直接赋值操作。
add() 增加多个关系对象
使用方法1：add(obj1, obj2, ...)
ORM提供了add方法，来添加多对多的关系表。
def add(request): book = Book.objects.create(title='python',price=122,pub_date="2012-12-12",publish_id=1) xiao = Author.objects.filter(name="xiao").first() zhang = Author.objects.filter(name="zhang").first() book.authors.add(xiao,zhang) # 添加2条数据,接收一个参数，就会产生一条记录 return HttpResponse('添加成功')
注意：book.authors.add(xiao,zhang)，相当于执行上面2句伪代码！
它会自动获取2个对象的主键id，并插入到对应的字段中。
刷新页面，查看book表，发现多了一条记录
查看book_authors表，发现多2条数据
如果需要为书籍绑定所有作者呢？
author_list = Author.objects.all()
book.authors.add(*author_list)
上面2行代码，就搞定了，非常简洁！
使用方法2：add(主键1, 主键2, ...)
下面这种写法，也是可以的。在html表单页面添加时，会用到此写法！
book.authors.add(1,2)
还有一种写法，是属于python的。*[1,2]，表示打散。它相当于上面的写法
book.authors.add(*[1,2])
区别在于：add(1,2)这种写法，它是执行了2次，在book_authors表中插入2条记录。
那么在不知道有多少数值的情况下，需要使用*[args1,args2]这种写法。
注意：在html表单中的复选框中，它提交的数据是多个值，必须使用getlist方法获取，它是列表类型。
因为不知道用户，到底会选择多少个选项。所以就需要使用这种打散写法！
删除记录
remove(obj1, obj2, ...) 去除多个关系对象
举例：删除python这本书的xiao作者
那么只需要删除book_authors表，id为1的这一条记录，就可以了
但是，不能直接对这张表，直接删除。因为它是2个表的关联表。
解除绑定的关系
def add(request): book = Book.objects.filter(id=3).first() # 先找到这本书 xiao = Author.objects.filter(name="xiao").first() # 再找到作者 book.authors.remove(xiao) # 解除绑定的关系 return HttpResponse('添加成功')
刷新页面，查看book_authors表记录，发现作者没有了
注意：这里可不是级联删除，book_authors并没有on_delete=models.CASCADE属性
clear() 清理所有关系对象
修改book_authors表记录，添加1条记录
举例：将book_id等于3的所有的作者删除
上面的例子，用remove，可以将一个删除。如果这本书，有5个作者呢？
一个个remove？太累了！django提供了clear方法，可以清理所有关系对象。
def add(request): book = Book.objects.filter(id=3).first() book.authors.clear() # 清理所有关系对象 return HttpResponse('添加成功')
刷新页面，再次查看book_authors表记录，发现已经空了！
修改authordetail表，增加一条记录
修改author表，增加一条记录
修改book_authors表，增加3条数据
set([obj1,obj2...]) 先清空再设置
set([obj1,obj2,...]) 它接收多个值，可以一个，也可以多个。适用于后台网页修改操作！
举例：
python这本书目前有3个作者，将wang设置为这本书的唯一作者
怎么做呢？将另外2个作者解除关系就可以了。
def add(request): book = Book.objects.filter(id=3).first() # 先找到书 xiao = Author.objects.filter(name="xiao").first() # 再找到作者 zhang = Author.objects.filter(name="zhang").first() book.authors.remove(xiao,zhang) # 解除绑定的关系 return HttpResponse('添加成功')
但是这样将2个作者解除，太麻烦了。
还有一种做法，先清空，再设置
def add(request): book = Book.objects.filter(id=3).first() # 先找到书 book.authors.clear() # 清理所有关系对象 wang = Author.objects.filter(name="wang").first() book.authors.add(wang) return HttpResponse('添加成功')
django提示了set方法，直接合并了先清空再设置的操作
它必须接收一个数组，因为可以接收多个值
def add(request): book = Book.objects.filter(id=3).first() # 先找到书 wang = Author.objects.filter(name="wang").first() # 再找作者 book.authors.set([wang]) #先清空再设置 return HttpResponse('添加成功')
刷新页面，查看book_authors表记录，发现只有一条了
总结：
重点掌握create，add，remove，clear，set这五个方法！
添加表记录：
一对一和一对多，使用create方法。它有2种使用方法：
1. create(字段名1=值1...)。适用于表单添加操作！注意，这里面的字段名是ORM创建表之后的的字段名
比如: book类的publish属性，它是关联字段，ORM创建之后，字段名为publish_id
2.create(模型类属性1=值1...)。比如book类的publish属性，它是关联字段。
直接create(publish=obj1)，注意，它接收一个model对象，对象包含了主键id
多对多使用add方法。add用2种使用方法：
1.add(obj1，obj2...) 它接收一个model对象，对象包含了主键id
2.add(主键id1，主键id2...) 它接收一个主键id。适用于表单添加操作！
还有一个python的打散语法，前面加一个*就可以了。比如*[1,2]，它会依次调用前置方法，每次只取一个值。表单操作，会用到！
删除记录：
适用于一对一，一对多，多对一。
remove(obj1, obj2, ...) 去除多个关系对象。它需要指定一个或者多个对象
clear() 清理所有关系对象。不管现有的关系有多少，一律清空！
set([obj1,obj2...]) 先清空再设置。不管现有的关系有多少，一律清空再设置。适用于网页后台修改操作
基于对象的跨表查询(子查询)
先来查询id为3的书籍，打印publish和authors是什么？
def add(request): book = Book.objects.filter(id=3).first() print(book.publish) # 查看publish属性 print(book.authors) print(type(book.authors)) # 查看类型 print(book.authors.all()) # 返回所有book的关联对象 print(book.authors.all().values()) # 查看关联对象的值 return HttpResponse('添加成功')
刷新页面，查看控制台信息
Publish object (1) app01.Author.None <class 'django.db.models.fields.related_descriptors.create_forward_many_to_many_manager.<locals>.ManyRelatedManager'> <QuerySet [<Author: Author object (3)>]> <QuerySet [{'name': 'wang', 'age': 27, 'id': 3, 'ad_id': 3}]>
注意：book.authors不能直接print，否则返回的值是None。它是一个多对多的关系管理器，必须用all()才能取值。
book.authors.all() 表示返回所有book的关联对象。注意：这里的book对象，是一个model对象，它是表示id为3的一条记录。从最后一条打印信息中，就可以看出来！
修改book_authors表，添加2条记录
再次刷新页面，查看控制台信息
Publish object (1) app01.Author.None <class 'django.db.models.fields.related_descriptors.create_forward_many_to_many_manager.<locals>.ManyRelatedManager'> <QuerySet [<Author: Author object (1)>, <Author: Author object (2)>, <Author: Author object (3)>]> <QuerySet [{'name': 'xiao', 'id': 1, 'ad_id': 1, 'age': 25}, {'name': 'zhang', 'id': 2, 'ad_id': 2, 'age': 26}, {'name': 'wang', 'id': 3, 'ad_id': 3, 'age': 27}]>
注意最后一条信息，它返回了3个model对象。为什么会返回3条信息呢？
它实际是执行了下面这句SQL
SELECT author.id, author.name, author.age, author.ad_id FROM author INNER JOIN book_authors ON ( author.id = book_authors.author_id ) WHERE book_authors.book_id = 3 LIMIT 21;
因为book的id为3，它先从关系表book_authors，查找book_id=3的记录。此时有3条记录！
再和author表关联查询，找出3个作者的记录。所以最终结果就是author的3条记录！
book.authors.all()是与这本书关联的作者对象queryset对象集合
django有2个日期类型，一个是DateField()，它的格式是yyyy-mm-dd
还有一个类型是DateTimeField()，它的格式是yyyy-mm-dd h:i:s。它是带时分秒的！
python中的datetime
举例：
import datetime now = datetime.datetime.now() print(now) # 当前时间 print(now.today()) # 当前时间 print(now.date()) # 日期 print(now.time()) # 排除日期，取时分秒 print(now.strftime("%Y-%m-%d %H:%I:%S")) # 格式化时间 delta = datetime.timedelta(days=3) # 时间差 print(delta) print(now+delta) # 3天后 print(now-delta) # 3天后
输出：
2018-06-29 20:59:02.741780 2018-06-29 20:59:02.741781 2018-06-29 20:59:02.741780 2018-06-29 20:08:02 3 days, 0:00:00 2018-07-02 20:59:02.741780 2018-06-26 20:59:02.741780
一对多查询（Publish 与 Book）
book_authors表添加2条数据
举例：
查询西游记这本书的出版社的名字
普通写法
先找出这本书，然后取出publish_id。在publish表中，通过publish_id找到对应记录。
def add(request): book = Book.objects.filter(title="西游记").first() publish_id = book.publish_id publish = Publish.objects.filter(id=publish_id).first() print(publish.name) return HttpResponse('添加成功')
刷新网页，查看控制台，输出：
榴莲出版社
推荐写法：
上面的步骤太麻烦了，下面使用简洁写法，2行就搞定了！
def add(request): book = Book.objects.filter(title="西游记").first() print(book.publish.name) return HttpResponse('添加成功')
举例：查询西瓜出版社出版过的所有书籍的名称
def add(request): publish = Publish.objects.filter(name="西瓜出版社").first() # 先找出版社 ret = Book.objects.filter(publish_id=publish.id).values("title") # 再找书籍 print(ret) return HttpResponse('添加成功')
刷新网页，查看控制台，效果同上
上面写的太麻烦，下面来介绍正向查询和反向查询
正向和反向，就看关键字段在哪里？
如果是通过关联字段查询，就是正向。否则是反向！
简单来说：正向，按照字段。反向，按照表名
正向与反向查询
正向查询：关联属性在book表中，所以book对象找出关联出版社对象，正向查询
反向查询：关联属性在book表中，所以publish对象找出关联书籍，正向查询
正向：按字段：publish book -----------> publish <----------- 反向：按表名小写_set() 例如：publish.obj.book_set()
正向查询
还是上面的例子：查询西瓜出版社出版过的所有书籍的名称
简洁写法：
def add(request): publish = Publish.objects.filter(name="西瓜出版社").first() # 先找出版社 # ret = Book.objects.filter(publish_id=publish.id).values("title") # 再找书籍 # print(ret) #正向查询--简洁写法 ret = publish.book_set.all().values("title") print(ret) return HttpResponse('添加成功')
刷新网页，控制台输出：
<QuerySet [{'title': '三国演义'}, {'title': 'python'}]>
推荐使用简洁写法，为什么呢？因为如果表越来越多，那么SQL就非常复杂。使用简洁写法，就能避免！
那么它是如何实现的呢？通过Book模型类的authors属性
authors=models.ManyToManyField(to="Author")
反向查询
举例：查询与西瓜出版社关联的所有书籍的名字
def add(request): publish = Publish.objects.filter(name="西瓜出版社").first() # 先找出版社 ret = publish.book_set.all().values("title") # 再找书籍,过滤title print(ret) return HttpResponse('添加成功')
刷新网页，控制台输出：
<QuerySet [{'title': '三国演义'}, {'title': 'python'}]>
多对多查询 (Author 与 Book)
正向查询：关联属性在book表中，所以book对象找出关联作者集合，正向查询
反向查询：关联属性在book表中，所以author对象找出关联书籍，正向查询
因为记录有多条，所以结尾要加.all()
正向：按字段：authors.all() book -----------> author <----------- 反向：按表名小写_set().all() 例如：author.obj.book_set().all()
正向查询
举例：查询西游记这本书籍的所有作者的姓名和年龄
def add(request): book = Book.objects.filter(title="西游记").first() # 先找书籍 ret = book.authors.all().values("name","age") # 再找作者,过滤name和age print(ret) return HttpResponse('添加成功')
刷新网页，控制台输出：
<QuerySet [{'age': 25, 'name': 'xiao'}]>
反向查询
举例：查询作者xiao出版过的所有书籍名称
def add(request): xiao = Author.objects.filter(name="xiao").first() # 先找作者 ret = xiao.book_set.all().values("title") # 再找书籍,过滤title print(ret) return HttpResponse('添加成功')
刷新网页，控制台输出：
<QuerySet [{'title': 'python'}, {'title': '西游记'}]>
一对一查询(Author 与 AuthorDetail)
正向查询：关联属性在author表中，所以author对象找出关联作者详细信息对象，正向查询
反向查询：关联属性在book表中，所以author对象找出关联书籍，正向查询
因为记录只有一条，所以直接.ad就可以了。ad是关联字段
正向：按字段：.ad author -----------> authordetail <----------- 反向：按表名小写 例如：authordetail_obj.author
正向查询
举例：查询xiao的女朋友的名字
def add(request): xiao = Author.objects.filter(name="xiao").first() # 先找作者 ret = xiao.ad.gf # 再找女朋友 print(ret) return HttpResponse('添加成功')
刷新网页，控制台输出：
赵丽颖
反向查询
举例：查询手机号为112的作者名字
def add(request): phone = AuthorDetail.objects.filter(tel="112").first() # 先找号码 ret = phone.author.name # 再找作者的名字 print(ret)
刷新网页，控制台输出：
wang
周末作业
基于多表的图书管理系统
注意：出版社和作者，是从数据库中读取的。
作业是复选框，可以选择多个
编辑页面，作者一栏的灰色背景。表示现有绑定的作者！
它是选择状，使用selected属性
提示：
视图函数接收复选框的值，需要使用request.POST.getlist()。使用get只能获取一个值！
答案
修改urls.py，添加路径
from django.contrib import admin from django.urls import path,re_path from book import views urlpatterns = [ path('admin/', admin.site.urls), path('', views.index), path('index/', views.index), path('books/add/', views.add), path('books/manage/', views.manage), re_path('books/delete/(?P<id>\d+)', views.delete), re_path('books/modify/(?P<id>\d+)', views.modify), ]
修改settings.py
注册app
INSTALLED_APPS = [ 'django.contrib.admin', 'django.contrib.auth', 'django.contrib.contenttypes', 'django.contrib.sessions', 'django.contrib.messages', 'django.contrib.staticfiles', 'book', ]
指定模板路径
TEMPLATES = [ { 'BACKEND': 'django.template.backends.django.DjangoTemplates', 'DIRS': [os.path.join(BASE_DIR, 'templates')], 'APP_DIRS': True, 'OPTIONS': { 'context_processors': [ 'django.template.context_processors.debug', 'django.template.context_processors.request', 'django.contrib.auth.context_processors.auth', 'django.contrib.messages.context_processors.messages', ], }, }, ]
默认使用sqlite3数据库，有需要的使用其他数据库的，自行更改
指定静态资源路径
STATIC_URL = '/static/' STATICFILES_DIRS=[ os.path.join(BASE_DIR,"static") ]
手动创建templates和static目录。
在static目录创建css目录，下载bootstrap 3.3.7的数据包。将将bootstrap.min.css放到css目录
修改models.py
from django.db import models # Create your models here. class Book(models.Model): title=models.CharField(max_length=32,unique=True) price=models.DecimalField(max_digits=8,decimal_places=2,null=True) pub_date=models.DateField() # 与Publish建立一对多的关系,外键字段建立在多的一方 publish=models.ForeignKey(to="Publish",to_field="id",on_delete=models.CASCADE) # 与Author表建立多对多的关系,ManyToManyField可以建在两个模型中的任意一个，自动创建关系表book_authors authors=models.ManyToManyField(to="Author") class Publish(models.Model): name=models.CharField(max_length=32) email=models.CharField(max_length=32) addr=models.CharField(max_length=32) class Author(models.Model): name=models.CharField(max_length=32) age=models.IntegerField() # 与AuthorDetail建立一对一的关系 # ad=models.ForeignKey(to="AuthorDetail",to_field="id",on_delete=models.CASCADE,unique=True) ad=models.OneToOneField(to="AuthorDetail",to_field="id",on_delete=models.CASCADE,) class AuthorDetail(models.Model): gf=models.CharField(max_length=32) tel=models.CharField(max_length=32)
使用2个命令生成表
python manage.py makemigrations
python manage.py migrate
使用navicat打开sqlite数据库，5个表，添加初始数据
注意修改应用名，因为每个人的应用名不一样！
下面是sql语句：
#作者详情表 INSERT INTO book_authordetail (`id`, `gf`, `tel`) VALUES (1, '赵丽颖',110); INSERT INTO book_authordetail (`id`, `gf`, `tel`) VALUES (2, '刘诗诗',111); INSERT INTO book_authordetail (`id`, `gf`, `tel`) VALUES (3, '唐嫣',112); #作者表 INSERT INTO book_author (`id`, `name`, `age`, `ad_id`) VALUES (1, 'xiao',25,1); INSERT INTO book_author (`id`, `name`, `age`, `ad_id`) VALUES (2, 'zhang',26,2); INSERT INTO book_author (`id`, `name`, `age`, `ad_id`) VALUES (3, 'wang',27,3); #出版社表 INSERT INTO book_publish (`id`, `name`, `email`, `addr`) VALUES (1, '人民教育出版社', '[email protected]', '北京'); INSERT INTO book_publish (`id`, `name`, `email`, `addr`) VALUES (2, '中国农业出版社', '[email protected]', '北京'); INSERT INTO book_publish (`id`, `name`, `email`, `addr`) VALUES (3, '中国林业出版社', '[email protected]', '云南'); #书籍表 INSERT INTO book_book (`id`, `title`, `price`, `pub_date`, `publish_id`) VALUES (1, '西游记',2, '1501-01-23',1); INSERT INTO book_book (`id`, `title`, `price`, `pub_date`, `publish_id`) VALUES (2, '红楼梦',3, '1715-02-13',2); INSERT INTO book_book (`id`, `title`, `price`, `pub_date`, `publish_id`) VALUES (3, '三国演义',4, '1330-03-25',3); #书籍和作者关系表 INSERT INTO book_book_authors (`id`, `book_id`, `author_id`) VALUES (1,1,1); INSERT INTO book_book_authors (`id`, `book_id`, `author_id`) VALUES (2,2,2); INSERT INTO book_book_authors (`id`, `book_id`, `author_id`) VALUES (3,3,3);
修改views.py
from django.shortcuts import render,HttpResponse #导入4个表模型 from book.models import Book,Publish,Author,AuthorDetail # Create your views here. def index(request): #首页 ret = Book.objects.all().exists() # 判断表是否有记录 if ret: book_list = Book.objects.all() # 查询表的所有记录 return render(request, "index.html", {"book_list": book_list}) else: hint = '<script>alert("没有书籍，请添加书籍");window.location.href="/books/add"</script>' return HttpResponse(hint) # js跳转到添加页面 def add(request): # 添加 if request.method=="POST": # print(request.POST) title=request.POST.get("title") the_book = Book.objects.filter(title=title).exists() if the_book: hint = '<script>alert("书籍已存在！不能重复添加");window.location.href="/books/add/"</script>' return HttpResponse(hint) # js跳转到添加页面 else: price=request.POST.get("price") pub_date=request.POST.get("pub_date") publish_id=request.POST.get("publish_id") author_id=request.POST.getlist("author_id") # 返回列表 print(title,price,pub_date,publish_id,author_id) #先插入书籍 book = Book.objects.create(title=title, price=price, pub_date=pub_date, publish_id=publish_id) #再插入作者 book.authors.add(*author_id) hint = '<script>alert("添加成功");window.location.href="/index/"</script>' return HttpResponse(hint) # js跳转到首页 #读取所有出版社，过滤出id和name publish_list = Publish.objects.all().values("id","name") # 读取所有作者，过滤出id和name author_list = Author.objects.all().values("id","name") return render(request, "add.html", {"publish_list": publish_list,"author_list":author_list}) def delete(request,id): # 删除 # 先删除关系表中的作者 book_ad = Book.objects.filter(id=id).first() book_ad.authors.clear() # 再删除书籍 ret = Book.objects.filter(id=id).delete() # 返回元组 print(ret) if ret[0]: # 取值为1的情况下 hint = '<script>alert("删除成功");window.location.href="/index/"</script>' return HttpResponse(hint) else: # 取值为0的情况下 hint = '<script>alert("删除失败");window.location.href="/index/"</script>' return HttpResponse(hint) def manage(request): # 管理页面 ret = Book.objects.all().exists() if ret: book_list = Book.objects.all() #加载管理页面 return render(request, "manage.html", {"book_list": book_list}) else: hint = '<script>alert("没有书籍，请添加书籍");window.location.href="/books/add"</script>' return HttpResponse(hint) def modify(request,id): # 修改 if request.method == "POST": title = request.POST.get("title") price = request.POST.get("price") pub_date = request.POST.get("pub_date") publish_id = request.POST.get("publish_id") author_id = request.POST.getlist("author_id") # 返回列表 # 先修改书籍 ret = Book.objects.filter(id=id).update(title=title, price=price, pub_date=pub_date, publish_id=publish_id) # 获取当前书籍 book_ad = Book.objects.filter(id=id).first() book_ad.authors.set(author_id) # 先清空再设置 if ret: # 判断返回值为1 hint = '<script>alert("修改成功");window.location.href="/index/"</script>' return HttpResponse(hint) # js跳转 else: # 返回为0 hint = '<script>alert("修改失败");window.location.href="/index/"</script>' return HttpResponse(hint) # js跳转 book = Book.objects.get(id=id) # 默认获取id值 # print(book) # 读取所有出版社，过滤出id和name publish_list = Publish.objects.all().values("id", "name") # 读取所有作者，过滤出id和name author_list = Author.objects.all().values("id", "name") the_author = [] # 当前书籍的作者 for i in book.authors.all(): the_author.append(i.name) # 最加到列表中 print(the_author) return render(request, "modify.html", {"book":book,"publish_list": publish_list, "author_list": author_list,"the_author":the_author})
在templates目录新建几个html文件
base.html，这个是所有html的母版文件
<!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> {% block title %} <title>title</title> {% endblock title %} {#bootstrap，版本为3.3.7#} <link rel="stylesheet" href="/static/css/bootstrap.min.css"> {#美化复选框#} <link rel="stylesheet" href="https://cdn.bootcss.com/awesome-bootstrap-checkbox/0.3.7/awesome-bootstrap-checkbox.css"> <link href="http://cdn.bootcss.com/font-awesome/4.6.3/css/font-awesome.min.css" rel="stylesheet"> <style> * { margin: 0; padding: 0; } .header { width: 100%; height: 60px; background-color: #369; } .title { line-height: 60px; color: white; font-weight: 100; margin-left: 20px; font-size: 20px; } .container { margin-top: 20px; } .table th, .table td { text-align: center; vertical-align: middle !important; } </style> </head> <body> <div class="header"> <p class="title"> 图书管理系统 </p> </div> <div class="container"> <div class="row"> <div class="col-md-3"> <div class="panel panel-danger"> <div class="panel-heading"><a href="/index/">查看书籍</a></div> <div class="panel-body"> Panel content </div> </div> <div class="panel panel-success"> <div class="panel-heading"><a href="/books/add/">添加书籍</a></div> <div class="panel-body"> Panel content </div> </div> <div class="panel panel-warning"> <div class="panel-heading"><a href="/books/manage/">管理书籍</a></div> <div class="panel-body"> Panel content </div> </div> </div> <div class="col-md-9"> {% block content %} {% endblock %} </div> </div> </div> </body> </html>
index.html，首页
{% extends 'base.html' %}
{% block title %}
<title>查看书籍</title>
{% endblock title %}
{% block content %}
<h3>查看书籍</h3>
<table class="table table-hover table-striped ">
<thead>
<tr>
<th>编号</th>
<th>书籍名称</th>
<th>价格</th>
<th>出版日期</th>
<th>出版社</th>
<th>作者</th>
</tr>
</thead>
<tbody>
{#遍历所有书籍#}
{% for book in book_list %}
<tr>
<td>{{ book.id }}</td>
<td>{{ book.title }}</td>
<td>{{ book.price }}</td>
<td>{{ book.pub_date|date:"Y-m-d" }}</td>
<td>{{ book.publish.name }}</td>
<td>
{#遍历所有书籍相关的作者#}
{% for j in book.authors.all %}
{#使用forloop.last判断，如果如果是最后一个，不增加逗号#}
{{ j.name }}{% if not forloop.last %},{% endif %}
{% endfor %}
</td>
</tr>
{% endfor %}
</tbody>
</table>
{% endblock content %}
add.html，添加页面
{% extends 'base.html' %}
{% block title %}
<title>添加书籍</title>
{% endblock title %}
{% block content %}
<h3>添加书籍</h3>
<form action="" method="post">
{% csrf_token %}
<div class="form-group">
<label for="">书籍名称</label>
<input type="text" name="title" class="form-control">
</div>
<div class="form-group">
<label for="">价格</label>
<input type="text" name="price" class="form-control">
</div>
<div class="form-group">
<label for="">出版日期</label>
<input type="date" name="pub_date" class="form-control">
</div>
<div class="form-group">
<label for="">出版社</label>
<select name="publish_id" id="" class="form-control">
{#使用for循环遍历所有出版社#}
{% for p in publish_list %}
{#由于表关系是通过id关联的，所以value值必须是id#}
<option value="{{ p.id }}">{{ p.name }}</option>
{% endfor %}
</select>
</div>
<div class="form-group">
<label for="">作者</label>
<ul class="list-group">
{#使用for循环遍历所有作者#}
{% for author in author_list %}
<li class="list-group-item">
<div class="checkbox checkbox-success ">
{#由于表关系是通过id关联的，所以value值必须是id#}
<input class="styled" type="checkbox" name="author_id" value="{{ author.id }}">
<label class="checkbox-inline">
{{ author.name }}
</label>
</div>
</li>
{% endfor %}
</ul>
</div>
<input type="submit" class="btn btn-success pull-right" value="添加">
</form>
{% endblock content %}
manage.html，管理页面，用来删除和修改的
{% extends 'base.html' %}
{% block title %}
<title>管理书籍</title>
{% endblock title %}
{% block content %}
<h3>管理书籍</h3>
<table class="table table-hover table-striped ">
<thead>
<tr>
<th>编号</th>
<th>书籍名称</th>
<th>价格</th>
<th>出版日期</th>
<th>出版社</th>
<th>作者</th>
<th>删除</th>
<th>编辑</th>
</tr>
</thead>
<tbody>
{% for book in book_list %}
<tr>
<td>{{ book.id }}</td>
<td>{{ book.title }}</td>
<td>{{ book.price }}</td>
<td>{{ book.pub_date|date:"Y-m-d" }}</td>
<td>{{ book.publish.name }}</td>
<td>
{#遍历所有书籍相关的作者#}
{% for j in book.authors.all %}
{#使用forloop.last判断，如果如果是最后一个，不增加逗号#}
{{ j.name }}{% if not forloop.last %},{% endif %}
{% endfor %}
</td>
<td>
{#由于表关系是通过id关联的，所以参数必须是id#}
<a href="/books/delete/{{ book.id }}">
<button type="button" class="btn btn-danger" data-toggle="modal" id="modelBtn">删除</button>
</a>
</td>
<td>
<a href="/books/modify/{{ book.id }}">
<button type="button" class="btn btn-success" data-toggle="modal">编辑</button>
</a>
</td>
</tr>
{% endfor %}
</tbody>
</table>
{% endblock content %}
modify.html，修改页面
{% extends 'base.html' %}
{% block title %}
<title>修改书籍</title>
{% endblock title %}
{% block content %}
<h3>修改书籍</h3>
<form action="" method="post">
{% csrf_token %}
<div class="form-group">
<label for="">书籍名称</label>
<input type="text" name="title" class="form-control" value="{{ book.title }}">
</div>
<div class="form-group">
<label for="">价格</label>
<input type="text" name="price" class="form-control" value="{{ book.price }}">
</div>
<div class="form-group">
<label for="">出版日期</label>
<input type="date" name="pub_date" class="form-control" value="{{ book.pub_date|date:"Y-m-d" }}">
</div>
<div class="form-group">
<label for="">出版社</label>
<select name="publish_id" id="" class="form-control">
{#遍历所有出版社#}
{% for p in publish_list %}
{#判断当前书籍的出版社id等于出版社表的id时#}
{% if book.publish_id == p.id %}
{#添加选中状态selected="selected"#}
{#由于表关系是通过id关联的，所以value值必须是id#}
<option value="{{ p.id }}" selected="selected">{{ p.name }}</option>
{% else %}
<option value="{{ p.id }}">{{ p.name }}</option>
{% endif %}
{% endfor %}
</select>
</div>
<div class="form-group">
<label for="">作者</label>
<ul class="list-group">
{% for author in author_list %}
<li class="list-group-item">
<div class="checkbox checkbox-success ">
{#判断作者的名字在当前书籍作者列表中#}
{% if author.name in the_author %}
{#添加选中状态checked="checked"#}
{#由于表关系是通过id关联的，所以value值必须是id#}
<input class="styled" type="checkbox" checked="checked" name="author_id"
value="{{ author.id }}">
<label class="checkbox-inline">{{ author.name }}</label>
{% else %}
<input class="styled" type="checkbox" name="author_id" value="{{ author.id }}">
<label class="checkbox-inline">{{ author.name }}</label>
{% endif %}
</div>
</li>
{% endfor %}
</ul>
</div>
<input type="submit" class="btn btn-default pull-right" value="修改">
</form>
{% endblock content %}
项目文件结构如下：
bms_mto ├── bms_mto │ ├── __init__.py │ ├── settings.py │ ├── urls.py │ └── wsgi.py ├── book │ ├── admin.py │ ├── apps.py │ ├── __init__.py │ ├── models.py │ ├── tests.py │ └── views.py ├── db.sqlite3 ├── manage.py ├── static │ └── css │ ├── bootstrap.min.css └── templates ├── add.html ├── base.html ├── index.html ├── manage.html └── modify.html
启动项目访问首页：http://127.0.0.1:8000/
点击左侧的添加书籍
添加一本书，选择2个作者
提示添加成功
首页就会多一本书籍
点击编辑按钮
修改价格，增加一个作者
提示修改成功
首页的书籍，价格和作者更新过来了
点击删除
提示删除成功
首页少了一条数据
参考资料：
转载声明：
作者：肖祥
出处： https://www.cnblogs.com/xiao987334176/
昨日内容回顾
多表方案： 如何确定表关系呢？ 表关系是在2张表之间建立的，没有超过2个表的情况。 那么相互之间有2条关系线，先来判断一对多的关系。 如果其中一张表的记录能够对应另外一张表的多条记录，那么关系线成立！ 如果只有一条线成立，那么就是一对多的关系。 如果有2条线成立，那么就是多对多的关系。 比如book和publish。一本书不能对应多个出版社(常规是这样的,否则就盗版了),那么不成立。 一个出版社可以对应多本书，关系线成立。所以book和publish表的关系是一对多的关系 多对多的关系，就是2张表互相对应多条记录。 比如book和author。一本书可以有多个作者，一个作者可以写多本！ 一对一的关系，就很简单了，彼此唯一。 比如author和authordetail是一对一的关系。 一对多： book和publish表的关系是一对多的关系 一旦确定一对多的关系：在多的表中创建关联字段 # 与Publish建立一对多的关系,外键字段建立在多的一方 publish=models.ForeignKey(to="Publish",to_field="id",on_delete=models.CASCADE) #创建的字段名为publish_id。它会自动加_id后缀 多对多： book和author是多对多的关系 一旦确定多对多的关系：创建第三张关系表 # 与Author表建立多对多的关系,ManyToManyField可以建在两个模型中的任意一个，自动创建第三张表 authors=models.ManyToManyField(to="Author") #注意：表名为应用名+book类名小写+authors，也就是book_authors。 #它只有3个字段,分别是主键id,book_id,author_id。 #book_id和author_id分别表示book表和author表的主键id 一对一： author和authordetail是一对一的关系 一旦确定一对一的关系 ： 创建关联字段(任意一张表创建都可以) #但是一般，我们会判断谁是重要的，谁是次要的。在重要的表上面创建关联字段！比如author #由于authordetail表是author表的延伸，所以在author表创建关联字段 # 与AuthorDetail建立一对一的关系 ad=models.OneToOneField(to="AuthorDetail",to_field="id",on_delete=models.CASCADE,) #创建的字段名为ad_id，它会自动加_id后缀。一对一关联字段，必须设置唯一属性！
一、django多表添加
昨天已经把5张表，都创建出来了。models.py里面有4个模型，其中第5张表，是book表和author表的关系表。
由book类的authors属性来创建了关系表，表名为：应用名+book+'_'+authors。
修改urls.py，添加add路径
from app01 import views urlpatterns = [ path('admin/', admin.site.urls), path('add/', views.add), ]
由于pycharm对sqlite数据库的时间字段，添加时，会自动转换为时间戳。
这样很不好，所以我使用navicat来连接。
新建一个连接
找到表publish
添加2条记录
添加表记录
create(**kwargs) 建立新对象
返回值是添加的model对象
一对一
举例：添加一条作者信息
姓名=hong，年龄=25，女朋友=唐安琪，电话=1314
def add(request): #先添加作者详细信息 hong_gf = AuthorDetail.objects.create(gf="唐安琪",tel=1314) #再添加作者，因为它依赖AuthorDetail表 hong = Author.objects.create(name="hong",age="25",ad=hong_gf) print(hong) return HttpResponse('添加成功')
注意：因为author的ad属性是关联authordetail表，必须添加authordetail表，才能添加author表。
ad必须接收一个model对象。可以从这个model对象中，获取插入的id值。
刷新页面，查看authordetail表，发现多了一条记录
查看author表，发现多了一条记录
一对多
方式1（推荐）
修改views.py，增加add视图函数
from django.shortcuts import render,HttpResponse from app01.models import Book # Create your views here. def add(request): #publish_id就是Book类的publish属性。它的字段为publish_id book = Book.objects.create(title='西游记',price=100,pub_date="1743-4-12",publish_id=2) print(book.title) #打印title return HttpResponse('添加成功')
访问url：http://127.0.0.1:8000/add/
查看book表记录，发现多了一条
方式2
添加一本书《三国演义》，指定出版社为西瓜出版社
首要要导入Publish
def add(request): xigua = Publish.objects.filter(name="西瓜出版社").first() #model对象 book = Book.objects.create(title='三国演义',price=300,pub_date="1643-4-12",publish=xigua) print(book.title) #打印标题 print(book.publish) # 与这本书籍关联的出版社对象 print(type(book.publish)) # 打印属性 print(book.publish.id) # 出版社id print(book.publish.name) # 出版社name return HttpResponse('添加成功')
注意：xigua它是一个model对象，它表示publish表的一条记录
create里面的publish只能接收publish表的model对象，不能接收别的表model对象！
查看models.py的Book类的publish属性
publish=models.ForeignKey(to="Publish",to_field="id",on_delete=models.CASCADE)
注意：它只能接收publish表的id字段。
所以执行sql时，它相当于publish_id=xigua.id。
这种添加方式，有严格的限制，必须接收publish的model对象才可以的。不推荐使用
查看控制台信息：
三国演义 [29/Jun/2018 16:47:44] "GET /add/ HTTP/1.1" 200 12 Publish object (1) <class 'app01.models.Publish'> 1 西瓜出版社
book.publish 是与这本书籍关联的出版社对象
那么就可以得到出版社的id和name属性值
查看表记录，发现多了一条
现在书籍和作者还没有绑定关系，先增加作者详细记录
修改authordetail表，增加2条记录
修改author表，增加2条记录
多对多
现在需要在book表里面插入一本书《python》，这本书有2个作者。那么book_authors应该有2条记录
它应该是这样的
id book_id author_id
1 3 1
2 3 2
那么如何将这2条记录，插入进去呢？
修改add视图函数，注意导入author类
先插入一条记录
book = Book.objects.create(title='python',price=122,pub_date="2012-12-12",publish_id=1)
再获取2个作者
xiao = Author.objects.filter(name="xiao").first() zhang = Author.objects.filter(name="zhang").first()
最后插入2条记录，注意：下面2行代码是不能执行的，它是伪代码！
book_authors.objects.create(book_id=book.id,author_id=xiao.id)
book_authors.objects.create(book_id=book.id, author_id=zhang.id)
上面2行代码表示在book_authors表中添加2条记录，只增加book_id和author_id。
那么问题来了，book_authors这张表是用orm创建的
但是orm的models.py里面找不到book_authors这张表的模型类。如果存在的话，那肯定没有问题的。
因为第3张表，是在book类里面的authors属性，用ManyToManyField创建的
因为一本书，对应的不止一个作者，所以不能直接赋值操作。
add() 增加多个关系对象
使用方法1：add(obj1, obj2, ...)
ORM提供了add方法，来添加多对多的关系表。
def add(request): book = Book.objects.create(title='python',price=122,pub_date="2012-12-12",publish_id=1) xiao = Author.objects.filter(name="xiao").first() zhang = Author.objects.filter(name="zhang").first() book.authors.add(xiao,zhang) # 添加2条数据,接收一个参数，就会产生一条记录 return HttpResponse('添加成功')
注意：book.authors.add(xiao,zhang)，相当于执行上面2句伪代码！
它会自动获取2个对象的主键id，并插入到对应的字段中。
刷新页面，查看book表，发现多了一条记录
查看book_authors表，发现多2条数据
如果需要为书籍绑定所有作者呢？
author_list = Author.objects.all()
book.authors.add(*author_list)
上面2行代码，就搞定了，非常简洁！
使用方法2：add(主键1, 主键2, ...)
下面这种写法，也是可以的。在html表单页面添加时，会用到此写法！
book.authors.add(1,2)
还有一种写法，是属于python的。*[1,2]，表示打散。它相当于上面的写法
book.authors.add(*[1,2])
区别在于：add(1,2)这种写法，它是执行了2次，在book_authors表中插入2条记录。
那么在不知道有多少数值的情况下，需要使用*[args1,args2]这种写法。
注意：在html表单中的复选框中，它提交的数据是多个值，必须使用getlist方法获取，它是列表类型。
因为不知道用户，到底会选择多少个选项。所以就需要使用这种打散写法！
删除记录
remove(obj1, obj2, ...) 去除多个关系对象
举例：删除python这本书的xiao作者
那么只需要删除book_authors表，id为1的这一条记录，就可以了
但是，不能直接对这张表，直接删除。因为它是2个表的关联表。
解除绑定的关系
def add(request): book = Book.objects.filter(id=3).first() # 先找到这本书 xiao = Author.objects.filter(name="xiao").first() # 再找到作者 book.authors.remove(xiao) # 解除绑定的关系 return HttpResponse('添加成功')
刷新页面，查看book_authors表记录，发现作者没有了
注意：这里可不是级联删除，book_authors并没有on_delete=models.CASCADE属性
clear() 清理所有关系对象
修改book_authors表记录，添加1条记录
举例：将book_id等于3的所有的作者删除
上面的例子，用remove，可以将一个删除。如果这本书，有5个作者呢？
一个个remove？太累了！django提供了clear方法，可以清理所有关系对象。
def add(request): book = Book.objects.filter(id=3).first() book.authors.clear() # 清理所有关系对象 return HttpResponse('添加成功')
刷新页面，再次查看book_authors表记录，发现已经空了！
修改authordetail表，增加一条记录
修改author表，增加一条记录
修改book_authors表，增加3条数据
set([obj1,obj2...]) 先清空再设置
set([obj1,obj2,...]) 它接收多个值，可以一个，也可以多个。适用于后台网页修改操作！
举例：
python这本书目前有3个作者，将wang设置为这本书的唯一作者
怎么做呢？将另外2个作者解除关系就可以了。
def add(request): book = Book.objects.filter(id=3).first() # 先找到书 xiao = Author.objects.filter(name="xiao").first() # 再找到作者 zhang = Author.objects.filter(name="zhang").first() book.authors.remove(xiao,zhang) # 解除绑定的关系 return HttpResponse('添加成功')
但是这样将2个作者解除，太麻烦了。
还有一种做法，先清空，再设置
def add(request): book = Book.objects.filter(id=3).first() # 先找到书 book.authors.clear() # 清理所有关系对象 wang = Author.objects.filter(name="wang").first() book.authors.add(wang) return HttpResponse('添加成功')
django提示了set方法，直接合并了先清空再设置的操作
它必须接收一个数组，因为可以接收多个值
def add(request): book = Book.objects.filter(id=3).first() # 先找到书 wang = Author.objects.filter(name="wang").first() # 再找作者 book.authors.set([wang]) #先清空再设置 return HttpResponse('添加成功')
刷新页面，查看book_authors表记录，发现只有一条了
总结：
重点掌握create，add，remove，clear，set这五个方法！
添加表记录：
一对一和一对多，使用create方法。它有2种使用方法：
1. create(字段名1=值1...)。适用于表单添加操作！注意，这里面的字段名是ORM创建表之后的的字段名
比如: book类的publish属性，它是关联字段，ORM创建之后，字段名为publish_id
2.create(模型类属性1=值1...)。比如book类的publish属性，它是关联字段。
直接create(publish=obj1)，注意，它接收一个model对象，对象包含了主键id
多对多使用add方法。add用2种使用方法：
1.add(obj1，obj2...) 它接收一个model对象，对象包含了主键id
2.add(主键id1，主键id2...) 它接收一个主键id。适用于表单添加操作！
还有一个python的打散语法，前面加一个*就可以了。比如*[1,2]，它会依次调用前置方法，每次只取一个值。表单操作，会用到！
删除记录：
适用于一对一，一对多，多对一。
remove(obj1, obj2, ...) 去除多个关系对象。它需要指定一个或者多个对象
clear() 清理所有关系对象。不管现有的关系有多少，一律清空！
set([obj1,obj2...]) 先清空再设置。不管现有的关系有多少，一律清空再设置。适用于网页后台修改操作
基于对象的跨表查询(子查询)
先来查询id为3的书籍，打印publish和authors是什么？
def add(request): book = Book.objects.filter(id=3).first() print(book.publish) # 查看publish属性 print(book.authors) print(type(book.authors)) # 查看类型 print(book.authors.all()) # 返回所有book的关联对象 print(book.authors.all().values()) # 查看关联对象的值 return HttpResponse('添加成功')
刷新页面，查看控制台信息
Publish object (1) app01.Author.None <class 'django.db.models.fields.related_descriptors.create_forward_many_to_many_manager.<locals>.ManyRelatedManager'> <QuerySet [<Author: Author object (3)>]> <QuerySet [{'name': 'wang', 'age': 27, 'id': 3, 'ad_id': 3}]>
注意：book.authors不能直接print，否则返回的值是None。它是一个多对多的关系管理器，必须用all()才能取值。
book.authors.all() 表示返回所有book的关联对象。注意：这里的book对象，是一个model对象，它是表示id为3的一条记录。从最后一条打印信息中，就可以看出来！
修改book_authors表，添加2条记录
再次刷新页面，查看控制台信息
Publish object (1) app01.Author.None <class 'django.db.models.fields.related_descriptors.create_forward_many_to_many_manager.<locals>.ManyRelatedManager'> <QuerySet [<Author: Author object (1)>, <Author: Author object (2)>, <Author: Author object (3)>]> <QuerySet [{'name': 'xiao', 'id': 1, 'ad_id': 1, 'age': 25}, {'name': 'zhang', 'id': 2, 'ad_id': 2, 'age': 26}, {'name': 'wang', 'id': 3, 'ad_id': 3, 'age': 27}]>
注意最后一条信息，它返回了3个model对象。为什么会返回3条信息呢？
它实际是执行了下面这句SQL
SELECT author.id, author.name, author.age, author.ad_id FROM author INNER JOIN book_authors ON ( author.id = book_authors.author_id ) WHERE book_authors.book_id = 3 LIMIT 21;
因为book的id为3，它先从关系表book_authors，查找book_id=3的记录。此时有3条记录！
再和author表关联查询，找出3个作者的记录。所以最终结果就是author的3条记录！
book.authors.all()是与这本书关联的作者对象queryset对象集合
django有2个日期类型，一个是DateField()，它的格式是yyyy-mm-dd
还有一个类型是DateTimeField()，它的格式是yyyy-mm-dd h:i:s。它是带时分秒的！
python中的datetime
举例：
import datetime now = datetime.datetime.now() print(now) # 当前时间 print(now.today()) # 当前时间 print(now.date()) # 日期 print(now.time()) # 排除日期，取时分秒 print(now.strftime("%Y-%m-%d %H:%I:%S")) # 格式化时间 delta = datetime.timedelta(days=3) # 时间差 print(delta) print(now+delta) # 3天后 print(now-delta) # 3天后
输出：
2018-06-29 20:59:02.741780 2018-06-29 20:59:02.741781 2018-06-29 20:59:02.741780 2018-06-29 20:08:02 3 days, 0:00:00 2018-07-02 20:59:02.741780 2018-06-26 20:59:02.741780
一对多查询（Publish 与 Book）
book_authors表添加2条数据
举例：
查询西游记这本书的出版社的名字
普通写法
先找出这本书，然后取出publish_id。在publish表中，通过publish_id找到对应记录。
def add(request): book = Book.objects.filter(title="西游记").first() publish_id = book.publish_id publish = Publish.objects.filter(id=publish_id).first() print(publish.name) return HttpResponse('添加成功')
刷新网页，查看控制台，输出：
榴莲出版社
推荐写法：
上面的步骤太麻烦了，下面使用简洁写法，2行就搞定了！
def add(request): book = Book.objects.filter(title="西游记").first() print(book.publish.name) return HttpResponse('添加成功')
举例：查询西瓜出版社出版过的所有书籍的名称
def add(request): publish = Publish.objects.filter(name="西瓜出版社").first() # 先找出版社 ret = Book.objects.filter(publish_id=publish.id).values("title") # 再找书籍 print(ret) return HttpResponse('添加成功')
刷新网页，查看控制台，效果同上
上面写的太麻烦，下面来介绍正向查询和反向查询
正向和反向，就看关键字段在哪里？
如果是通过关联字段查询，就是正向。否则是反向！
简单来说：正向，按照字段。反向，按照表名
正向与反向查询
正向查询：关联属性在book表中，所以book对象找出关联出版社对象，正向查询
反向查询：关联属性在book表中，所以publish对象找出关联书籍，正向查询
正向：按字段：publish book -----------> publish <----------- 反向：按表名小写_set() 例如：publish.obj.book_set()
正向查询
还是上面的例子：查询西瓜出版社出版过的所有书籍的名称
简洁写法：
def add(request): publish = Publish.objects.filter(name="西瓜出版社").first() # 先找出版社 # ret = Book.objects.filter(publish_id=publish.id).values("title") # 再找书籍 # print(ret) #正向查询--简洁写法 ret = publish.book_set.all().values("title") print(ret) return HttpResponse('添加成功')
刷新网页，控制台输出：
<QuerySet [{'title': '三国演义'}, {'title': 'python'}]>
推荐使用简洁写法，为什么呢？因为如果表越来越多，那么SQL就非常复杂。使用简洁写法，就能避免！
那么它是如何实现的呢？通过Book模型类的authors属性
authors=models.ManyToManyField(to="Author")
反向查询
举例：查询与西瓜出版社关联的所有书籍的名字
def add(request): publish = Publish.objects.filter(name="西瓜出版社").first() # 先找出版社 ret = publish.book_set.all().values("title") # 再找书籍,过滤title print(ret) return HttpResponse('添加成功')
刷新网页，控制台输出：
<QuerySet [{'title': '三国演义'}, {'title': 'python'}]>
多对多查询 (Author 与 Book)
正向查询：关联属性在book表中，所以book对象找出关联作者集合，正向查询
反向查询：关联属性在book表中，所以author对象找出关联书籍，正向查询
因为记录有多条，所以结尾要加.all()
正向：按字段：authors.all() book -----------> author <----------- 反向：按表名小写_set().all() 例如：author.obj.book_set().all()
正向查询
举例：查询西游记这本书籍的所有作者的姓名和年龄
def add(request): book = Book.objects.filter(title="西游记").first() # 先找书籍 ret = book.authors.all().values("name","age") # 再找作者,过滤name和age print(ret) return HttpResponse('添加成功')
刷新网页，控制台输出：
<QuerySet [{'age': 25, 'name': 'xiao'}]>
反向查询
举例：查询作者xiao出版过的所有书籍名称
def add(request): xiao = Author.objects.filter(name="xiao").first() # 先找作者 ret = xiao.book_set.all().values("title") # 再找书籍,过滤title print(ret) return HttpResponse('添加成功')
刷新网页，控制台输出：
<QuerySet [{'title': 'python'}, {'title': '西游记'}]>
一对一查询(Author 与 AuthorDetail)
正向查询：关联属性在author表中，所以author对象找出关联作者详细信息对象，正向查询
反向查询：关联属性在book表中，所以author对象找出关联书籍，正向查询
因为记录只有一条，所以直接.ad就可以了。ad是关联字段
正向：按字段：.ad author -----------> authordetail <----------- 反向：按表名小写 例如：authordetail_obj.author
正向查询
举例：查询xiao的女朋友的名字
def add(request): xiao = Author.objects.filter(name="xiao").first() # 先找作者 ret = xiao.ad.gf # 再找女朋友 print(ret) return HttpResponse('添加成功')
刷新网页，控制台输出：
赵丽颖
反向查询
举例：查询手机号为112的作者名字
def add(request): phone = AuthorDetail.objects.filter(tel="112").first() # 先找号码 ret = phone.author.name # 再找作者的名字 print(ret)
刷新网页，控制台输出：
wang
周末作业
基于多表的图书管理系统
注意：出版社和作者，是从数据库中读取的。
作业是复选框，可以选择多个
编辑页面，作者一栏的灰色背景。表示现有绑定的作者！
它是选择状，使用selected属性
提示：
视图函数接收复选框的值，需要使用request.POST.getlist()。使用get只能获取一个值！
答案
修改urls.py，添加路径
from django.contrib import admin from django.urls import path,re_path from book import views urlpatterns = [ path('admin/', admin.site.urls), path('', views.index), path('index/', views.index), path('books/add/', views.add), path('books/manage/', views.manage), re_path('books/delete/(?P<id>\d+)', views.delete), re_path('books/modify/(?P<id>\d+)', views.modify), ]
修改settings.py
注册app
INSTALLED_APPS = [ 'django.contrib.admin', 'django.contrib.auth', 'django.contrib.contenttypes', 'django.contrib.sessions', 'django.contrib.messages', 'django.contrib.staticfiles', 'book', ]
指定模板路径
TEMPLATES = [ { 'BACKEND': 'django.template.backends.django.DjangoTemplates', 'DIRS': [os.path.join(BASE_DIR, 'templates')], 'APP_DIRS': True, 'OPTIONS': { 'context_processors': [ 'django.template.context_processors.debug', 'django.template.context_processors.request', 'django.contrib.auth.context_processors.auth', 'django.contrib.messages.context_processors.messages', ], }, }, ]
默认使用sqlite3数据库，有需要的使用其他数据库的，自行更改
指定静态资源路径
STATIC_URL = '/static/' STATICFILES_DIRS=[ os.path.join(BASE_DIR,"static") ]
手动创建templates和static目录。
在static目录创建css目录，下载bootstrap 3.3.7的数据包。将将bootstrap.min.css放到css目录
修改models.py
from django.db import models # Create your models here. class Book(models.Model): title=models.CharField(max_length=32,unique=True) price=models.DecimalField(max_digits=8,decimal_places=2,null=True) pub_date=models.DateField() # 与Publish建立一对多的关系,外键字段建立在多的一方 publish=models.ForeignKey(to="Publish",to_field="id",on_delete=models.CASCADE) # 与Author表建立多对多的关系,ManyToManyField可以建在两个模型中的任意一个，自动创建关系表book_authors authors=models.ManyToManyField(to="Author") class Publish(models.Model): name=models.CharField(max_length=32) email=models.CharField(max_length=32) addr=models.CharField(max_length=32) class Author(models.Model): name=models.CharField(max_length=32) age=models.IntegerField() # 与AuthorDetail建立一对一的关系 # ad=models.ForeignKey(to="AuthorDetail",to_field="id",on_delete=models.CASCADE,unique=True) ad=models.OneToOneField(to="AuthorDetail",to_field="id",on_delete=models.CASCADE,) class AuthorDetail(models.Model): gf=models.CharField(max_length=32) tel=models.CharField(max_length=32)
使用2个命令生成表
python manage.py makemigrations
python manage.py migrate
使用navicat打开sqlite数据库，5个表，添加初始数据
注意修改应用名，因为每个人的应用名不一样！
下面是sql语句：
#作者详情表 INSERT INTO book_authordetail (`id`, `gf`, `tel`) VALUES (1, '赵丽颖',110); INSERT INTO book_authordetail (`id`, `gf`, `tel`) VALUES (2, '刘诗诗',111); INSERT INTO book_authordetail (`id`, `gf`, `tel`) VALUES (3, '唐嫣',112); #作者表 INSERT INTO book_author (`id`, `name`, `age`, `ad_id`) VALUES (1, 'xiao',25,1); INSERT INTO book_author (`id`, `name`, `age`, `ad_id`) VALUES (2, 'zhang',26,2); INSERT INTO book_author (`id`, `name`, `age`, `ad_id`) VALUES (3, 'wang',27,3); #出版社表 INSERT INTO book_publish (`id`, `name`, `email`, `addr`) VALUES (1, '人民教育出版社', '[email protected]', '北京'); INSERT INTO book_publish (`id`, `name`, `email`, `addr`) VALUES (2, '中国农业出版社', '[email protected]', '北京'); INSERT INTO book_publish (`id`, `name`, `email`, `addr`) VALUES (3, '中国林业出版社', '[email protected]', '云南'); #书籍表 INSERT INTO book_book (`id`, `title`, `price`, `pub_date`, `publish_id`) VALUES (1, '西游记',2, '1501-01-23',1); INSERT INTO book_book (`id`, `title`, `price`, `pub_date`, `publish_id`) VALUES (2, '红楼梦',3, '1715-02-13',2); INSERT INTO book_book (`id`, `title`, `price`, `pub_date`, `publish_id`) VALUES (3, '三国演义',4, '1330-03-25',3); #书籍和作者关系表 INSERT INTO book_book_authors (`id`, `book_id`, `author_id`) VALUES (1,1,1); INSERT INTO book_book_authors (`id`, `book_id`, `author_id`) VALUES (2,2,2); INSERT INTO book_book_authors (`id`, `book_id`, `author_id`) VALUES (3,3,3);
修改views.py
from django.shortcuts import render,HttpResponse #导入4个表模型 from book.models import Book,Publish,Author,AuthorDetail # Create your views here. def index(request): #首页 ret = Book.objects.all().exists() # 判断表是否有记录 if ret: book_list = Book.objects.all() # 查询表的所有记录 return render(request, "index.html", {"book_list": book_list}) else: hint = '<script>alert("没有书籍，请添加书籍");window.location.href="/books/add"</script>' return HttpResponse(hint) # js跳转到添加页面 def add(request): # 添加 if request.method=="POST": # print(request.POST) title=request.POST.get("title") the_book = Book.objects.filter(title=title).exists() if the_book: hint = '<script>alert("书籍已存在！不能重复添加");window.location.href="/books/add/"</script>' return HttpResponse(hint) # js跳转到添加页面 else: price=request.POST.get("price") pub_date=request.POST.get("pub_date") publish_id=request.POST.get("publish_id") author_id=request.POST.getlist("author_id") # 返回列表 print(title,price,pub_date,publish_id,author_id) #先插入书籍 book = Book.objects.create(title=title, price=price, pub_date=pub_date, publish_id=publish_id) #再插入作者 book.authors.add(*author_id) hint = '<script>alert("添加成功");window.location.href="/index/"</script>' return HttpResponse(hint) # js跳转到首页 #读取所有出版社，过滤出id和name publish_list = Publish.objects.all().values("id","name") # 读取所有作者，过滤出id和name author_list = Author.objects.all().values("id","name") return render(request, "add.html", {"publish_list": publish_list,"author_list":author_list}) def delete(request,id): # 删除 # 先删除关系表中的作者 book_ad = Book.objects.filter(id=id).first() book_ad.authors.clear() # 再删除书籍 ret = Book.objects.filter(id=id).delete() # 返回元组 print(ret) if ret[0]: # 取值为1的情况下 hint = '<script>alert("删除成功");window.location.href="/index/"</script>' return HttpResponse(hint) else: # 取值为0的情况下 hint = '<script>alert("删除失败");window.location.href="/index/"</script>' return HttpResponse(hint) def manage(request): # 管理页面 ret = Book.objects.all().exists() if ret: book_list = Book.objects.all() #加载管理页面 return render(request, "manage.html", {"book_list": book_list}) else: hint = '<script>alert("没有书籍，请添加书籍");window.location.href="/books/add"</script>' return HttpResponse(hint) def modify(request,id): # 修改 if request.method == "POST": title = request.POST.get("title") price = request.POST.get("price") pub_date = request.POST.get("pub_date") publish_id = request.POST.get("publish_id") author_id = request.POST.getlist("author_id") # 返回列表 # 先修改书籍 ret = Book.objects.filter(id=id).update(title=title, price=price, pub_date=pub_date, publish_id=publish_id) # 获取当前书籍 book_ad = Book.objects.filter(id=id).first() book_ad.authors.set(author_id) # 先清空再设置 if ret: # 判断返回值为1 hint = '<script>alert("修改成功");window.location.href="/index/"</script>' return HttpResponse(hint) # js跳转 else: # 返回为0 hint = '<script>alert("修改失败");window.location.href="/index/"</script>' return HttpResponse(hint) # js跳转 book = Book.objects.get(id=id) # 默认获取id值 # print(book) # 读取所有出版社，过滤出id和name publish_list = Publish.objects.all().values("id", "name") # 读取所有作者，过滤出id和name author_list = Author.objects.all().values("id", "name") the_author = [] # 当前书籍的作者 for i in book.authors.all(): the_author.append(i.name) # 最加到列表中 print(the_author) return render(request, "modify.html", {"book":book,"publish_list": publish_list, "author_list": author_list,"the_author":the_author})
在templates目录新建几个html文件
base.html，这个是所有html的母版文件
<!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> {% block title %} <title>title</title> {% endblock title %} {#bootstrap，版本为3.3.7#} <link rel="stylesheet" href="/static/css/bootstrap.min.css"> {#美化复选框#} <link rel="stylesheet" href="https://cdn.bootcss.com/awesome-bootstrap-checkbox/0.3.7/awesome-bootstrap-checkbox.css"> <link href="http://cdn.bootcss.com/font-awesome/4.6.3/css/font-awesome.min.css" rel="stylesheet"> <style> * { margin: 0; padding: 0; } .header { width: 100%; height: 60px; background-color: #369; } .title { line-height: 60px; color: white; font-weight: 100; margin-left: 20px; font-size: 20px; } .container { margin-top: 20px; } .table th, .table td { text-align: center; vertical-align: middle !important; } </style> </head> <body> <div class="header"> <p class="title"> 图书管理系统 </p> </div> <div class="container"> <div class="row"> <div class="col-md-3"> <div class="panel panel-danger"> <div class="panel-heading"><a href="/index/">查看书籍</a></div> <div class="panel-body"> Panel content </div> </div> <div class="panel panel-success"> <div class="panel-heading"><a href="/books/add/">添加书籍</a></div> <div class="panel-body"> Panel content </div> </div> <div class="panel panel-warning"> <div class="panel-heading"><a href="/books/manage/">管理书籍</a></div> <div class="panel-body"> Panel content </div> </div> </div> <div class="col-md-9"> {% block content %} {% endblock %} </div> </div> </div> </body> </html>
index.html，首页
{% extends 'base.html' %}
{% block title %}
<title>查看书籍</title>
{% endblock title %}
{% block content %}
<h3>查看书籍</h3>
<table class="table table-hover table-striped ">
<thead>
<tr>
<th>编号</th>
<th>书籍名称</th>
<th>价格</th>
<th>出版日期</th>
<th>出版社</th>
<th>作者</th>
</tr>
</thead>
<tbody>
{#遍历所有书籍#}
{% for book in book_list %}
<tr>
<td>{{ book.id }}</td>
<td>{{ book.title }}</td>
<td>{{ book.price }}</td>
<td>{{ book.pub_date|date:"Y-m-d" }}</td>
<td>{{ book.publish.name }}</td>
<td>
{#遍历所有书籍相关的作者#}
{% for j in book.authors.all %}
{#使用forloop.last判断，如果如果是最后一个，不增加逗号#}
{{ j.name }}{% if not forloop.last %},{% endif %}
{% endfor %}
</td>
</tr>
{% endfor %}
</tbody>
</table>
{% endblock content %}
add.html，添加页面
{% extends 'base.html' %}
{% block title %}
<title>添加书籍</title>
{% endblock title %}
{% block content %}
<h3>添加书籍</h3>
<form action="" method="post">
{% csrf_token %}
<div class="form-group">
<label for="">书籍名称</label>
<input type="text" name="title" class="form-control">
</div>
<div class="form-group">
<label for="">价格</label>
<input type="text" name="price" class="form-control">
</div>
<div class="form-group">
<label for="">出版日期</label>
<input type="date" name="pub_date" class="form-control">
</div>
<div class="form-group">
<label for="">出版社</label>
<select name="publish_id" id="" class="form-control">
{#使用for循环遍历所有出版社#}
{% for p in publish_list %}
{#由于表关系是通过id关联的，所以value值必须是id#}
<option value="{{ p.id }}">{{ p.name }}</option>
{% endfor %}
</select>
</div>
<div class="form-group">
<label for="">作者</label>
<ul class="list-group">
{#使用for循环遍历所有作者#}
{% for author in author_list %}
<li class="list-group-item">
<div class="checkbox checkbox-success ">
{#由于表关系是通过id关联的，所以value值必须是id#}
<input class="styled" type="checkbox" name="author_id" value="{{ author.id }}">
<label class="checkbox-inline">
{{ author.name }}
</label>
</div>
</li>
{% endfor %}
</ul>
</div>
<input type="submit" class="btn btn-success pull-right" value="添加">
</form>
{% endblock content %}
manage.html，管理页面，用来删除和修改的
{% extends 'base.html' %}
{% block title %}
<title>管理书籍</title>
{% endblock title %}
{% block content %}
<h3>管理书籍</h3>
<table class="table table-hover table-striped ">
<thead>
<tr>
<th>编号</th>
<th>书籍名称</th>
<th>价格</th>
<th>出版日期</th>
<th>出版社</th>
<th>作者</th>
<th>删除</th>
<th>编辑</th>
</tr>
</thead>
<tbody>
{% for book in book_list %}
<tr>
<td>{{ book.id }}</td>
<td>{{ book.title }}</td>
<td>{{ book.price }}</td>
<td>{{ book.pub_date|date:"Y-m-d" }}</td>
<td>{{ book.publish.name }}</td>
<td>
{#遍历所有书籍相关的作者#}
{% for j in book.authors.all %}
{#使用forloop.last判断，如果如果是最后一个，不增加逗号#}
{{ j.name }}{% if not forloop.last %},{% endif %}
{% endfor %}
</td>
<td>
{#由于表关系是通过id关联的，所以参数必须是id#}
<a href="/books/delete/{{ book.id }}">
<button type="button" class="btn btn-danger" data-toggle="modal" id="modelBtn">删除</button>
</a>
</td>
<td>
<a href="/books/modify/{{ book.id }}">
<button type="button" class="btn btn-success" data-toggle="modal">编辑</button>
</a>
</td>
</tr>
{% endfor %}
</tbody>
</table>
{% endblock content %}
modify.html，修改页面
{% extends 'base.html' %}
{% block title %}
<title>修改书籍</title>
{% endblock title %}
{% block content %}
<h3>修改书籍</h3>
<form action="" method="post">
{% csrf_token %}
<div class="form-group">
<label for="">书籍名称</label>
<input type="text" name="title" class="form-control" value="{{ book.title }}">
</div>
<div class="form-group">
<label for="">价格</label>
<input type="text" name="price" class="form-control" value="{{ book.price }}">
</div>
<div class="form-group">
<label for="">出版日期</label>
<input type="date" name="pub_date" class="form-control" value="{{ book.pub_date|date:"Y-m-d" }}">
</div>
<div class="form-group">
<label for="">出版社</label>
<select name="publish_id" id="" class="form-control">
{#遍历所有出版社#}
{% for p in publish_list %}
{#判断当前书籍的出版社id等于出版社表的id时#}
{% if book.publish_id == p.id %}
{#添加选中状态selected="selected"#}
{#由于表关系是通过id关联的，所以value值必须是id#}
<option value="{{ p.id }}" selected="selected">{{ p.name }}</option>
{% else %}
<option value="{{ p.id }}">{{ p.name }}</option>
{% endif %}
{% endfor %}
</select>
</div>
<div class="form-group">
<label for="">作者</label>
<ul class="list-group">
{% for author in author_list %}
<li class="list-group-item">
<div class="checkbox checkbox-success ">
{#判断作者的名字在当前书籍作者列表中#}
{% if author.name in the_author %}
{#添加选中状态checked="checked"#}
{#由于表关系是通过id关联的，所以value值必须是id#}
<input class="styled" type="checkbox" checked="checked" name="author_id"
value="{{ author.id }}">
<label class="checkbox-inline">{{ author.name }}</label>
{% else %}
<input class="styled" type="checkbox" name="author_id" value="{{ author.id }}">
<label class="checkbox-inline">{{ author.name }}</label>
{% endif %}
</div>
</li>
{% endfor %}
</ul>
</div>
<input type="submit" class="btn btn-default pull-right" value="修改">
</form>
{% endblock content %}
项目文件结构如下：
bms_mto ├── bms_mto │ ├── __init__.py │ ├── settings.py │ ├── urls.py │ └── wsgi.py ├── book │ ├── admin.py │ ├── apps.py │ ├── __init__.py │ ├── models.py │ ├── tests.py │ └── views.py ├── db.sqlite3 ├── manage.py ├── static │ └── css │ ├── bootstrap.min.css └── templates ├── add.html ├── base.html ├── index.html ├── manage.html └── modify.html
启动项目访问首页：http://127.0.0.1:8000/
点击左侧的添加书籍
添加一本书，选择2个作者
提示添加成功
首页就会多一本书籍
点击编辑按钮
修改价格，增加一个作者
提示修改成功
首页的书籍，价格和作者更新过来了
点击删除
提示删除成功
首页少了一条数据