day05

环境准备

1.创建Django项目 day59
2.初始化操作准备下

"Django自带一个sqlite3小型数据库"
	该数据库功能非常有限,并且针对日期类型的数据兼容性很差
    
3.Django切换MySQL数据
	Django1.11版本 需要在项目或者应用目录下的__init__.py中添加
    	improt pymysql
        pymysql.install_as_MySQLdb()
	Django2.2以上 需要使用mysqlclient模块
    	pip install mysqlclient
        
	1.打开数据库,手动创建day59
    	CREATE DATABASE day59
        
	2.settings.py中配置数据库
        DATABASES = {
            'default': {
                'ENGINE': 'django.db.backends.mysql',
                'NAME': 'day59',
                'HOST': '127.0.0.1',
                'PORT': 3306,
                'USER': 'root',
                'PASSWORD': '123456',
                'CHARSET': 'utf8',
            }
        }
3.在models.py中添加
class User(models.Model):
    # 没有主键,Django会自动创建主键,这里我们指定uid为主键
    # verbose_name相当于SQL的comment 注释
    uid = models.AutoField(primary_key=True, verbose_name='编号')
    # CharField必须要指定长度max_length
    name = models.CharField(max_length=32, verbose_name='姓名')
    # IntegerField可以什么都不加
    age = models.IntegerField(verbose_name='年龄')
    # DateTimeField年月日时分秒,DecimalField年月日
    '''日期字段
        auto_now:每次操作数据并保存都会知道更新当前时间
        auto_now_add:只在创建数据的那一刻自动获取当前时间,之后不人为更改则不变
    '''
    join_time = models.DateField(auto_now_add=True)
4.执行数据库迁移命令
	1.将models中有关数据库的操作记录下来(migrations文件夹)
		python3 manage.py makemigrations
	2.将操作真正影响到数据库中
    	python3 manage.py migrate
5.模型层测试环境准备 # 只测试orm学习,所以不需要整Django都启动起来
	'''方式1:在任意的py文件中准备环境,比如在Django的test.py中,复制manage.py文件内容'''
        import os
        import sys

        def main():
            os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'day59.settings')
            # 下面是我们要测试的orm代码
            import django
            django.setup()

            from app01 import models
            print(models.User.objects.first())
            res = models.User.objects.create(name='jason', age=18)
            # 上面是我们要测试的orm代码
            """接下来就在这里测试rom了"""

        if __name__ == '__main__':
            main()   
	'''方式2:pycharm提供测试环境'''
    在python console(python终端)使用命令行,比如下面 #但是不好用,命令行模式,代码不能保存,关了就没了
            from app01 import models
            models.User.objects.filter()
		

orm常见查询关键字

# 在模型类中定义一个__str__方法,便于后续数据对象被打印展示的时候方便查看
# QuerySet中如果是列表套数据对象,那么直接for循环和索引取值,但是索引不支持是负数
# 虽然QuerySet支持索引,但是当QuerySet为None时候,会报错,所以推荐使用first()
'''
	1.create()
		创建
	2.update()
		更新
	3.delete()
		删除
'''

    在models.py中添加
        def __str__(self):
            """对象被执行打印(print,页面展示,数据查询)操作的时候自动触发"""
            return f'对象:{self.name}'  # 该方法必须要返回字符串类型的数据
1.create()
	创建数据,返回值就是当前创建的数据对象
    案例:
        res = models.User.objects.create(name='tony', age=18)
        print(res.name)
        print(res.age)
        print(res.join_time)
        print(res.uid)  # 打印主键uid
        print(res.pk)  # 无需核查主键字段真正的名字,通过pk直接获取
    '''还可以利用类实例化对象,调用save方法'''
    案例:
        user_obj = models.User(name='oscar', age=24)
        user_obj.save()
2.filter()
	筛选数据,返回值是一个QuerySet(可以看成是列表套数据对象)
    	1.括号内不写查询条件,默认表示查询所有
        2.括号内可以填写条件,并且支持多个逗号隔开,默认是and关系
	案例:
		res = models.User.objects.filter()  # 没有条件表示查所有
		print(res)  # <QuerySet [<User: 对象:jason>, <User: 对象:tony>, <User: 对象:oscar>]>
        
        res = models.User.objects.filter(name='jason', age=19)
        print(res) # 打印不出,括号内的条件是and的关系
