day68 django 10

昨日回顾

1 常用字段和非常用字段，常用参数和非常用参数，元信息
	-常用字段，很多
    -常用参数，很多
    -表名，联合索引，联合唯一
2 admin的使用(快速对表增删查改)
	-创建超级用户
    -/admin/
    -把表在admin.py中注册
3 国际化
	-中文，时区问题
    
4 单表的新增，单表的删除，单表的修改
	-新增
    	-对象.save()
        -类名.object.create()
    -删除
    	-对象.delete()
        -queryset.delete()
    -修改
    	-对象.save()
        -queryset.update()
5 单表查询
	-13个 api
	 filter,all,get,last,first,reverse,count,order_by,values,values_list,distinct,exclude,exist
    -模糊查询（__  神奇的双下滑下）
    	-__in=[19.23,16.54]
        -__range
        -__gt
        -__gte
        -__lt
        -__lte
        -时间类型__year
        -__contains
        -__icontains
        -__startswith
        -__endswith
6 在脚本中调用django
7 打印原生sql（配置日志）

今日内容

一、多表操作之模型创建

model.py

from django.db import models

# Create your models here.
class Book(models.Model):
    id=models.AutoField(primary_key=True)
    name=models.CharField(max_length=32)
    price=models.DecimalField(max_digits=6,decimal_places=2)
    publish_date=models.DateTimeField(auto_now_add=True)

    # to='Publish'跟Publish表做关联（ForeignKey，一对多）
    # to_field='id'跟哪个字段做关联
    # ForeignKey对到数据中的字段是int类型
    # publish=models.CharField(max_length=32)
    # publish=models.ForeignKey(to='Publish',to_field='id')
    # publish = models.ForeignKey(to='Publish')  # 不写，默认跟主键做关联
    publish=models.ForeignKey(to='Publish')
    # publish = models.ForeignKey(to=Publish, on_delete=models.CASCADE)  # 不写，默认跟主键做关联
    # publish = models.ForeignKey(to=Publish,on_delete=models.SET_NULL,null=True)  # 不写，默认跟主键做关联
    # publish = models.ForeignKey(to=Publish,on_delete=models.SET_DEFAULT,default=0)  # 不写，默认跟主键做关联

    #自动创建第三张表(这句话就会自动创建第三张表)
    #authors在数据库中不存在该字段，没有to_field
    #morning情况下：第三张表有id字段，当前Book表的id字段和Author表的id字段
    authors=models.ManyToManyField(to='Author')

class Publish(models.Model):
    id=models.AutoField(primary_key=True)
    name=models.CharField(max_length=32)
    addr=models.CharField(max_length=64)
    phone=models.CharField(max_length=64)#既可以存纯数字，也可以存座机，如：021-123445
    email=models.EmailField()

class Author(models.Model):
    id=models.AutoField(primary_key=True)
    name=models.CharField(max_length=32)
    age=models.SmallIntegerField()
    # 一对一的本质是  ForeignKey+unique
    author_detail = models.OneToOneField(to='AuthorDetail', to_field='id', on_delete=models.CASCADE)
    # author_detail=models.ForeignKey(to='AuthorDetail',to_field='id',unique=True)

class AuthorDetail(models.Model):
    id=models.AutoField(primary_key=True)
    sex=models.SmallIntegerField()
    addr=models.CharField(max_length=64)
    phone=models.BigIntegerField()#只存数字

settings.py

DATABASES = {
    ##book这个数据库必须是个新数据库，不能有任何表，否则迁移失败
    'default': {
        'ENGINE': 'django.db.backends.mysql',
        'NAME': 'book',
        'USER':'root',
        'PASSWORD':'123',
        'HOST':'127.0.0.1',
        'PORT':3306,
        'CHARSET':'utf8'
    }
}

app01\init.py

import pymysql
pymysql.install_as_MySQLdb()

数据库迁移：

运行makemigrations和migrate完成数据库迁移

ER图表如下：

二、一对多添加记录

s1.py

import os
if __name__ == '__main__':
    os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'day68lianxi.settings')
    import django
    django.setup()
    from app01 import models
    #一对多添加记录（出版社和图书）
    #先新增出版社，再新增图书
    #新增北京出版社
    publish=models.Publish.objects.create(name='北京出版社',addr='北京',phone='0536-12345678',email='邮箱地址')
    #新增红楼梦图书
    book=models.Book.objects.create(name='红楼梦',price='32.90',publish=publish)#publish=对象
    # book=models.Book.objects.create(name='西游记',price='32.00',publish_id=1)# publish_id=数字
    # 新增红楼梦图书
    book = models.Book.objects.create(name='西游记', price='32.90', publish_id=publish.id)# publish.id=数字


