前言
object relation mapping(ORM)关系对象映射表，一个类实例映射为一条表记录
目录
1.django 默认使用sqlite的数据库，如果需要使用mysql数据库，就需要在settings中修改配置信息
DATABASES = {
‘default‘: {
‘ENGINE‘: ‘django.db.backends.mysql‘,
‘NAME‘ : ‘‘, #你的数据库的名字
‘USER‘ : ‘‘, #你的数据库用户
‘PASSWORD‘ : ‘‘, #你的数据库密码
‘HOST‘ : ‘‘, #你的数据库主机，默认localhost
‘PORT‘ : ‘3306‘, #你的数据库端口
}
}
2.需要手动导入PyMySQL，在_init_.py中导入
import MySQLdb
1. 在models.py中创建类映射表
from django.db import models
# Create your models here.
class Book(models.Model):
name=models.CharField(max_length=20)
price=models.FloatField()
pub_date=models.DateField()
publish = models.ForeignKey("Publish", on_delete=models.CASCADE) #一对多
authors = models.ManyToManyField("Author") #多对多
def __str__(self):
return self.name
class Publish(models.Model):
name=models.CharField(max_length=32)
city=models.CharField(max_length=32)
def __str__(self):
return self.name
class Author(models.Model):
name = models.CharField(max_length=32)
age = models.IntegerField(default=20)
def __str__(self):
return self.name
2.在终端中输入 python manage.py makemigrations ， python manage.py migrate 两条命令
注：如果想要显示表执行的sql语句，就在settings中配置
LOGGING = {
‘version‘: 1,
‘disable_existing_loggers‘: False,
‘handlers‘: {
‘console‘:{
‘level‘:‘DEBUG‘,
‘class‘:‘logging.StreamHandler‘,
},
},
‘loggers‘: {
‘django.db.backends‘: {
‘handlers‘: [‘console‘],
‘propagate‘: True,
‘level‘:‘DEBUG‘,
},
}
}
-----------增
# 单表
#添加方法一
b = Book(name="python基础",price=99,author="chen",pub_date="2017-12-12")
b.save()
#添加方法二
Book.objects.create(name="PHP基础",price=70,author="chen",pub_date="2016-12-12")
-----------删
# 单表
Book.objects.filter(author="liu").delete()
-----------改
# 单表
Book.objects.filter(author="chen").update(price=100)
-----------查
# 单表
book_list = Book.objects.all()
print(book_list[0])
book_list = Book.objects.all()[::-2]
book_list = Book.objects.all()[::2]
book_list = Book.objects.first()
book_list = Book.objects.last()
book_list = Book.objects.get(id=4) #只能取出一条记录的时候不报错
ret = Book.objects.filter(author="chen").values("name","price") #以字典的形式显示
ret = Book.objects.filter(author="chen").values_list("name","price") #以元组的形式显示
book_list = Book.objects.exclude(author="chen").values("name","price") #除了chen以外的人的数据
book_list = Book.objects.all().values("name").distinct() #根据一个字段去重
ret = Book.objects.all().values("name").distinct().count() #根据一个字段去重
Book.objects.filter(authors__id__in=[1,2]) #获取id等于1或2的数据
Book.objects.filter(authors__id__range=[1,2]) #范围
print(ret)
#万能的__
#价格大于50的数/85.41
book_list = Book.objects.filter(price__gt=50).values("name","price")
#模糊查询
book_list = Book.objects.filter(name__icontains="P").values("name","price")
书籍和出版社是一对多的关系
class Book(models.Model):
name=models.CharField(max_length=20)
price=models.FloatField()
pub_date=models.DateField()
publish = models.ForeignKey("Publish", on_delete=models.CASCADE) #一对多
def __str__(self):
return self.name
class Publish(models.Model):
name=models.CharField(max_length=32)
city=models.CharField(max_length=32)
def __str__(self):
return self.name
添加数据的方法
#多表添加
# Book.objects.create(name="linux运维",price=77,pub_date="2017-12-12",publish_id=2)
#Book.objects.create(name="GO",price=23,pub_date="2017-05-12",publish=publish_obj)
多表查询的方法
#含外键:一对多查询
# 查询人民出版社出过的所有书籍名字和价格
# 方式一：
pub_obj=Publish.objects.filter(name="人民出版社")[0]
ret=Book.objects.filter(publish=pub_obj).values("name","price")
#方式二
pub_obj = Publish.objects.filter(name="人民出版社")[0]
print(pub_obj.book_set.all().values("name","price")) #book_set
print(type(pub_obj.book_set.all()))
# 方式三，用__
ret=Book.objects.filter(publish__name="人民出版社").values("name","price")
#python基础书出版社的名字
#法一
ret = Publish.objects.filter(book__name="Python基础").values("name")
# 法二
ret3=Book.objects.filter(name="python基础").values("publish__name")
#北京出版出版的所有的书
ret = Book.objects.filter(publish__city="北京").values("name")
ret = Publish.objects.filter(city="北京")
书籍和作者是多对多的关系
注：使用authors = models.ManyToManyField("Author")，会自动创建book_authors表，也可以自己创建关系表(不会有authors属性)
class Book(models.Model):
name=models.CharField(max_length=20)
price=models.FloatField()
pub_date=models.DateField()
authors = models.ManyToManyField("Author") #多对多
def __str__(self):
return self.name
class Author(models.Model):
name = models.CharField(max_length=32)
age = models.IntegerField(default=20)
def __str__(self):
return self.name
-----------增
#绑定多表关系
# book_obj = Book.objects.get(id=4)
# authors_objs = Author.objects.get(id=2) #authors_objs = Author.objects.all()
# book_obj.authors.add(authors_objs)
-----------查
#多对多的关系，第三张表关系表
#通过对象的方式绑定关系
#书找作者
book_obj=Book.objects.get(id=3)
print(book_obj.authors.all())
#作者找书
author_obj = Author.objects.get(id=2)
print(author_obj.book_set.all())
return HttpResponse("添加成功")
-----------删
# 解除多表关系
book_obj = Book.objects.get(id=4)
authors_objs = Author.objects.all() #是列表
book_obj.authors.remove(*authors_objs)
book_obj.authors.remove(2) #删除的是数量
#手动创建关系表
class Book(models.Model):
name=models.CharField(max_length=20)
price=models.FloatField()
pub_date=models.DateField()
def __str__(self):
return self.name
class Book_Author(models.Model):
book=models.ForeignKey("Book",on_delete=models.CASCADE)
author=models.ForeignKey("Author",on_delete=models.CASCADE)
class Author(models.Model):
name = models.CharField(max_length=32)
age = models.IntegerField(default=20)
def __str__(self):
return self.name
-----------增
#手动创建的关系表
Book_Author.objects.create(book_id=2,author_id=3)
-----------查
#关联查询，查找书的所有作者
obj = Book.objects.get(id=2)
print(obj.book_author_set.all()[0].author)
#chen出过的书和价格
ret = Book.objects.filter(book_author__author__name="chen").values("name","price")
先导入模块
from django.db.models import Min,Avg,Max,Sum from django.db.models import F,Q
#聚合函数（需要先导入函数）
ret = Book.objects.all().aggregate(Avg("price"))
ret = Book.objects.all().aggregate(chen_money = Sum("price")) #取别名
#查各个作者的书的价格总和
value:按照作者名字分组
ret = Book.objects.values("authors__name").annotate(Sum("price"))
print(ret)
#查各个出版社出的书的最小
ret = Publish.objects.values("name").annotate(Min("book__price"))
print(ret)
#-----------------------------------------------------------------------------------------------------------------------------
#F查询和Q查询,（使用前要导入模块）
#F拿到的值
Book.objects.all().update(price=F("price")+10)
#Q可以做or操作 ，~Q表示非
re = Book.objects.filter(Q(price=80) | Q(name="GO"))
#组合查询
re = Book.objects.filter(Q(name__contains="G"))
#Q查询和关键字查询组合，Q要在前面
re = Book.objects.filter(Q(name="GO"),price=80)
#只有在使用ret使用的时候才去查询，惰性取值
re = Book.objects.filter(price=80) #不会取值
for i in re: #使用时才会去查询
print(i)
print(re)
#---------------------------------------------------------------------
#exists()
re = Book.objects.filter(price=80)
re.exists() #会查询，但re不会被赋值，只有使用re变量的时候才会被赋值
#----------------------------------------------------------------------
#iterator() 迭代器对象
ret = Book.objects.filter(price=80)
ret = ret.iterator()
python之路（19）django数据库模型(model)
原文：https://www.cnblogs.com/shuzhixia/p/11062437.html