3.all()
	查询所有数据,返回值是一个QuerySet(可以看成是列表套数据对象) 
	案例:
        res = models.User.objects.all()
        print(res) # <QuerySet [<User: 对象:jason>, <User: 对象:tony>, <User: 对象:oscar>]>
4.first()
	获取QuerySet中第一个数据对象,如果为空则返回None
    案例:
        res = models.User.objects.filter(name='jason').first()
        print(res)
5.last()
	获取QuerySet中最后一个数据对象,如果为空则返回None
	案例:
        res = models.User.objects.all().last()
        print(res)
6.get()
	直接根据条件查询具体的数据对象,但是条件不存在直接报错 "不推荐使用"
	案例:
    res = models.User.objects.get(pk=2)
    print(res)
7.values
	指定查询字段,结果是QuerySet(可以看成列表套字典数据)
	案例:
    res = models.User.objects.values('name', 'age')
    # res = models.User.objects.all().values('name', 'age')
    print(res)# <QuerySet [{'name': 'jason', 'age': 18}, {'name': 'tony', 'age': 18}, {'name': 'oscar', 'age': 24}]>
8.values_list
	查询指定查询字段,结果是QuerySet(可以看成是列表套元组数据)
	案例:
    res = models.User.objects.values_list('name', 'join_time')
    print(res)
9.order_by()
    指定字段排序,默认是升序,在字段前加负号,则为降序,并且支持多个字段排序
    # res = models.User.objects.order_by('age')  # 升序
    res = models.User.objects.order_by('-age')  # 降序
    print(res)
10.count()
	统计orm查询之后结果集 中的数据个数
    案例:
	res = models.User.objects.all().count()
    print(res)
11.distinct()
	针对重复的数据集进行去重,一定要注意数据对象中的主键
	案例:
    res = models.User.objects.values('name').distinct()
    print(res)
12.exclude()
	针对括号内的条件取反进行数据查询
	案例:
	res = models.User.objects.exclude(pk=1)
    print(res)
13.reverse() "很少用到"
	针对已经排了序的结果集做颠倒
    案例:
    res = models.User.objects.all().order_by('age').reverse()
    print(res)
14.exists()
	判断查询结果集是否有数据,返回的结果是布尔值,但是几乎不用,所有的数据自带布尔值
	案例:
    res = models.User.objects.exists()
    print(res) # True
15.raw()
	执行SQL语句,结果可以用for循环取值
    案例:
    res = models.User.objects.raw('select * from app01_user')
    print(list(res)) # [<User: 对象:jason>, <User: 对象:tony>, <User: 对象:oscar>]
    
 	还可以借助于模块,这里就直接百度下来的案例了
    from django.db import connection  
    cursor = connection.cursor()  
    cursor.execute("insert into hello_author(name) VALUES ('郭敬明')") 
    cursor.execute("update hello_author set name='韩寒' WHERE name='郭敬明'")  
    cursor.execute("delete from hello_author where name='韩寒'")  
    cursor.execute("select * from hello_author")  
    cursor.fetchone()  
    cursor.fetchall()

双下划线查询

1.比较运算符
	字段__gt  大于
    字段__lt  小于
    字段__gte 大于等于
    字段__lte 小于等于
	案例:
    # 查询年龄大于20的数据
    res = models.User.objects.filter(age__gt=20)
	# 查询年龄小于20的数据
    res = models.User.objects.filter(age__lt=20)
2.成员运算
	字段__in
    案例:
    # 查询姓名是jason或者kevin的数据
    res = models.User.objects.filter(name__in=['jason', 'tony'])
3.氛围查询,(针对数字),顾头又顾尾
	字段__range
	案例:
    # 查询年龄在18到24之间的数据
    res = models.User.objects.filter(age__range=(18, 24))