# 总结：
	1 email可以不传email，本质就是varchar（admin中会判断）
    2 新增图书：
    	-publish=publish
        -publish_id=publish.id
    3 写在表模型中的publish字段，到数据库中会变成publish_id(ForeignKey)
    4 查到book对象以后
    	-book.publish     对象
    	-book.publish_id  id号，数字

三、多对多添加记录

 自动创建的表，表模型就拿不到，book.authors代指表模型
    
    #多对多，作者和书
    #给西游记这本书新增两个作者lqz和egon
    #取到西游记这本书
    book=models.Book.objects.get(name='西游记')
    print(book.authors)#authors代指中间表
    book.authors.add(3,4)#新增作者，通过id新增
    lqz=models.Author.objects.get(id=3)
    egon=models.Author.objects.get(id=4)
    book.authors.add(lqz,egon)#新增作者，通过对象新增
    book.authors.add(3,egon)#新增作者，通过对象新增

    #西游记删除一个作者
    book=models.Book.objects.get(name='西游记')
    book.authors.remove(3)
    egon=models.Author.objects.get(id=4)
    book.authors.remove(egon)
    
    #clear 清空所有作者
    book=models.Book.objects.get(name='西游记')
    book.authors.add(3, 4)
    book.authors.clear()
    
    #set 新清空，再add,前提是不存在的作者
    book.authors.set([12,])
    
     # add ,remove，set clear

四、多对多其他api

# add ,remove，set clear

五、基于对象的跨表查询（正向反向）

跨表查询有两种方式：

	-基于对象的跨表查询：子查询
    -基于双下划线的跨表查询：关联查询，连表查询

基于对象的跨表查询（子查询）

一对多

#查询主键为1的书籍的出版社所在的城市
    book=models.Book.objects.get(id=1)#第一次查询
    # book=models.Book.objects.filter(id=1)
    publish=book.publish#内部又执行了一次查询
    print(publish.addr)
    
    #北京出版社关联的所有书籍
    publish=models.Publish.objects.get(name='北京出版社')#第一次查询了出版社
    books=publish.book_set.all()#表名小写——set, # 第二次，根据出版社id，查询所有书
    print(books)

正向查询：book表内有publish字段 直接对象.字段名

反向查询：publish表内没有book字段，出版社对象.Book小写_set.all()

一对一

#查询所有住址在山东的作者的姓名

    # 反向查询：author_detail表内没有author字段，author_detail表名小写（一对一）
    author_detail=models.AuthorDetail.objects.filter(addr__contains='山东').first()
    #反向
    print(author_detail.author.name) 
    
    # 查询egon作者的地址
    # 正向
    author=models.Author.objects.get(name='egon')
    print(author.author_detail.addr)

多对多关系查询

#西游记所有作者的名字以及手机号
book=models.Book.objects.get(name='西游记')
#正向
authors=book.authors.all()
for author in authors:
    print(author.name)
    print(author.author_detail.phone)
        
 # 反向 查询egon出过的所有书籍的名字
    egon=models.Author.objects.get(name='egon')
    books=egon.book_set.all()
    for book in books:
        print(book.name)
        
# 地址为山东的作者写的所有书   author_detail=models.AuthorDetail.objects.get(addr='山东')
    author=author_detail.author
    books=author.book_set.all()
    print(books[0].name)        

总结：

基于对象的跨表查询，先查对象，通过对象再去查另一个对象（正向：字段名，反向：表名小写/表名小写_set.all()

六、基于双下划线的跨表查询

连表查询

一对多

# 正向：字段名
# 反向:表名小写
# filter，values,values_list(写 __ 跨表)
# 练习:  查询北京出版社出版过的所有书籍的名字与价格(一对多)
    # SELECT `app01_book`.`name`, `app01_book`.`price` FROM `app01_publish` LEFT OUTER JOIN `app01_book` ON (`app01_publish`.`id` = `app01_book`.`publish_id`) WHERE `app01_publish`.`name` = '北京出版社' ;
    res=models.Publish.objects.filter(name='北京出版社').values('book__name','book__price')
    print(res)
    # SELECT `app01_book`.`name`, `app01_book`.`price` FROM `app01_book` INNER JOIN `app01_publish` ON (`app01_book`.`publish_id` = `app01_publish`.`id`) WHERE `app01_publish`.`name` = '北京出版社';

    res=models.Book.objects.filter(publish__name='北京出版社').values('name','price')
    print(res)

