一、Django数据库理解

Django数据库和flask数据库一样，都是使用orm(Object Relational Mapping)对象关系映射方法，使用面向对象的方式来操作数据库。将类转换为表格，属性转换为字段，对象转换为记录。

ORM.png

二、创建数据库

为了方便后续操作演示，在这里创建基础的数据库。

class Seller(models.Model):
    id = models.AutoField(primary_key=True)  # 主键 自增
    username = models.CharField(max_length=32, default='zs')
    password = models.CharField(max_length=32, default=123)
    age = models.IntegerField(default=18)
    gender = models.BooleanField(default=True)  # true表示男 存储在数据库是1，女存储在数据库是0
    phone = models.CharField(max_length=32, default='11111111111')
    email = models.CharField(max_length=32, default='lalala@qq.com')
    heading = models.CharField(max_length=64, default='1.jpg')  # 头像路径
    # heading = models.ImageField()  # 功能强大，但是麻烦
    address = models.CharField(max_length=128, default='魔都')


class Store(models.Model):
    name = models.CharField(max_length=32, default='我的小店')
    address = models.CharField(max_length=128, default='beijing')
    desc = models.CharField(max_length=128, default='欢迎光临我的甜蜜小屋......')
    logo = models.CharField(max_length=128, default='1.jpg')
    # 一对一建立关系
    # to表示和哪个模型类进行关联
    # on_delete:删除策略
    seller = models.OneToOneField(to=Seller, on_delete=models.CASCADE)


# 商品和商品类型是一对多关系：水果类型-苹果、橘子……
class GoodsType(models.Model):
    name = models.CharField(max_length=32, default='新鲜水果')
    logo = models.CharField(max_length=128, default='1.jpg')
    # 一对多映射：Django不需要映射，反向查询使用对应的模型类的小写

    # 多对多,连接到店铺：商品类型和店铺多对多
    store = models.ManyToManyField(to=Store)


class Goods(models.Model):
    name = models.CharField(max_length=64, default='苹果')
    # 实际开发可以使用字符串，查询出来再转换类型
    # max_digits:数字总共位数
    # decimal_places：小数位数
    price = models.DecimalField(max_digits=5, decimal_places=2)
    bzq = models.IntegerField(default=30)   # 保质期
    # 一个是Python为空，一个是数据库为空
    scrq = models.DateField(null=True, blank=True)   # 生产日期
    num = models.IntegerField(default=100)  # 产品数量
    desc = models.CharField(max_length=128)
    picture = models.CharField(max_length=128, default='1.jpg')

    # 一对多，外键：删除商品类型时级联删除商品
    goodstype = models.ForeignKey(to=GoodsType, on_delete=models.CASCADE)

    # 店铺和商品是一对多关系
    store = models.ForeignKey(to=Store, on_delete=models.CASCADE, null=True, blank=True)

三、Django数据库操作

（一）增

1.save()：Django框架默认封装了数据库的保存save()、更新update()和删除delete()方法。

from app01 import models

def register(request):
    # 1.获取表单提交的内容
    if request.method == 'POST':
        name = request.POST.get('name')
        password = request.POST.get('password')
        age = request.POST.get('age')
        gender = request.POST.get('gender')
        phone = request.POST.get('phone')
        email = request.POST.get('email')
        address = request.POST.get('address')

        # 2.保存到数据库
        seller_obj = models.Seller()
        seller_obj.username = name
        seller_obj.password = password
        seller_obj.age = age
        seller_obj.gender = gender
        seller_obj.phone = phone
        seller_obj.email = email
        seller_obj.address = address
        seller_obj.save()
        # 3.返回一句话
        return HttpResponse('ok......')
    return render(request, 'register.html')

save()的使用方法和flask相同
2.seller_obj = models.Seller.objects.create(username=name, password=password)
注意：该方法有返回值，可以使用变量接收，也可以不接收，如果没有其他用的话。

（二）删

seller_obj = models.Seller.objects.get(id=1).delete()
注意：falsk的get方法，获取的参数只用写id值，但是这里需要使用键值对的方式传参
flask:
seller_obj = Seller.query.get(1)
seller_obj.delete()

（三）改

修改的方法和flask有些差别，应该格外注意

1. 获取要修改的对象，修改后用save()方法

seller_obj = models.Seller.objects.get(id=2)
    seller_obj.username = 'zs'
    seller_obj.age = 16
    seller_obj.gender = False
    seller_obj.save()

2. models.Seller.objects.filter(id=2).update(username='张三')
   filter查询得到的是QuerySet类型，也是一个可迭代对象，他有update()方法，但是get得到的对象没有update()方法
   flask的到的是对象列表，update()方法只适用于单独的对象

（四）查

