欢迎光临
我们一直在努力
Hi, 请登录   找回密码

django中操作mysql数据库的方法

2022-12-26 分类：MySQL 阅读(193) 评论(0) 扫描二维码 隐藏侧边

对象关系映射模式是一种为了解决面向对象与关系数据库存在的互不匹配的现象的技术，这篇文章主要介绍了django中操作mysql数据库的方法,需要的朋友可以参考下！

1.准备工作（django连接数据库）

1.本机电脑下载好mysql数据库2.打开django，修改setting.py中的DATABASES配置项

  1. DATABASES = {
  2. 'default': {
  3. 'ENGINE': 'django.db.backends.mysql',
  4. 'NAME': 'python',
  5. 'USER': 'root',
  6. 'PASSWORD': 'zy199909237412',
  7. 'HOST': '127.0.0.1',
  8. 'POST': '3306',
  9. }
  10. }

3.在pycharm的右侧栏点击database或者做下角点击database，连接数据库,如果都没有，则去pluging里面寻找是否装了database插件！！

django中操作mysql数据库的方法

或者

django中操作mysql数据库的方法

4.输入需要连接的数据库

django中操作mysql数据库的方法

5.这里没有下载驱动的需要先下载，不然连接不上

django中操作mysql数据库的方法

6.在django项目中的__init__.py中导入pymysql，告诉django使用pymysql连接数据库，而不是mysqldb模块

  1. import pymysql
  2. pymysql.install_as_MySQLdb()

7.简单使用pycharm操作数据库

django中操作mysql数据库的方法

2.django操作数据库（ORM）

2.1 ORM简介

对象关系映射（Object Relational Mapping，简称ORM）模式是一种为了解决面向对象与关系数据库存在的互不匹配的现象的技术。ORM在业务逻辑层和数据库层之间充当了桥梁的作用

简单来说，ORM就是使用面向对象的方式来操作数据库！

（1）ORM的优势：

1.将表和类一一对应，类的每个实例对应表中的一条记录，类的每个属性对应表中的每个字段。2.ORM提供了对数据库的映射，不用直接编写SQL代码，只需操作对象就能对数据库操作数据，提高了工作效率

(2)ORM的劣势

1.一些查询操作完成不了2.一定程度上牺牲了程序的执行效率3.用久了会忘SQL语言

2.2 创建表和字段

  1. from django.db import models # 1.导入models模块
  2.  
  3. # 2.定义一个类继承models.Model类（创建一张项目名（应用名）_类名的表）
  4. class Book(models.Model):
  5.  
  6. # 3.定义类属性title和price（对应是创建字段名、字段类型和字段选项）
  7. title = models.CharField('书名', max_length=50, default='')
  8. price = models.DecimalField('价格', max_digits=7, decimal_places=2)
  9.  
  10. class 模型类名（models.Model):
  11. 字段名 = models.字段类型（字段选项）
  12.  
  13.  
  14. 在类里面不指定主键字段，django会帮您自动创建一个id主键！

注意：对于数据库的增删改查之后都要进行数据库迁移1.执行python3 manage.py makemigration---将应用下的model.py文件生成一个中间件文件，并保存在migrations文件中2.执行python3 manage.py migrate ----将每个应用下的migrations目录中的中间文件同步回数据库

2.3 字段的增删改查

1.增加字段

  1. 直接在对应的类里面添加字段、字段类型和字段选项
  2.  
  3. 注意增加的字段都需要指定default = '' 或者null = True，如下添加info字段：
  4.  
  5. info = models.CharField(max_length=32,default='',null=True)

2.修改字段

直接在类里面修改对应字段就行！

然后执行数据库迁移命令！

3.字段的删除

直接在类里面将需要删的字段注释掉就行！然后执行数据库迁移命令！

注意：执行完毕了，数据库对应的数据就没有了！慎重！！！

2.4 单表数据的增删改查

每个继承model.Model的模型类，都有一个objects对象被同样继承下来，这个对象叫管理器对象，数据库的增删改查都是通过模型的管理器实现。

对于数据的增删改查，其实最主要的都是在views.py的视图函数里完成的！因此，我们需要在视图函数里进行数据库的增删改查操作！

2.4.1单表数据的查询