多对多

# 练习: 查询egon出过的所有书籍的名字,价格(多对多)
#反向
 res=models.Author.objects.filter(name='egon').values('book__name','book__price')
    print(res)
# 正向
    res=models.Book.objects.filter(authors__name='egon').values('name','price')
    print(res) 
    
    
#查询egon的手机号
    res=models.Author.objects.filter(name='egon').values('author_detail__phone')
    print(res)
    res=models.AuthorDetail.objects.filter(author__name='egon').values('phone')
    print(res)

七、进阶连续跨表查询

#查询北京出版社出版过的所有书籍的名字以及作者的姓名
    res=models.Publish.objects.filter(name='北京出版社').values('book__name','book__authors__name')
    print(res)

    res=models.Book.objects.filter(publish__name='北京出版社').values('name','authors__name')
    print(res)

    res=models.Author.objects.filter(book__publish__name='北京出版社').values('book__name','name')
    print(res)

    # 手机号以189开头的作者出版过的所有  书籍名称  以及   出版社名称
    				res=models.AuthorDetail.objects.filter(phone__startswith='189').values('author__book__name','author__book__publish__name')
    print(res)

    # SELECT `app01_book`.`name`, `app01_publish`.`name` FROM `app01_author` INNER JOIN `app01_authordetail` ON (`app01_author`.`author_detail_id` = `app01_authordetail`.`id`) LEFT OUTER JOIN `app01_book_authors` ON (`app01_author`.`id` = `app01_book_authors`.`author_id`) LEFT OUTER JOIN `app01_book` ON (`app01_book_authors`.`book_id` = `app01_book`.`id`) LEFT OUTER JOIN `app01_publish` ON (`app01_book`.`publish_id` = `app01_publish`.`id`) WHERE `app01_authordetail`.`phone` LIKE  '189%' ;
    res=models.Author.objects.filter(author_detail__phone__startswith='189').values('book__name','book__publish__name')
print(res)

扩展

1 看一看这篇博客

https://www.cnblogs.com/nokiaguy/p/13803370.html

2 安装模块相关

pip3 install django    
# 本质是去https://pypi.python.org/simple，搜这个模块，会根据你的平台下载在一个安装包（windows平台是whl）,下载完，再安装

# pip安装失败的情况
# 我们可以绕过它，有了whl文件以后，自己装
# https://www.lfd.uci.edu/~gohlke/pythonlibs/#opencv
pip3 install django.whl   

# 官方库没有上传到pypi，官方也不给制作whl文件
#如何安装  包 （setup.py）
到达安装目录，setup.py所在的目录
python setup.py build
python setup.py install

# 配置清华源，豆瓣源，本质是
豆瓣源会把pypi，包拉到自己的服务器上，以后你再下，去它的服务器上下，所以速度快

# 你自己写的包，如何上传到pypi上给别人使用？

2 外键关系要不要建立

1 关联字段与外键约束没有必然的联系（建管理字段是为了进行查询，建约束是为了不出现脏数据）
2 默认情况，关联关系建好以后，外键约束就自然建立了
3 实际工作中，外键约束一般不建（影响效率），都是人为约束（代码约束）
	-db_constraint=False
4 表模型和数据库表的对应，不要直接修改表（这是可以的，但是不建议），要修改表模型，同步到表中

作业

1 讲的东西整理完

2 连续跨表的其它写法

3 如下（基于对象，基于双下滑下）

查找所有书名里包含红楼的书
查找出版日期是2017年的书
查找出版日期是2017年的书名
查找价格大于10元的书
查找价格大于10元的书名和价格

查找在北京的出版社
查找名字以沙河开头的出版社

查找作者名字里面带“小”字的作者
查找年龄大于30岁的作者
查找手机号是155开头的作者
查找手机号是155开头的作者的姓名和年龄

查找书名是“红楼梦”的书的出版社
查找书名是“红楼梦”的书的出版社所在的城市
查找书名是“红楼梦”的书的出版社的名称

查找书名是“红楼梦”的书的所有作者
查找书名是“红楼梦”的书的作者的年龄
查找书名是“红楼梦”的书的作者的手机号码

查找书名是“红楼梦”的书的作者的地址
查找书名是“红楼梦”的书的作者的邮箱