# 查询
def find(request):
    # 1.get()方法,返回值是当前对象类型。可以直接使用对象属性。
    # 如果返回多个或者每一个都没有都会报错，只能返回唯一的对象。
    seller_obj = models.Seller.objects.get(id=3)
    print(seller_obj.gender)  # Seller object (3)
    ret = models.Seller.objects.get(age=40)
    print(ret)
    # 2.first() 和last() 方法,返回查询后的第一个对象和最后一个对象，注意类型都是当前对象类型。
    ret = models.Seller.objects.first()
    print(ret)  # Seller object (2)
    ret = models.Seller.objects.last()
    print(ret)
    # 3.filter(): 过滤,返回一个QuerySet对象，用法类型于 列表。
    ret = models.Seller.objects.filter(age=10)
    print(ret)
    print(ret[2].username)
    for seller_obj in ret:
        print(seller_obj.username)
    # 如果查询出一个对象，返回的也是QuerySet类型。
    ret = models.Seller.objects.filter(age=40)
    print(ret)
    print(ret[0].username)

    # 4. all() 查询所有对象,返回值类型：QuerySet类型。
    ret = models.Seller.objects.all()
    print(ret)

    # 5.order_by() 排序, 默认是升序排序， 降序 使用 '-字段名称'
    ret = models.Seller.objects.all().order_by('-id')
    print(ret)

    # 6.双下划线方法
    ret = models.Seller.objects.filter(username__startswith='li')
    print(ret)
    ret = models.Seller.objects.filter(age__gt=10)
    print(ret)

    # 7.聚合查询
    from django.db.models import Count, Max, Min, Sum, Avg, F, Q
    ret = models.Seller.objects.all().aggregate(Avg('age'))
    print(ret)  # {'age__avg': 16.0}

    # 8.分组  根据性别分组，求人数
    ret = models.Seller.objects.all().values('gender').annotate(Count('gender'))
    print(ret)

    # 9. F 和 Q 查询
    # F查询， 同一个模型类中的属性进行比较。
    models.Goods.objects.create(name='奶瓶', kc=1000, xl=2000)
    models.Goods.objects.create(name='奶茶', kc=1000, xl=500)
    models.Goods.objects.create(name='奶粉', kc=1000, xl=600)
    # 库存大于销量的商品
    ret = models.Goods.objects.filter(kc__gt=F('xl'))
    # print(ret)
    # Q查询
    # 查询 年龄=40 或者 name 以 z 开头的用户。
    ret = models.Seller.objects.filter(Q(age=40) | Q(username__startswith='z'))
    print(ret)

    return HttpResponse('find...')

（五）小总结

1.flask和Django的保存save()、更新update()和删除delete()方法的区别

• flask的三个方法只适用于单个的对象
• Django的save()方法适用于的单个对象，update()方法用于QuerySet类型数据，delete()方法既可以用于单个对象，也可以用于QuerySet类型数据。

三、关系操作

（一）一对一

1.建立联系：卖家和店铺为例
一对一关系的建立是可以在任意一个一表中建立外键关系，且设定外键唯一。
在Django数据库中一对一关系的建立只需要通过OneToOneField建立关系。

# to=：指定关联的表
# on_delete: 删除策略
# models.CASCADE: 级联删除，删除一个表时将另一个表删除
# models.DO_NOTHING: 不做任何事情
seller = models.OneToOneField(to=Seller, on_delete=models.CASCADE)

2. 添加数据
   添加关系的表增加数据时，关系属性保存的应该是对象，而不是单纯的数值。
   

   添加数据.png

3. 删除数据

   
   删除数据.png

4. 查询

def onetoonefind(request):
    # 查询王五的店对应的卖家，外键在store
    store_obj = models.Store.objects.filter(name='这是王五的店').first()
    ret = store_obj.seller   # Seller object (5)
    ret_id = store_obj.seller_id   # 5
    print(ret.username)

    # 查询zhoubapi的店铺信息，反向查询使用要查的模型类的小写
    seller_obj = models.Seller.objects.filter(username='zhoubapi').first()
    print(seller_obj)
    print(seller_obj.store.name)
    return HttpResponse('一对一查询')

查询方向.png
重点信息标注.png

（二）一对多

1. 建立联系：商品类型和商品
   Django：在多表使用ForeignKey()建立联系，一表不做任何处理
   flask：在多表建立外键，在一表建立映射
   goodstype = models.ForeignKey(to=GoodsType, on_delete=models.CASCADE)

2.添加数据

添加数据.png

3.查询
正向查询：使用属性直接查询
反向查询：使用对应表的小写_set.all()

def onetomanyfind(request):
    # 查询苹果对应的商品类型
    goods_obj = models.Goods.objects.filter(name='苹果').first()
    print(goods_obj.goodstype.name)

    # 查询水果类对应的所有商品
    gt_obj = models.GoodsType.objects.filter(name='水果类').first()
    goods_obj = gt_obj.goods_set.all()
    print(goods_obj)

    # 删除苹果，商品删除，类型还在
    models.Goods.objects.filter(name='苹果').delete()
    # 删除类型：
    models.GoodsType.objects.filter(name='水果类').delete()

    return HttpResponse('一对多查询。。。。')

（三）多对多

1. 建立联系：店铺和商品类型
   多对多表关系的建立通过中间表，
   Django通过ManyToManyField()建立联系，不同专门新建中间表，而是Django框架创建了中间表
   flask是在数据库中新建中间表，在其中一张表建立外键
   2.添加数据

def mantomany(request):
    # 创建2个店铺
    store_obj1 = models.Store.objects.create(name='奇异果小店', seller_id=3)
    store_obj2 = models.Store.objects.create(name='圣女果小店', seller_id=2)
    # 创建两个商品类型
    gt_obj1 = models.GoodsType()
    gt_obj1.name = '水果类型'
    gt_obj1.save()
    gt_obj2 = models.GoodsType()
    gt_obj2.name = '海鲜类型'
    gt_obj2.save()

    # 关联: 水果类型关联奇异果小店，圣女果小店
    #       海鲜类型关联奇异果小店，圣女果小店
    gt_obj1.store.add(store_obj1, store_obj2)
    gt_obj2.store.add(store_obj1, store_obj2)

    return HttpResponse("多对多……")

3.查询

def manytomanyfind(request):
    # 查询水果类型对应的所有店铺
    gt_obj = models.GoodsType.objects.filter(name='水果类型').first()
    print(gt_obj.store.all())

    # 查询奇异果小店对应的所有商品类型
    store_obj = models.Store.objects.filter(name='奇异果小店').first()
    print(store_obj.goodstype_set.all())

    return HttpResponse('多对多查询')