1.filter（）查询方法

  1. from app01 import models # 1.导入自己创建的模型类
  2.  
  3. # 2.filter查询方法，语法是:models.类名.objects.filter()，filter内可以查询多个参数，默认是and连接，等于SQL语法的where方法！，不传参时代表查所有
  4.  
  5. res = models.MyModle.objects.filter(username=username)
  6. # 该方法有一个返回值，返回的是一个queryset对象，该对象可以看成是列表套字典的形式，列表里面套着一个个数据对象，形式为：[数据对象1，数据对象2]
  7. # queryset列表也支持索引，切片操作，但是不支持负数索引，可以当成列表套字典的形式for循环
  8.  
  9. user_obj = res[0] # 得到的是具体的数据对象，但是官方不推荐使用索引的方式取到具体的数据对象，它推荐的是res.first()方法取到列表里的第一个数据对象！
  10.  
  11. print(user_obj.username) # 通过点大法，即.属性的方法得到具体的值

2.all（）查询所有方法

  1. # all方法查询User表的所有数据，返回的是一个queryset对象列表，
  2. user_queryset = models.User.objects.all()

2.4.2单表数据的增加

1.create（）方法

  1. # create增加数据方法，语法是:models.类名.objects.create()
  2. res = models.MyModle.objects.create(username=username,password=password)
  3. # 该方法也有一个返回值，返回的是当前这个数据对象
  4. print(res.username,res.password) # 可以通过点属性的方法，查看到对应属性的值

2.save（）方法

  1. obj = models.User(username=username,password=password)
  2. obj.save() # 保存数据到数据库

2.4.3单表数据的修改

1.upadte（）方法：先查出来，在更新

  1. # 查出id为什么的对象，然后进行批量更新。filter可以查所有，也可以查具体
  2. models.User.objects.filter(id=edit_id).update(username=username,password=password)

2.赋值+save（）方法

  1. obj = models.User.objects.filter(id=edit_id).first() #拿到待修改的对象
  2. obj.username = username # 采用给该对象属性重新赋值的方法修改数据
  3. obj.password = password
  4. obj.save() # 最后赋值完记得需咬保存

2.4.4单表数据删除

1.delete()方法：用于批量删除

  1. # 先filter查出需要删除的对象，然后.delete（）方法
  2. models.User.objects.filter(id=delete_id).delete() # 这里是把filter查出来的queryset对象里全部删除了，有几个删几个。
  3. # 这里的id可以改写成pk，用了pk就不需要知道表的主键是id还是其他什么了！

2.单一删除

  1. res = models.User.objects.filter(id=delete_id).first()
  2. res.delete() # 单一删除

2.4.5补充13条单表查询

  1. # 1.all() 查询所有数据
  2.  
  3. # 2.filter() 带有过滤条件的查询，拿到的是一个queryset对象列表
  4.  
  5. # 3.get()直接拿数据对象 但是条件不存在直接报错
  6.  
  7. # 4.first() 拿queryset里面第一个元素
  8. # res = models.User.objects.all().first()
  9. # print(res) # 拿到queryset对象列表里的第一个数据对象
  10.  
  11. # 5.last()
  12. # res = models.User.objects.all().last()
  13. # print(res) # 同上，拿到的是最好一个
  14.  
  15. # 6.values() 可以指定获取的数据字段 select name,age from ...
  16. # res = models.User.objects.values('name','age')
  17. # print(res) # 结果为：列表套字典<QuerySet [{'name': 'jason', 'age': 18}, {'name': 'egonPPP', 'age': 84}]>
  18.  
  19. # 7.values_list()
  20. # res = models.User.objects.values_list('name','age')
  21. # print(res) # 结果为：列表套元祖，<QuerySet [('jason', 18), ('egonPPP', 84)]>
  22.  
  23. # 8.query
  24. # print(res.query) # 查看内部封装的sql语句
  25. # 上述查看sql语句的方式 只能用于queryset对象
  26. # 只有queryset对象才能够点击query查看内部的sql语句
  27.  
  28. # 9.distinct() 去重
  29. # res = models.User.objects.values('name','age').distinct()
  30. # print(res)
  31. """
  32. 去重一定要是一模一样的数据
  33. 如果带有主键那么肯定不一样 你在往后的查询中一定不要忽略主键
  34. """
  35.  
  36. # 10.order_by()
  37. # res = models.User.objects.order_by('age') # 默认升序
  38. # res = models.User.objects.order_by('-age') # 降序
  39. # print(res)
  40.  
  41. # 10.reverse() 反转的前提是 数据已经排过序了 order_by()
  42. # res = models.User.objects.all()
  43. # res1 = models.User.objects.order_by('age').reverse()
  44. # print(res,res1)
  45.  
  46. # 11.count() 统计当前数据的个数
  47. # res = models.User.objects.count()
  48. # print(res)
  49.  
  50. # 12.exclude() 排除在外
  51. # res = models.User.objects.exclude(name='jason')
  52. # print(res)
  53.  
  54. # 13.exists() #基本用不到因为数据本身就自带布尔值 返回的是布尔值
  55. # res = models.User.objects.filter(pk=10).exists() # 判读主键为10的是否存在，返回是布尔值
  56. # print(res)

