day 48 ORM 进阶 多表连接 创建 以及 html模板继承
多表的一对多修改
多表的多对多修改
前情提要:
最近认识了不少大佬,大佬开着保时捷. .一顿狂奔..我连车尾灯都看不到..
本次内容 ORM 的多表链接 查询 , html的模板继承
2、添加表记录
方式一:
通过类实例化对象的方式。注意:一定要对象.save()
1
2
|
book = models.Book(title = "吸星大法" , price = 200 , publisher = "明教出版社" , pub_date = "2018-12-12" ) book.save() |
方式二:
通过ORM提供的objects提供的方法 create来实现。
1
|
book = models.Book.objects.create(title = "独孤九剑" , price = 150 , publisher = "华山出版社" , pub_date = "2019-1-12" ) |
3、查询表记录
1、查询API
<1> all(): 查询所有结果 <2> filter(**kwargs): 它包含了与所给筛选条件相匹配的对象 <3> get(**kwargs): 返回与所给筛选条件相匹配的对象,返回结果有且只有一个,
如果符合筛选条件的对象超过一个或者没有都会抛出错误。 <4> exclude(**kwargs): 它包含了与所给筛选条件不匹配的对象 <5> order_by(*field): 对查询结果排序 <6> reverse(): 对查询结果反向排序 <7> count(): 返回数据库中匹配查询(QuerySet)的对象数量。 <8> first(): 返回第一条记录 <9> last(): 返回最后一条记录 <10> exists(): 如果QuerySet包含数据,就返回True,否则返回False <11> values(*field): 返回一个ValueQuerySet——一个特殊的QuerySet,运行后得到的并不是一系列
model的实例化对象,而是一个可迭代的字典序列
<12> values_list(*field): 它与values()非常相似,它返回的是一个元组序列,values返回的是一个字典序列 <13> distinct(): 从返回结果中剔除重复纪录
2、基于双下划线的模糊查询
1
2
3
4
5
6
7
8
|
Book.objects. filter (price__in = [ 100 , 200 , 300 ]) Book.objects. filter (price__gt = 100 ) Book.objects. filter (price__lt = 100 ) Book.objects. filter (price__range = [ 100 , 200 ]) Book.objects. filter (title__contains = "法" ) Book.objects. filter (title__icontains = "python" ) # 不区分大小写 Book.objects. filter (title__startswith = "九" ) Book.objects. filter (pub_date__year = 2018 ) |
4、删除表记录
删除方法就是 delete()。它运行时立即删除对象而不返回任何值。例如:
1
|
model_obj.delete() |
你也可以一次性删除多个对象。每个 QuerySet 都有一个 delete() 方法,它一次性删除 QuerySet 中所有的对象。
例如,下面的代码将删除 pub_date 是2018年的 Book 对象:
1
|
Book.objects. filter (pub_date__year = 2018 ).delete() |
在 Django 删除对象时,会模仿 SQL 约束 ON DELETE CASCADE 的行为,换句话说,删除一个对象时也会删除与它相关联的外键对象。例如:
1
2
3
|
b = Book.objects.get(pk = 1 ) # This will delete the Blog and all of its Entry objects. b.delete() |
要注意的是: delete() 方法是 QuerySet 上的方法,但并不适用于 Manager 本身。这是一种保护机制,是为了避免意外地调用 Entry.objects.delete() 方法导致 所有的 记录被误删除。如果你确认要删除所有的对象,那么你必须显式地调用:
1
|
Book.objects. all ().delete() |
5、修改表记录
方式一:
通过修改实例对象的属性方式。注意:一定要对象.save()
1
2
3
|
book = models.Book.objects.get(title = "吸星大法" ) book.price = 180 book.save() |
方式二:
通过ORM提供的objects提供的方法 update来实现。
1
|
models.Book.objects. filter (title = "吸星大法" ).update(price = 190 ) |
此外,update()方法对于任何结果集(QuerySet)均有效,这意味着你可以同时更新多条记录update()方法会返回一个整型数值,表示受影响的记录条数。
一: html 模板继承
模板继承主要使用在几个界面大体类似 只是 地方做修改的时候的操作
1:首先先建立一个公共模板
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Title</title>
<link rel="stylesheet" href="/static/plugins/bootstrap-3.3.7-dist/bootstrap/css/bootstrap.css">
<link rel="stylesheet" href="/static/css/dsb.css">
{% block css %}
{% endblock css %}
</head>
<body> <nav class="navbar navbar-inverse navbar-fixed-top">
<div class="container-fluid">
<div class="navbar-header">
<button type="button" class="navbar-toggle collapsed" data-toggle="collapse" data-target="#navbar" aria-expanded="false" aria-controls="navbar">
<span class="sr-only">Toggle navigation</span>
<span class="icon-bar"></span>
<span class="icon-bar"></span>
<span class="icon-bar"></span>
</button>
<a class="navbar-brand" href="#">图书管理系统</a>
</div>
<div id="navbar" class="navbar-collapse collapse">
<ul class="nav navbar-nav navbar-right">
<li><a href="#">Dashboard</a></li>
<li><a href="#">Settings</a></li>
<li><a href="#">Profile</a></li>
<li><a href="#">Help</a></li>
</ul>
<form class="navbar-form navbar-right">
<input type="text" class="form-control" placeholder="Search...">
</form>
</div>
</div>
</nav> <div class="container-fluid">
<div class="row">
<div class="col-sm-3 col-md-2 sidebar">
<ul class="nav nav-sidebar">
<li class="active"><a href="{% url 'book_list' %}">书籍列表 <span class="sr-only">(current)</span></a></li>
<li><a href="#">Reports</a></li>
<li><a href="#">Analytics</a></li>
<li><a href="#">Export</a></li>
</ul>
</div>
<div class="col-sm-9 col-sm-offset-3 col-md-10 col-md-offset-2 main">
<div class="panel panel-primary">
<div class="panel-heading">
{% block title %}
{% endblock title %}
</div>
<div class="panel-body"> {% block content %}
<a class="btn btn-primary" href="{% url 'add_book' %}">新增书籍</a>
{% endblock content %}
</div>
</div>
</div>
</div>
</div> </body>
{% block js %}
{% endblock js %}
</html>
css 模板继承
html 继承
js 继承:
前面是在模板层定义大体框架,之后设计具体的内容
{% extends 'layout.html' %} {% block title %}
<h3 class="panel-title">书籍列表</h3>
{% endblock title %} {% block content %}
{{ block.super }}
<table class="table table-hover">
<thead>
<tr>
<th>序号</th>
<th>id</th>
<th>书名</th>
<th>价格</th>
<th>出版社</th>
<th>出版日期</th>
<th>操作</th>
</tr>
</thead>
<tbody>
{% for book in all_book %}
<tr>
<td>{{ forloop.counter }}</td>
<td>{{ book.pk }}</td>
<td>{{ book.title }}</td>
<td>{{ book.price }}</td>
<td>{{ book.publish }}</td>
<td>{{ book.pub_date|date:"Y-m-d" }}</td>
<td>
<a class="btn btn-info btn-sm" href="{% url 'edit_book' book_id=book.nid %}">编辑</a>
|
<a class="btn btn-danger btn-sm" href="{% url 'del_book' book.nid %}">删除</a>
</td>
</tr>
{% endfor %}
</tbody>
</table>
{% endblock content %}
二: ORM 多表链接
1:创建模型
>1: 创建图书管理系统的模型
1.1分析:
由 上可知 :
模型创建以后有5个表
其中 book 中的 book_id 与 book_author 是一对多的关系 ,即一本书可能会有好几个作者
publish 表中的id 与book 表中的publish 是一对多的关系 ,即一个出版社可能会有好几个书
author表与book_author 是一对多的关系 ,即一个作者可能会有好几个书,
所以book_author 是多对多关系. 是第第三方表.
通过上面分析.: Django 中可以创建4个模型. 即可实现5个表的关系
book 模型
from django.db import models # Create your models here.
class Book(models.Model):
title = models.CharField(max_length=32)
price = models.DecimalField(max_digits=5, decimal_places=2)
pub_date = models.DateField
publish = models.ForeignKey("Publish", on_delete=models.CASCADE) # 一对多
authors = models.ManyToManyField("Author") # 多对多
publish 模型
class Publish(models.Model):
name = models.CharField(max_length=32)
city = models.CharField(max_length=64)
email = models.EmailField()
author 模型
class Author(models.Model):
name = models.CharField(max_length=32)
age = models.IntegerField()
au_detail = models.OneToOneField("AuthorDeail", on_delete=models.CASCADE) # 一对一
AuthorDeail 模型
class AuthorDeail(models.Model):
tel = models.CharField(max_length=32)
addr = models.CharField(max_length=255)
birthday =models.DateField()
创建一对多关系时 对应的id Django 会自动帮填写id
整理 : 首先是普通方法
正向:调用字段名 ,反向: 调用小写的表明
1:一对多
正向: (在model 内写关系的为正向)
代码:
# book_obj=models.Book.objects.filter(pk=1).first()
# print(book_obj.publish.city)
反向:
# pub_obj =models.Publish.objects.filter(id=2).first()
# print(pub_obj.book_set.all(),type(pub_obj.book_set.all()))
# for i in pub_obj.book_set.all():
# print(i.title)
2:多对多
正向:
# book_obj =models.Book.objects.filter(id=2).first()
# for i in book_obj.authors.all():
# print(i.name,i.au_detail.tel)
反向:
# au_obj =models.Author.objects.filter(id=3).first()
# for j in au_obj.book_set.all():
# print(j.title)
3:一对一
一对一没有正反向, 两端一样
# 一对一查询
# au_obj = models.Author.objects.filter(id=3).first()
# print(au_obj.au_detail.tel)
# au_addr = models.AuthorDetail.objects.filter(id=2).first()
# print(au_addr.author.name)
双下 方法的使用
正向: 直接调用他对应的内容的字段
反向: 反向找到其父级,调用其对应内容的字段
关联管理器(RelatedManager)
一、class RelatedManager
"关联管理器"是在一对多或者多对多的关联上下文中使用的管理器。它存在于下面两种情况:
1、一对多
ForeignKey关系的“另一边”。像这样:
1
2
3
4
5
6
7
|
from django.db import models class Publish(models.Model): pass class Book(models.Model): publish = models.ForeignKey( "Publish" , on_delete = models.CASCADE) |
在上面的例子中,管理器publish_obj.book_set 会拥有下面介绍的方法。
2、多对多
ManyToManyField关系的两边:
1
2
3
4
5
6
|
class Author(models.Model): pass class Book(models.Model): authors = models.ManyToManyField( "Author" ) |
在这个例子中,book_obj.authors 和author_obj.book_set 都拥有下面的方法。
3、方法合集
1、add(obj1[, obj2, ...])
把指定的模型对象添加到关联对象集中。 例如: >>> author_obj = Author.objects.get(id=1)
>>> book_obj = Book.objects.get(id=2)
>>> author_obj .book_set.add(e)
在上面的例子中,对于ForeignKey关系,book_obj.save()由关联管理器调用,执行更新操作。然而,在多对多关系中使用add()并不会调用任何 save()方法,而是由QuerySet.bulk_create()创建关系。 延伸: # 1 *[]的使用
>>> book_obj = Book.objects.get(id=1)
>>> author_list = Author.objects.filter(id__gt=2)
>>> book_obj.authors.add(*author_list) # 2 直接绑定主键
book_obj.authors.add(*[1,3]) # 将id=1和id=3的作者对象添加到这本书的作者集合中
# 应用: 添加或者编辑时,提交作者信息时可以用到.
2、create(**kwargs)
创建一个新的对象,保存对象,并将它添加到关联对象集之中。返回新创建的对象: >>> author_obj = Author.objects.get(id=1)
>>> book = author_obj.book_set.create(
...
title='挤奶龙爪手',
...
) # No need to call e.save() at this point -- it's already been saved.
这完全等价于(不过更加简洁于): >>> author_obj = Author.objects.get(id=1)
>>> book = Book(
...
title='挤奶龙爪手',
...
)
>>> author_obj.save(force_insert=True)
要注意我们并不需要指定模型中用于定义关系的关键词参数。在上面的例子中,我们并没有传入author_obj参数给create()。Django会明白新的 Book对象author_obj 应该添加到author_obj中。
3、remove(obj1[, obj2, ...])
从关联对象集中移除执行的模型对象: >>> author_obj = Author.objects.get(id=1)
>>> book_obj = Book.objects.get(id=2)
>>> author_obj .book_set.remove(book_obj)
对于ForeignKey对象,这个方法仅在null=True时存在。
4、clear()
从关联对象集中移除一切对象。 >>> author_obj = Author.objects.get(id=1)
>>> author_obj.book_set.clear()
注意这样不会删除对象 —— 只会删除他们之间的关联。 就像 remove() 方法一样,clear()只能在 null=True的ForeignKey上被调用。
5、set()方法
先清空,在设置,编辑书籍时即可用到。
book = models.Book.objects.filter(title="独孤九剑").first()
book.authors.set([1, 3])
注意:
对于所有类型的关联字段,add()、create()、remove()和clear(),set()都会马上更新数据库。换句话说,在关联的任何一端,都不需要再调用save()方法。
二、操作表记录
1、添加一些简单的数据
1、publish表:
2、author表:
3、authordatail表:
2、一对多
# 方式一 传对象的形式
pub_obj = models.Publish.objects.get(pk=1)
book = models.Book.objects.create(title="独孤九剑", price=180, pub_date="2018-10-23", publish=pub_obj) # 方式二 传对象id的形式
book = models.Book.objects.create(title="独孤九剑", price=180, pub_date="2018-10-23", publish_id=1)
核心:明白book.publish 和 book.publish_id 的区别?
3、多对多
# 方式一 传对象的形式
book = models.Book.objects.filter(title="独孤九剑").first()
ling = models.Author.objects.filter(name="令狐冲").first()
ying = models.Author.objects.filter(name="任盈盈").first()
book.authors.add(ling, ying) # 方式二 传对象id的形式
book = models.Book.objects.filter(title="独孤九剑").first()
ling = models.Author.objects.filter(name='令狐冲').first()
ying = models.Author.objects.filter(name='任盈盈').first()
book.authors.add(ling.pk, ying.pk)
核心:book.authors.all()是什么?
多对多其他常用API:
1
2
3
|
book_obj.authors.remove() # 将某个特定的对象从被关联对象集合中去除。 ====== book_obj.authors.remove(*[]) book_obj.authors.clear() #清空被关联对象集合 book_obj.authors. set () #先清空再设置 |
2、基于对象的跨表查询
1、一对多查询(Publish 与 Book)
正向查询(按字段 publish)
1
2
3
4
|
# 查询主键为1的书籍的出版社所在的城市 book_obj = Book.objects. filter (pk = 1 ).first() # book_obj.publish 是主键为1的书籍对象关联的出版社对象 print (book_obj.publish.city) |
反向查询(按book表)
1
2
3
4
5
6
|
# 查询明教出版社出版的书籍名 publish = Publish.objects.get(name = "明教出版社" ) #publish.book_set.all() : 与明教出版社关联的所有书籍对象集合 book_list = publish.book_set. all () for book_obj in book_list: print (book_obj.title) |
2、一对一查询(Author 和 AuthorDetail)
正向查询(按字段:au_detail):
1
2
|
# 查询令狐冲的电话<br>ling=Author.objects.filter(name="令狐冲").first() print (ling.au_detail.tel) |
反向查询(按表名:author):
1
2
3
4
5
|
# 查询所有住址在黑木崖的作者的姓名 authorDetail_list = AuthorDetail.objects. filter (addr = "黑木崖" ) for obj in authorDetail_list: print (obj.author.name) |
3、多对多查询 (Author 与 Book)
正向查询(按字段:authors):
1
2
3
4
5
6
|
# 独孤九剑所有作者的名字以及手机号 book_obj = Book.objects. filter (title = "独孤九剑" ).first() authors = book_obj.authors. all () for author_obj in authors: print (author_obj.name, author_obj.au_detail.tel) |
反向查询(按表名:book_set):
1
2
3
4
5
6
|
# 查询令狐冲出过的所有书籍的名字 author_obj = Author.objects.get(name = "令狐冲" ) book_list = author_obj.book_set. all () #与令狐冲作者相关的所有书籍 for book_obj in book_list: print (book_obj.title) |
注意:
你可以通过在 ForeignKey() 和ManyToManyField的定义中设置 related_name 的值来覆写 FOO_set 的名称。例如,如果 Book model 中做一下更改:
1
|
publish = models.ForeignKey( "Publish" , on_delete = models.CASCADE, related_name = "book_list" ) |
那么接下来就会如我们看到这般:
1
2
3
4
|
# 查询 明教出版社出版过的所有书籍 publish = Publish.objects.get(name = "明教出版社" ) book_list = publish.book_list. all () # 与明教出版社关联的所有书籍对象集合 |
3、基于双下划线的跨表查询
Django 还提供了一种直观而高效的方式在查询(lookups)中表示关联关系,它能自动确认 SQL JOIN 联系。要做跨关系查询,就使用两个下划线来链接模型(model)间关联字段的名称,直到最终链接到你想要的model 为止。
'''
正向查询按字段,反向查询按表名小写用来告诉ORM引擎join哪张表
'''
1、一对多查询
# 练习: 查询明教出版社出版过的所有书籍的名字与价格(一对多) # 正向查询 按字段:publish queryResult=Book.objects.filter(publish__name="明教出版社").values_list("title","price") # 反向查询 按表名:book queryResult=Publish.objects.filter(name="明教出版社").values_list("book__title","book__price")
2、多对多查询
# 练习: 查询令狐冲出过的所有书籍的名字(多对多) # 正向查询 按字段:authors:
queryResult=Book.objects.filter(authors__name="令狐冲").values_list("title") # 反向查询 按表名:book
queryResult=Author.objects.filter(name="令狐冲").values_list("book__title","book__price")
3、一对一查询
# 查询令狐冲的手机号 # 正向查询
ret=Author.objects.filter(name="令狐冲").values("au_detail__tel") # 反向查询
ret=AuthorDetail.objects.filter(author__name="令狐冲").values("tel")
4、进阶练习(连续跨表)
# 练习: 查询明教出版社出版过的所有书籍的名字以及作者的姓名 # 正向查询
queryResult=Book.objects.filter(publish__name="明教出版社").values_list("title","authors__name")
# 反向查询
queryResult=Publish.objects.filter(name="明教出版社").values_list("book__title","book__authors__age","book__authors__name") # 练习: 手机号以132开头的作者出版过的所有书籍名称以及出版社名称 # 方式1:
queryResult=Book.objects.filter(authors__au_detail__tel__startswith="132").values_list("title","publish__name") # 方式2:
ret=Author.objects.filter(au_detail__tel__startswith="132").values("book__title","book__publish__name")
二、操作表记录
1、添加一些简单的数据
1、publish表:
2、author表:
3、authordatail表:
2、一对多
# 方式一 传对象的形式
pub_obj = models.Publish.objects.get(pk=1)
book = models.Book.objects.create(title="独孤九剑", price=180, pub_date="2018-10-23", publish=pub_obj) # 方式二 传对象id的形式
book = models.Book.objects.create(title="独孤九剑", price=180, pub_date="2018-10-23", publish_id=1)
核心:明白book.publish 和 book.publish_id 的区别?
3、多对多
# 方式一 传对象的形式
book = models.Book.objects.filter(title="独孤九剑").first()
ling = models.Author.objects.filter(name="令狐冲").first()
ying = models.Author.objects.filter(name="任盈盈").first()
book.authors.add(ling, ying) # 方式二 传对象id的形式
book = models.Book.objects.filter(title="独孤九剑").first()
ling = models.Author.objects.filter(name='令狐冲').first()
ying = models.Author.objects.filter(name='任盈盈').first()
book.authors.add(ling.pk, ying.pk)
核心:book.authors.all()是什么?
多对多其他常用API:
1
2
3
|
book_obj.authors.remove() # 将某个特定的对象从被关联对象集合中去除。 ====== book_obj.authors.remove(*[]) book_obj.authors.clear() #清空被关联对象集合 book_obj.authors. set () #先清空再设置 |
2、基于对象的跨表查询
1、一对多查询(Publish 与 Book)
正向查询(按字段 publish)
1
2
3
4
|
# 查询主键为1的书籍的出版社所在的城市 book_obj = Book.objects. filter (pk = 1 ).first() # book_obj.publish 是主键为1的书籍对象关联的出版社对象 print (book_obj.publish.city) |
反向查询(按book表)
1
2
3
4
5
6
|
# 查询明教出版社出版的书籍名 publish = Publish.objects.get(name = "明教出版社" ) #publish.book_set.all() : 与明教出版社关联的所有书籍对象集合 book_list = publish.book_set. all () for book_obj in book_list: print (book_obj.title) |
2、一对一查询(Author 和 AuthorDetail)
正向查询(按字段:au_detail):
1
2
|
# 查询令狐冲的电话<br>ling=Author.objects.filter(name="令狐冲").first() print (ling.au_detail.tel) |
反向查询(按表名:author):
1
2
3
4
5
|
# 查询所有住址在黑木崖的作者的姓名 authorDetail_list = AuthorDetail.objects. filter (addr = "黑木崖" ) for obj in authorDetail_list: print (obj.author.name) |
3、多对多查询 (Author 与 Book)
正向查询(按字段:authors):
1
2
3
4
5
6
|
# 独孤九剑所有作者的名字以及手机号 book_obj = Book.objects. filter (title = "独孤九剑" ).first() authors = book_obj.authors. all () for author_obj in authors: print (author_obj.name, author_obj.au_detail.tel) |
反向查询(按表名:book_set):
1
2
3
4
5
6
|
# 查询令狐冲出过的所有书籍的名字 author_obj = Author.objects.get(name = "令狐冲" ) book_list = author_obj.book_set. all () #与令狐冲作者相关的所有书籍 for book_obj in book_list: print (book_obj.title) |
注意:
你可以通过在 ForeignKey() 和ManyToManyField的定义中设置 related_name 的值来覆写 FOO_set 的名称。例如,如果 Book model 中做一下更改:
1
|
publish = models.ForeignKey( "Publish" , on_delete = models.CASCADE, related_name = "book_list" ) |
那么接下来就会如我们看到这般:
1
2
3
4
|
# 查询 明教出版社出版过的所有书籍 publish = Publish.objects.get(name = "明教出版社" ) book_list = publish.book_list. all () # 与明教出版社关联的所有书籍对象集合 |
3、基于双下划线的跨表查询
Django 还提供了一种直观而高效的方式在查询(lookups)中表示关联关系,它能自动确认 SQL JOIN 联系。要做跨关系查询,就使用两个下划线来链接模型(model)间关联字段的名称,直到最终链接到你想要的model 为止。
'''
正向查询按字段,反向查询按表名小写用来告诉ORM引擎join哪张表
'''
1、一对多查询
# 练习: 查询明教出版社出版过的所有书籍的名字与价格(一对多) # 正向查询 按字段:publish queryResult=Book.objects.filter(publish__name="明教出版社").values_list("title","price") # 反向查询 按表名:book queryResult=Publish.objects.filter(name="明教出版社").values_list("book__title","book__price")
2、多对多查询
# 练习: 查询令狐冲出过的所有书籍的名字(多对多) # 正向查询 按字段:authors:
queryResult=Book.objects.filter(authors__name="令狐冲").values_list("title") # 反向查询 按表名:book
queryResult=Author.objects.filter(name="令狐冲").values_list("book__title","book__price")
3、一对一查询
# 查询令狐冲的手机号 # 正向查询
ret=Author.objects.filter(name="令狐冲").values("au_detail__tel") # 反向查询
ret=AuthorDetail.objects.filter(author__name="令狐冲").values("tel")
4、进阶练习(连续跨表)
# 练习: 查询明教出版社出版过的所有书籍的名字以及作者的姓名 # 正向查询
queryResult=Book.objects.filter(publish__name="明教出版社").values_list("title","authors__name")
# 反向查询
queryResult=Publish.objects.filter(name="明教出版社").values_list("book__title","book__authors__age","book__authors__name") # 练习: 手机号以132开头的作者出版过的所有书籍名称以及出版社名称 # 方式1:
queryResult=Book.objects.filter(authors__au_detail__tel__startswith="132").values_list("title","publish__name") # 方式2:
ret=Author.objects.filter(au_detail__tel__startswith="132").values("book__title","book__publish__name")
# book_obj =models.Book.objects.filter(id=2).first()
# for i in book_obj.authors.all():
# print(i.name,i.au_detail.tel)
'''1、查询丐帮出版社出版的所有书名和作者名称;
2、查询独孤九剑的作者名称和出版社名称;
3、查询吸星大法的作者的姓名、电话和地址;
4、查询令狐冲写的书籍,在哪些出版社出版过,获取其出版社名称和地址;
5、查询出版社地址为黑木崖,在该出版社出版过书籍的作者姓名和邮箱;
'''
# 正向查询按字段, 反向查询按小写表名。
# 1方式1 正向 双下
# books1 =models.Book.objects.filter(publish__id=2).values("title","authors__name")
# print(books1)
# print(">>>>>>>>>>>>>>>>>")
# # 1方式2 反向 双下
# books2 =models.Publish.objects.filter(id=2).values("book__title","book__authors__name")
# print(books2)
# # 1 方式3 反向
# pub1 =models.Publish.objects.filter(id=2).first()
# for i in pub1.book_set.all():
# for j in i.authors.all():
#
# print(i.title,j.name) # 2 方法1
# books1 =models.Book.objects.filter(id=2).values("authors__name","publish__name")
# print(books1)
# #2 方法2
# books2 =models.Author.objects.filter(book__id=2).values("name","book__publish__name")
# print(books2)
# #2 方法3
# books3 =models.Book.objects.filter(id=2) # for i in books3:
# name,pub=i.authors.all(),i.publish.name
# for j in name:
# print(j.name,i.publish)
# 3、查询吸星大法的作者的姓名、电话和地址; # 3 方法1:
# books1=models.Book.objects.filter(id=3).values("authors__name","authors__au_detail__tel","authors__au_detail__addr")
#
# print(books1)
# #3 方法2:
# books2 =models.Author.objects.filter(book__id=3).values("name","au_detail__tel","au_detail__addr")
# print(books2)
# # 3 方法3:
# books3 =models.Book.objects.filter(id=3).first().authors.all()
# for i in books3:
# print(i.name,i.au_detail.tel,i.au_detail.addr)
# 4、查询令狐冲写的书籍,在哪些出版社出版过,获取其出版社名称和地址;
# 4 方法1:
# books1 =models.Author.objects.filter(id=3).values("book__title","book__publish__name","book__publish__city")
# print(books1)
# # 4 方法2:
# books2 =models.Book.objects.filter(authors__id=3).values("title","publish__name","publish__city")
# print(books2)
# #4 方法3 :
# books3 =models.Author.objects.filter(id=3).first()
# for i in books3.book_set.all():
# print(i.title,i.publish.name,i.publish.city)
#
# 5 5、查询出版社地址为黑木崖,在该出版社出版过书籍的作者姓名和邮箱;
# 5 方法1 :
books1 =models.Publish.objects.filter(id=2).values("book__title","book__authors__name","book__authors__au_detail__addr")
print(books1)
# 5 方法2:
books2 =models.Book.objects.filter(publish_id=2).values("title","authors__name","authors__au_detail__addr")
print(books2)
# 5 方法3:
books3 =models.Publish.objects.filter(id=2).first()
for i in books3.book_set.all():
for j in i.authors.all():
print(i.title,j.name)
day 48 ORM 进阶 多表连接 创建 以及 html模板继承的更多相关文章
- Django之ORM多表关系创建
ORM模型多表逻辑创建: 以图书和作者关系模型为例: models.py from django.db import models ''' 一本书只能被一个出版社出版; 一个出版社可以出版多本书; 一 ...
- Django项目的ORM操作之--数据模型类创建
在django项目中,其自带了ORM(Object Relation Mapping)对象关系映射框架,我们在django项目下app的models模块下对类进行操作,通过ORM会将我们对类的操作转化 ...
- 4.mysql数据库创建,表中创建模具模板脚本,mysql_SQL99标准连接查询(恩,外部连接,全外连接,交叉连接)
mysql数据库创建,表创建模等模板脚本 -- 用root用户登录系统,运行脚本 -- 创建数据库 create database mydb61 character set utf8 ; -- ...
- Python进阶----数据库引擎(InnoDB),表的创建,mysql的数据类型,mysql表的约束
Python进阶----数据库引擎(InnoDB),表的创建,mysql的数据类型,mysql表的约束 一丶MySQL的存储引擎 什么是存储引擎: MySQL中的数据用各种不同的技术存储在文件( ...
- MySQL进阶11--DDL数据库定义语言--库创建/修改/删除--表的创建/修改/删除/复制
/*进阶 11 DDL 数据库定义语言 库和表的管理 一:库的管理:创建/修改/删除 二:表的管理:创建/修改/删除 创建: CREATE DATABASE [IF NOT EXISTS] 库名; 修 ...
- MySQL 进阶6: 连接查询 (多表连接) : 等值连接/非等值连接 /左右全连接/内连接
#进阶6: 连接查询 (多表连接) : 等值连接/非等值连接 /左右全连接/内连接 /* 含义: 当查询的字段来自于多个表时, 就会用到连接查询 一: sql 92标准 :等值连接 ,(#内连接) 1 ...
- django ORM model filter 条件过滤,及多表连接查询、反向查询,某字段的distinct
版权归作者所有,任何形式转载请联系作者.作者:petanne(来自豆瓣)来源:https://www.douban.com/note/301166150/ 1.多表连接查询:感觉django太NX了. ...
- Django中的ORM进阶操作
Django中的ORM进阶操作 Django中是通过ORM来操作数据库的,通过ORM可以很easy的实现与数据库的交互.但是仍然有几种操作是非常绕也特别容易混淆的.于是,针对这一块,来一个分类总结吧. ...
- Django - ORM - 进阶
一.多表操作 创建模型 实例:我们来假定下面这些概念,字段和关系 作者模型:一个作者有姓名和年龄. 作者详细模型:把作者的详情放到详情表,包含生日,手机号,家庭住址等信息.作者详情模型和作者模型之间是 ...
随机推荐
- java bulid path 和 WEB-INF/lib 下jar 包区别
用Java Build Path导入包和把包复制到lib下是有区别的,它俩其实不会冲突,也没有什么关系的, Java Build Path是我们编译需要的包, 导入到lib下是程序运行时需要的包 , ...
- socketpair初识
#include <stdio.h> #include <string.h> #include <unistd.h> #include <sys/typ ...
- kafka系列 -- 基础概念
kafka是一个分布式的.分区化.可复制提交的发布订阅消息系统 传统的消息传递方法包括两种: 排队:在队列中,一组用户可以从服务器中读取消息,每条消息都发送给其中一个人. 发布-订阅:在这个模型中,消 ...
- 使用reactjs做一个CRUD功能
第一步:引入reactjs所依赖的js文件,本案例使用的是bootstrap前端框架,所以引入了相应的js和css文件 第二步:body里面添加两个div 第三步:开始编写reactjs脚本 < ...
- 2018.10.14 bzoj4571: [Scoi2016]美味(主席树)
传送门 自认为是一道思想很妙的题. 直接分析问题. 如果没有xxx的干扰直接上可持久化01trie01trie01trie走人. 但现在有了xxx这个偏移量. 相当于把整个01trie01trie01 ...
- yii2缓存
use yii\caching\Cache;$cache = Yii::$app->cache;$cache['var1'] = $value1; // equivalent to: $cac ...
- hdu-2191(完全背包+二进制优化模板)
题目链接:http://acm.hdu.edu.cn/showproblem.php?pid=2191 思路:完全背包模板 #include<iostream> #include<c ...
- Spring源码解析 - AbstractBeanFactory 实现接口与父类分析
我们先来看类图吧: 除了BeanFactory这一支的接口,AbstractBeanFactory主要实现了AliasRegistry和SingletonBeanRegistry接口. 这边主要提供了 ...
- hdu 1231 最大连续子序列 ,1003 Max Sum;
题目(1231) #include<stdio.h> #include<iostream> using namespace std; int main() { int K,nu ...
- Centos 7 安装 FFmpeg
Step 1: Update the system sudo yum install epel-release -y sudo yum update -y sudo shutdown -r now S ...