4.模糊查询
	字段__contains 不忽略大小写
    字段__icontains 忽略大小写
    字段__startswith 以什么开头
    字段__endswith 以什么小写
	案例:
    # 查询姓名中含有字母j的数据
    res = models.User.objects.filter(name__contains='j')
5.日期处理
	字段__year
    字段__month
    字段__day
    案例:
    # 查询注册年份是2023年的数据
    res = models.User.objects.filter(join_time__year=2023)
    # 查询注册月份是4月的数据
    res = models.User.objects.filter(join_time__month=4)
    # 查询注册是25号的数据
    res = models.User.objects.filter(join_time__day=25)

查看orm底层SQL

方式1
	如果是QuerySet对象,可以直接点QuerySet查看SQL语句 #有局限,如果不是QuerySet对象就不能查看
    案例:
	res = models.User.objects.filter(join_time__day=25)
    print(res.query) # SELECT `app01_user`.`uid`, `app01_user`.`name`, `app01_user`.`age`, `app01_user`.`join_time` FROM `app01_user` WHERE EXTRACT(DAY FROM `app01_user`.`join_time`) = 25
方式2
	配置文件配置,打印所有orm操作对应的SQL语句
    案例:
       	1.在settings.py中添加
            LOGGING = {
                'version': 1,
                'disable_existing_loggers': False,
                'handlers': {
                    'console': {
                        'level': 'DEBUG',
                        'class': 'logging.StreamHandler',
                    },
                },
                'loggers': {
                    'django.db.backends': {
                        'handlers': ['console'],
                        'propagate': True,
                        'level': 'DEBUG',
                    },
                }
            }
	2.执行orm
		res = models.User.objects.filter(join_time__day=25)
         print(res)
		pycharm打印 # (0.000) SELECT `app01_user`.`uid`, `app01_user`.`name`, `app01_user`.`age`, `app01_user`.`join_time` FROM `app01_user` WHERE EXTRACT(DAY FROM `app01_user`.`join_time`) = 25  LIMIT 21; args=(25,)

orm外键字段创建

一对多
	orm外键字段建在多的一方 models.ForeignKey()
    	会自动添加_id的后缀
多对多
	orm中有三种创建多对多字段的方式 models.ManyToManyField()
    	方式1:直接在查询频率较高的表中添加字段即可,自动创建第三张关系表
        方式2:自己创建第三张关系表
        方式3:自己创建第三张关系表,但是还使用orm多对多字段做关联
一对一
	orm中外键字段建在查询频率较高的表中 models.OneToOneField()
    	会自动添加_id的后缀
Django1.x 针对 models.ForeignKey() models.OneToOneField() 不需要 on_delete参数
Django2.x 3.x 则需要添加on_delete参数

案例:
        class Book(models.Model):
            title = models.CharField(max_length=32)
            # 价格总共8位,小数占2位
            price = models.DecimalField(max_digits=8, decimal_places=2)
            publish_time = models.DateTimeField(auto_now=True)
            publish = models.ForeignKey(to='Publish', on_delete=models.CASCADE)
            authors = models.ManyToManyField(to='Author')

            def __str__(self):
                return '书籍对象:%s' % self.title

        class Publish(models.Model):
            name = models.CharField(max_length=32)
            email = models.EmailField()

            def __str__(self):
                return '出版社对象:%s' % self.name

        class Author(models.Model):
            name = models.CharField(max_length=32)
            age = models.IntegerField()
            author_detail = models.OneToOneField(to='AuthorDetail', on_delete=models.CASCADE)

            def __str__(self):
                return '作者对象:%s' % self.name

        class AuthorDetail(models.Model):
            phone = models.BigIntegerField()
            addr = models.CharField(max_length=255)

            def __str__(self):
                return '作者详情对象:%s' % str(self.phone)
	2.pycharm的cmd终端执行
    	python3 manage.py makemigrations
        python3 manage.py migrate

# 准备些数据,方便下面的案例
app01_authordetail表 手动添加3条数据 
	id=1,phone=110,addr=芜湖
    id=2,phone=120,addr=山东
    id=3,phone=130,addr=武汉