2.4.6 神奇的双下划线查询

  1. __exact:等值查询
  2. __contains:包含指定值--区分大小写 a2=Book.objects.filter(name____contains=‘n') 查询出名字里包含n的
  3. __icontains:包含指定值--忽略大小写
  4. __startwith:以xxx开始
  5. __endwith:以xxx结尾
  6. __gt:大于指定值，例如：a2=Book.objects.filter(id__gt=3)
  7. __gte:大于等于
  8. __it:小于
  9. __ite：小于等于
  10. __in:查找数据是否在指定范围内 a2=Book.objects.filter(id__in=[1,3,5])
  11. __range:查询数据是否在指定区间范围内 a2=Book.objects.filter(id__range=[1,5]) 查询出id在1-5的收尾都要
  12. a2=Book.objects.filter（register_time__month='1'）:查询出月份是1月的数据
  13. a2=Book.objects.filter（register_time__year='2022'）:查询出年份在2022的数据

2.5 多表数据操作

2.5.1 orm创建表关系

表的关系有三种，分别是：一对一、一对多、多对多

判断表和表之间的关系：换位思考法

具体创建表关系语法：

  1. """
  2. 图书和出版社：一对多关系，外键建在多的一方
  3. 图书和作者：多对多关系，外键建在任何一方，但是推荐建在查询频率高的一方
  4. 作者和作者详情：一对一关系，外键建在任何一方，但是推荐建在查询频率高的一方
  5. """
  6. class Book(models.Model):
  7. title = models.CharField(verbose_name='书名',max_length=32)
  8. price = models.DecimalField(max_digits=8,decimal_places=2)
  9. create_time = models.DateTimeField(auto_now_add=True)
  10. # 一对多外键建在多的一方，to='是需要建立外键的那一个类名publish'
  11. # 注意：在django2、3里面需要指定级联删除参数on_delete=models.CASCADE
  12. publish = models.ForeignKey(to='Publish',on_delete=models.CASCADE)
  13. # 多对多外键建在查询频率高的一方，多对多在sql语句中需要自己手动建第三张表，但是在django中，django遇到会自动帮你创建第三张表！
  14. author = models.ManyToManyField(to='Author')
  15.  
  16. class Publish(models.Model):
  17. name = models.CharField(max_length=32)
  18. addr = models.CharField(max_length=64)
  19. email = models.EmailField()
  20.  
  21. class Author(models.Model):
  22. name = models.CharField(max_length=32)
  23. age = models.IntegerField()
  24. # 一对一外键建在查询频率高的一方，需要指定on_delete
  25. author_detail = models.OneToOneField(to='AuthorDetail',on_delete=models.CASCADE)
  26.  
  27. class AuthorDetail(models.Model):
  28. phone = models.BigIntegerField()
  29. addr = models.CharField(max_length=64)

2.5.2 一对多关系的增删改

  1. from app01 import models
  2. # 1.增
  3. # 法1：直接写book表里面的外键的实际字段名，然后指定关联publish的id就行
  4. models.Book.objects.create(title='活着',price=33,publish_id=1)
  5. # 法2：虚拟字段，传入一个具体的publish的数据对象就行
  6. publish_obj = models.Publish.objects.filter(pk=2).first()
  7. # 注意这里需要.first()一下，因为不点拿到的是queryset对象，点一下拿到queryset里的具体数据对象
  8. models.Book.objects.create(title='我',price=555,publish=publish_obj)
  9.  
  10. # 2.删
  11. models.Publish.objects.filter(pk=2).delete() # 将book里关联id=2的也全部删除
  12.  
  13. # 3.改
  14. # 法1：update里面传具体需要修改的外键字段名和值
  15. models.Book.objects.filter(pk=2).update(publish_id=2) # 将id为2的书的关联publish_id改成2
  16. # 法2：update里面传入虚拟字段publish=需要关联的publish数据对象，同增的法2

2.5.3 多对多关系的增删改

  1. # 1.增
  2. # 一本书对应多个作者，先查出这个书的对象，在通过对象.多对多字段名.add()方法关联作者id
  3. # add()方法里面可以法数字1,2,3，表示关联作者的主键值；还可以放具体的作者数据对象！！
  4. book_obj = models.Book.objects.filter(pk=1).first()
  5. book_obj.author.add(1,2)
  6. author_obj = models.Author.objects.filter(pk=1).first()
  7. book_obj.author.add(author_obj)
  8.  
  9. # 2.删
  10. # 删除这边书关联的作者id为1和2的，和add方法一样也支持里面放具体的作者数据对象！！
  11. book_obj.author.remove(1,2)
  12.  
  13. # 3.改
  14. # set方法修改该书关联的作者id为1和3，set方法和add方法一样也支持里面放具体的作者数据对象！！
  15. # 注意：set方法里面必须放一个可迭代对象，比如列表！
  16. book_obj.author.set([1,3])
  17.  
  18. # 4.清空当前书和作者的对应关系
  19. book_obj.author.clear()

2.5.4 多表的查询操作

查询的时候，分正方向查询，外键字段在我手上，我查你就是正向查询；反之，不在我手上，我查你就是反向查询。

查询口诀：正向查询按字段，反向查询按表名小写；

1.基于对象的多表查询

  1. from app01 import models
  2.  
  3. # 1.查询书籍主键为1的出版社名称 ----正向一对多查询
  4. book_obj = models.Book.objects.filter(pk=1).first() # 先得到主键为1的书籍对象
  5. res = book_obj.publish # 正向查询按字段，Book表里面有一个publish字段，返回一个与主键1关联的出版社对象
  6. print(res)
  7. print(res.name) # 对象.的方法查询具体的字段属性
  8. print(res.addr)
  9.  
  10. # 2.查询书籍主键为1的作者----正向多对多查询
  11. book_obj1 = models.Book.objects.filter(pk=1).first()
  12. res = book_obj1.author.all() # 不.all()返回的是一个app01.Author.None
  13. print(res) # .all()返回的是<QuerySet [<Author: Author object (1)>, <Author: Author object (2)>]>,书籍id为1对应两个作者
  14. print(res.first().name) # 通过.first().name 方式获取作者的具体信息
  15.  
  16. # 3.查询作者王的电话 ----正向一对一查询
  17. author_obj = models.Author.objects.filter(name='王').first()
  18. res = author_obj.author_detail
  19. print(res) # 返回的是AuthorDetail object (1)，是一个作者详情对象
  20. print(res.phone) # .字段查出对应作者的详情信息
  21. """
  22. 总结：正向查询时，当你的结果可能是多个的时候，就需要加.all(),如果是一个直接拿到数据对象
  23. """
  24.  
  25. # 4.查询出版社是东风出版社的书----反向一对多查询
  26. publish_obj = models.Publish.objects.filter(name='东风').first()
  27. res = publish_obj.book_set.all()
  28. print(res)
  29.  
  30. # 5.查询作者是王写过的书----反向多对多查询
  31. author_obj = models.Author.objects.filter(name='王').first()
  32. res = author_obj.book_set.all()
  33. print(res)
  34.  
  35. # 6.查询电话号码是122324233的作者
  36. author_detail_obj = models.AuthorDetail.objects.filter(phone=122324233).first()
  37. res = author_detail_obj.author
  38. print(res.name)
  39. """
  40. 总结：反向查询的时候，如果结果为多个，就需要加_set.all();如果是一对一结果就一个，就不用！
  41. """

2.基于双下划线__的多表查询

  1. from app01 import models
  2.  
  3. # 1.查询王这个作者的年龄和手机号--正向一对一查询
  4. # 先得到王这个对象，然后.values，里面放需要查询的字段名，正向则直接'字段名'；反向则'表名小写__字段名'
  5. res = models.Author.objects.filter(name='王').values('age','author_detail__phone')
  6. print(res) # 得到的是一个queryset对象(列表里套了一个字典)
  7. dict = res.first() # .first()方法取到该字典对象
  8. print(dict['age']) # 字典方式取到具体需要的值
  9. # 反向查询
  10. res = models.AuthorDetail.objects.filter(author__name='王').values('phone','author__age')
  11. print(res)
  12.  
  13. # 2.查询书籍主键为1的出版社名字和书的价格---正向一对多查询
  14. res = models.Book.objects.filter(pk=1).values('price','publish__name')
  15. print(res)
  16. # 反向查询
  17. res = models.Publish.objects.filter(book__id=1).values('name','book__price')
  18. print(res)
  19.  
  20. # 3.查询书籍主键为1的作者姓名和书籍名称
  21. res = models.Book.objects.filter(pk=1).values('title','author__name')
  22. print(res)
  23. # 反向查询
  24. res = models.Author.objects.filter(book__id=1).values('name','book__title')
  25. print(res)
  27. # 4.终极大招：查询书籍主键为1的作者的电话号码！！！---跨了book、author、author_detail三张表查询
  28. res =models.Book.objects.filter(pk=1).values('author__author_detail__phone')
  29. print(res)
  30. # 反向查询
  31. res = models.Author.objects.filter(book__id=1).values('author_detail__phone')
  32. print(res)

2.6 字段类型与字段选项

  1. from django.db import models
  2.  
  3. # Create your models here.
  4. class MyBook(models.Model):
  5. # 1.字符串字段类型CharField，必须传的字段选项是max_length=指定最大字符数，verbose_name=''指定该字段在django后台管理中的描述名
  6. name = models.CharField(max_length=32,verbose_name='姓名')
  8. # 2.数字字段类型IntegerField
  9. age = models.IntegerField()
  11. # 3.日期时间字段类型DateTimeField
  12. register_time = models.DateTimeField(auto_now_add=True)
  14. # 4.日期字段类型
  15. register_time = models.DateField(auto_now_add=True)
  17. # 针对这两个字段类型，有两个关键性参数
  18. # auto_now:每次操作数据的时候，该字段会自动将当前时间更新
  19. # auto_now_add：在创建数据的时候会自动将当前时间记录下来，以后只要不认为修改就一直不变
  21. # 5.邮箱字段
  22. email = models.EmailField()
  24. # 6.大数字字段类型
  25. phone = models.BigIntegerField()
  27. # 7.小数字段，有两个字段选项max_digits=8,表示连小数一共8位；decimal_places=2，表示小数部分2位。
  28. price = models.DecimalField(max_digits=8,decimal_places=2)
  30. # 8.布尔型字段,传入参数是False\True，在数据库中对应0
  31. boolean = models.BooleanField(False)
  33. # 9.文本字段类型，没有字数限制，大文本
  34. text = models.TextField()
  36. # 10.文件字段类型,upload_to=''参数：给该字段传一个文件对象，会自动将该文件保存在/data目录下，如何把该文件的路径传到数据库中
  37. file = models.FileField(upload_to='/data')
  39. 自定义字段暂略

2.7聚合查询

聚合函数通常是和分组一起使用的，关键字.aggregate()方法

  1. # 先导入五个聚合函数
  2. """
  3. 小技巧：只要跟数据库相关的模块，基本上都在django.db.models里面
  4. 如果没有则可能在django.db里面
  5. """
  6. from django.db.models import Sum,Avg,Min,Max,Count
  7. # 1.求书这个表里面的价格平均值和总合和最大值...单独使用需要使用.aggregate方法
  8. res = models.Book.objects.aggregate(Avg('price'),Max('price'),Sum('price'))
  9. print(res)

2.8分组查询

分组查询关键字annotate

  1. # 1.统计每本书的作者个数
  2. res = models.Book.objects.annotate(author_num=Count('author')).values('author_num')
  3. print(res)
  4. """
  5. 说明：
  6. 1.分组查询的关键字是annotate
  7. 2.models后面点什么，就是按什么分的组
  8. 3.author_num是自己自定义的字段，用来存统计出来的每本书对应的个数
  9. 4.count里面的author指的是统计作者的个数
  10. 5.values('author_num')是取出统计出来的作者个数
  11. """
  12.  
  13. # 2.统计每个出版社卖的最便宜书的价格
  14. res = models.Publish.objects.annotate(book_price=Min('book__price')).values('name','book_price')
  15. print(res)
  16. print('=========')
  17. # 3.统计作者个数不止一个的图书
  18. # 先按图书分组，求出图书对应的作者个数；再filter过滤出作者个数大于1的
  19. res = models.Book.objects.annotate(author_num=Count('author')).filter(author_num__gt=1).values('title','author_num')
  20. print(res)
  21.  
  22. # 4.查询每个作者出的书的总价格
  23. res = models.Author.objects.annotate(book_price=Sum('book__price')).values('name','book_price')
  24. print(res)
  25.  
  26. """
  27. 那么如何按照字段分组呢？
  28. models.Book.objects.values('price').annotate()
  29. # 如果annotate前面出现了values，则它将不在按照book分组，而是按照values分组
  30. """

2.9F与Q查询

2.9.1F查询

  1. # F查询
  2. # 1.查询卖出数大于库存数的书籍
  3. # F查询
  4. """
  5. 能够帮助你直接获取到表中某个字段对应的数据
  6. """
  7. from django.db.models import F # 导入f模块
  8. # res = models.Book.objects.filter(maichu__gt=F('kucun')) #f括号里放的是对应的字段名
  9. # print(res)
  10.  
  11.  
  12. # 2.将所有书籍的价格提升500块
  13. # models.Book.objects.update(price=F('price') + 500)
  14.  
  15.  
  16. # 3.将所有书的名称后面加上爆款两个字
  17. """
  18. 在操作字符类型的数据的时候 F不能够直接做到字符串的拼接
  19. """
  20. from django.db.models.functions import Concat
  21. from django.db.models import Value # 先导入Concat和Value模块
  22. models.Book.objects.update(title=Concat(F('title'), Value('爆款')))
  23. # models.Book.objects.update(title=F('title') + '爆款') # 所有的名称会全部变成空白

2.9.2Q查询

  1. # Q查询
  2. # 1.查询卖出数大于100或者价格小于600的书籍
  3. # res = models.Book.objects.filter(maichu__gt=100,price__lt=600)
  4. """filter括号内多个参数是and关系，并不能得到结果"""
  5. from django.db.models import Q # 导入q模块，实现或和not功能
  6. # res = models.Book.objects.filter(Q(maichu__gt=100),Q(price__lt=600)) # Q包裹逗号分割 还是and关系
  7. # res = models.Book.objects.filter(Q(maichu__gt=100)|Q(price__lt=600)) # | or关系
  8. # res = models.Book.objects.filter(~Q(maichu__gt=100)|Q(price__lt=600)) # ~ not关系
  9. # print(res) # <QuerySet []>
  10.  
  11. # Q的高阶用法 能够将查询条件的左边也变成字符串的形式
  12. q = Q()
  13. q.connector = 'or'
  14. q.children.append(('maichu__gt',100))
  15. q.children.append(('price__lt',600))
  16. res = models.Book.objects.filter(q) # 默认还是and关系
  17. print(res)
打赏微海报分享

AD：【飞鱼博客】本站文章与软件大多收集于互联网搬运，如有版权问题，请联系博主及时删除！

 收藏 (0) 打赏

您可以选择一种方式赞助本站

支付宝扫一扫赞助

微信钱包扫描赞助

除特别注明外，本站所有文章均基于CC-BY-NC-SA 4.0原创，转载请注明出处。
文章名称：《django中操作mysql数据库的方法》
文章链接：https://www.xpn.cc/3714/fy.html。
分享到： 更多 (0)

相关推荐

热门推荐

评论 抢沙发

取消

登录

忘记密码 ?