app01_author表 手动添加3条数据
	id=1,name=jason,age=18,author_detail_id=1
    id=2,name=kevin,age=28,author_detail_id=2
    id=3,name=jerry,age=20,author_detail_id=3
app01_publish表 手动添加3条数据
	id=1,name=北方出版社,email=北京
    id=2,name=南方出版社,email=南京
    id=3,name=东方出版社,email=东京

外键字段数据操作

# 一对多
publish = models.ForeignKey(to='Publish', on_delete=models.CASCADE)
	方式1:直接给实际字段添加关联数据值 publish_id=1
    models.Book.objects.create(title='Python从入门到放弃', price=29800.88, publish_id=1)
    方式2:间接使用外键虚拟字段添加数据对象 publish=publish_obj
    publish_obj = models.Publish.objects.filter(pk=2).first()
    models.Book.objects.create(title='Django从入门到入土', price=19888.88, publish=publish_obj)
# 一对一
author_detail = models.OneToOneField(to='AuthorDetail', on_delete=models.CASCADE)
	方式1:直接给实际字段添加关联数据值 author_detail_id=1
	方式2:间接使用外键虚拟字段添加数据对象 author_detail=authorDetail_obj
# 多对多 给第三张表添加数据
authors = models.ManyToManyField(to='Author')
	# 再多加几本书,方便下面做案例
		models.Book.objects.create(title='Golang高并发', price=39800.88, publish_id=3)
		models.Book.objects.create(title='Linux云计算', price=19800.88, publish_id=1)
		models.Book.objects.create(title='Python数据分析', price=24800.88, publish_id=2)
	
	add()
    	去第三张表中添加数据,括号内既可以填写数据值,也可以填写数据对象,支持多个
        案例:
            book_obj = models.Book.objects.filter(pk=1).first()
            book_obj.authors.add(1)  # 朝第三张关系表添加数据 这里的1指的是作者的主键id1
            book_obj.authors.add(2, 3) # 添加多个作者id
            author_obj1 = models.Author.objects.filter(pk=1).first() #作者1对象
            author_obj2 = models.Author.objects.filter(pk=2).first() #作者2对象
            book_obj.authors.add(author_obj1) # 添加作者1对象
            book_obj.authors.add(author_obj1,author_obj2) # 添加多个作者对象
    remove()
    	删除数据,括号内既可以填写数据值,也可以填写数据对象,支持多个
        案例:
            book_obj = models.Book.objects.filter(pk=1).first()
            book_obj.authors.remove(1)  # 这里的1指的是作者主键id1
            book_obj.authors.remove(2, 3)  # 这里的1指的是作者主键id1和2
            author_obj1 = models.Author.objects.filter(pk=1).first() #作者1对象
            author_obj2 = models.Author.objects.filter(pk=2).first() #作者2对象
             book_obj.authors.remove(author_obj1) #删除作者1对象
            book_obj.authors.remove(author_obj1, author_obj2) #删除多个作者对象
    set()
    	修改数据 括号内必须是可迭代对象
        案例:
            book_obj = models.Book.objects.filter(pk=1).first()
            book_obj.authors.set([2, ]) # 修改作者1的主键id为2
    clear()
    	清空指定数据 括号内不需要任何参数
        案例:
            book_obj = models.Book.objects.filter(pk=1).first()
            book_obj.authors.clear() # 清空书的主键为1的数据

正反向概念

正反向的概念核心在于外键字段在谁手上

正向查询
	通过书查询出版社,外键字段在书表里
    
反向查询
	通过出版社查询书,外键字段不在出版社表中

"""orm跨表查询口诀:正向查询按外键字段,反向查询按表名小写"""

基于对象的跨表查询(子查询)

正向查询:
	"""一对多"""
    # 1.查询主键为1的书籍对应的出版社名称(书>>>出版社)
    # 1.1.先根据条件查询数据对象(先查数据对象)
    book_obj = models.Book.objects.filter(pk=1).first()
    # 1.2.以对象为基准,思考正反向概念(书查出版社,外键字段在书表中,所以是正向查询)
    print(book_obj.publish.name)
    """多对多"""
    # 2.查询主键为3的书籍对应的作者(书>>>作者)
    # 2.1.先根据条件查询数据对象(先查书籍对象)
    book_obj=models.Book.objects.filter(pk=3).first()
    # 2.2.以对象为基准,思考正反向概念(书查作者,外键字段在书表中,所以是正向查询)
    print(book_obj.authors.all()) """结果是多个的情况,要用all()"""
    """一对一"""
    # 3.查询jason的作者详情
    # 3.1.先根据条件查询数据对象
    author_obj = models.Author.objects.filter(name='jason').first()
    # 3.2.以对象为基准,思考正反向概念
    print(author_obj.author_detail)

反向查询:
	"""一对多"""
    # 4.查询南方出版社查询的书籍
    # 4.1.先拿出版社对象
    publish_obj = models.Publish.objects.filter(name='南方出版社').first()
    # 4.2.思考正反向
    print(publish_obj.book_set.all()) """结果是多个的情况,要用_set.all()"""
    """多对多"""
    # 5.查询jason写过的书
    # 5.1.先拿作者对象
    author_obj = models.Author.objects.filter(name='jason').first()
    # 5.2.思考正反向
    print(author_obj.book_set.all()) """结果是多个的情况,要用_set.all()"""
    """一对一"""
   	# 查询电话是110的作者
    # 6.1.先拿作者详情对象
    author_detail_obj = models.AuthorDetail.objects.filter(phone=110).first()
    # 6.2.思考正反向
    print(author_detail_obj.author) """单个数据不用_set.all()"""

基于双下划线的跨表查询(连表操作)

    """一对多"""
    # 1.查询主键为1的书籍对应的出版社名称及书名
    res = models.Book.objects.filter(pk=1).values('publish__name', 'title')
    print(res)
    """多对多"""
    # 2.查询主键为3的书籍对应的作者姓名及书名
    res = models.Book.objects.filter(pk=3).values('authors__name','title')
    print(res)
    """一对一"""
	# 3.查询jason的作者的电话号码和地址
    res = models.Author.objects.filter(name='jason').values('author_detail__addr','author_detail__phone','name','age')
    print(res)
    """一对多"""
    # 4.查询南方出版社出版的书籍名称及价格
    res = models.Publish.objects.filter(name='南方出版社').values('book__title','book__price')
    print(res)
    """多对多"""
    # 5.查询jason写过的书名和日期
    res = models.Author.objects.filter(name='jason').values('book__title','book__publish_time')
    print(res)
    """一对一"""
    # 6.查询电话是110的作者姓名和年龄
    res = models.AuthorDetail.objects.filter(phone='110').values('author__name','author__age')
    print(res)
三个表查询:用外键关联起来
    # 7.查询主键为1的书籍对应的作者电话号码
    res = models.Book.objects.filter(pk=1).values('authors__author_detail__phone')
    print(res)

正反向查询进阶

    # 1.查询主键为1的书籍对应的出版社名称及书名
    res = models.Publish.objects.filter(book__pk=1).values('name', 'book__title')
    print(res)
    
    # 2.查询主键为3的书籍对应的作者姓名及书名
    res = models.Author.objects.filter(book__pk=3).values('name','book__title')
    print(res)
    
	# 3.查询jason作者的电话号码和地址
    res = models.AuthorDetail.objects.filter(author__name='jason').values('phone', 'addr')
    print(res)
    
	# 4.查询南方出版社出版的书籍名称和价格
    res = models.Book.objects.filter(publish__name='南方出版社').values('title','price')
    print(res)
    
    # 5.查询jason写过的书的名称和日期
    res = models.Book.objects.filter(authors__name='jason').values('title', 'publish_time')
    print(res)
    
    # 6.查询电话是110的作者姓名和年龄
    res = models.Author.objects.filter(author_detail__phone='110').values('name', 'age')
    print(res)
    
	# 7. 查询主键为1的书籍对应的作者电话号码
    res = models.AuthorDetail.objects.filter(author__book__pk=1).values('phone')
    	# 或
    res = models.Author.objects.filter(book__pk=1).values('author_detail__phone')
    print(res)