Django-4.Model模型基础

---

一、数据库配置

1.ORM概念

定义：对象关系映射（Object Relational Mapping,简称ORM）
优势：不用直接编写SQL代码，只需像操作对象一样从数据库操作数据。

2.模型映射关系

• 模型类必须都写在app下的models.py文件中
• 模型如果需要映射到数据库,所在的app必须被安装.
• 一个数据表对应一个模型类,表中的字段,对应模型中的类属性.

3.数据库的配置

• 1.在settings.py中配置DATABASES

  DATABASES = {
      'default': {
          'ENGINE': 'django.db.backends.mysql',  # 数据库引擎
          'NAME': 'mydb',                        #数据库名称
          'USER': 'admin',                       # 链接数据库的用户名
          'PASSWORD':'qwe123',                   # 链接数据库的密码
          'HOST': '127.0.0.1',                   # mysql服务器的域名和ip地址
          'PORT': '3306',                        # mysql的一个端口号,默认是3306
      }
  }
  

• 2._init_.py

  设置连接器为pymysql:
  在主目录下的的__init__.py文件添加下面两句
  import pymysql
  pymysql.install_as_MySQLdb()
  

二、模型的创建与映射

1.使用Django中的模型

在app下面的models.py中创建django的模型类.

代码如下：

from django.db import models

class User(models.Model):  #模型类名  对应表名
    id = models.AutoField(primary_key=True) #id 可以省略 会自动创建
    name = models.CharField(max_length=30)  #字符类型
    age = models.IntegerField()  #整数类型

    def __str__(self):  #使用查询方法时，数据的展示方式
        return "User<id={0}>,name={1},age={2}".format(self.id, self.name, self.age)

2.将模型类映射到数据库

1. 首先执行以下命令,要创建映射文件
   - python manage.py makemigrations app_name
   - 命令后面可以跟app名称,表示指定对某个app的模型进行映射,没写所有的app都执行.
2. 执行以下命令,将映射文件中的映射数据提交到数据库中
   - python manage.py migrate
   - 在执行前,保证我们创建模型的APP是已经注册过的APP

	(django_moran) [lemon@iZbp159egvvktszc82dr5xZ testPro]$ python manage.py makemigrations model_test

Migrations for 'model_test':
  model_test/migrations/0001_initial.py
    - Create model User

打开数据我们能看到创建的以app名_模型名的数据表,而其他的一些表格是django自动生成的.
注意:如果要删除表,那么可以去django模型中注释掉模型类,然后执行映射的命令,不要手动在命令行里面去删除.

3.数据的增删改查

3.1数据的增删改查----------增加数据

在视图函数中导入User模型类,然后使用下面的方法添加数据

def add_user(request):
    #方法一
    moran = User(name='wuyifan', age=43)
    moran.save()#保存上传
    return HttpResponse('数据添加成功')

    #方法二
    wufeng = User()
    wufeng.name = 'Tom'
    wufeng.age = 19
    wufeng.city = 'Shanghai'
    wufeng.save()
    return HttpResponse(f'数据{wufeng.name}添加成功！')

    #方法三
    User.objects.create(name='Siri', age=17, city='Shijiazhuang')
    return HttpResponse('数据添加成功！')


    #方法四
    User.objects.get_or_create(name='Jerry', age=20)
    return HttpResponse('数据添加成功！')

3.2数据的增删改查----------查找数据

在视图函数中导入User模型类,实现简单的查找
<QuerySet [<User: User<id=5>,name=Ctmd,age=50>]>支持索引

def select_user(request):
    #查询所有数据
    rs = User.objects.all()
    for i in rs:
        print(rs)
    #条件查询一个记录对象
    rs = User.objects.get(id=1)  #get 一般查询主键字段
    print(rs)

    #获取满足条件的对象（结果是一个QuerySet,支持索引）
    rs2 = User.objects.filter(age=50)
    print(rs2[0])
    

	#查询第一条数据
    rs3 = User.objects.first()
    print(rs3)

    #排除条件查询
    rs4 = User.objects.exclude(age=43)
    print(rs4)

    #排序查询
    rs5 = User.objects.order_by('age')  #正序
    rs5 = User.objects.order_by('-age')  #倒叙

    #范围查询
    rs6 = User.objects.filter(age__gt=18)  #gt:大于
    rs6 = User.objects.filter(age__lt=18)  #lt:小于
    rs6 = User.objects.filter(age__in=[18,40])  #闭区间范围
    rs6 = User.objects.filter(age__range=(18,40))  #开区间范围

    #转字典形式查询
    rs7 = User.objects.all().values()
    rs7 = User.objects.filter(age=18).values()

	return HttpResponse('数据查询完毕')

3.3数据的增删改查----------修改数据

在视图函数中导入User模型类,然后使用下面的方法更新数据

def update_user(request):
    #方法一：先查询到数据，再进行属性修改
    # res = User.objects.get(id=5)
    # res.name = 'WCTMD'
    # res.age = 29
    # res.city = 'TianChang'
    # res.save()
    # return HttpResponse('数据修改完毕')

    #方法二：直接查询修改
    User.objects.filter(id=5).update(city='DaTianChang')
    return HttpResponse('数据修改完毕')

3.4数据的增删改查----------删除数据

在视图函数中导入User模型类,然后使用下面的方法更新数据

def delete_user(request):
    User.objects.get(id=8).delete()
    User.objects.filter(name='Siri').delete()

    return HttpResponse("数据删除完毕")

数据的增删改查--------数据库相关的接口（QuerySet API)

1.从数据库中查询出来的结果一般是一个集合，这个集合叫做 QuerySet.
2.QuerySet是可迭代对象.
3.QuerySet支持切片, 不支持负索引.
4.可以用list强行将QuerySet变成列表.

三、常用的查询及字段类型

1.常用的查询

2.常用的字段类型及映射关系

1. IntegerField : 整型，映射到数据库中的int类型。
2. CharField: 字符类型，映射到数据库中的varchar类型，通过max_length指定最大长度。
3. TextField: 文本类型，映射到数据库中的text类型。
4. BooleanField: 布尔类型，映射到数据库中的tinyint类型，在使用的时候，传递True/False进去。如果要可以为空，则用NullBooleanField。
5. DateField: 日期类型，没有时间。映射到数据库中是date类型，
   在使用的时候，可以设置DateField.auto_now每次保存对象时，自动设置该字段为当前时间。设置DateField.auto_now_add当对象第一次被创建时自动设置当前时间。
6. DateTimeField: 日期时间类型。映射到数据库中的是datetime类型，
   在使用的时候，传递datetime.datetime()进去。
   

3.Field常用参数

1. primary_key: 指定是否为主键。
2. unique: 指定是否唯一。
3. null: 指定是否为空，默认为False。
4. blank: 等于True时form表单验证时可以为空，默认为False。
5. default: 设置默认值。
6. DateField.auto_now: 每次修改都会将当前时间更新进去，只有调用，QuerySet.update方法将不会调用。这个参数只是Date和DateTime以及TimModel.save()方法才会调用e类才有的。
7. DateField.auto_now_add: 第一次添加进去，都会将当前时间设置进去。以后修改，不会修改这个值

四、表关联对象及多表查询

1.表关系的实现

models.py示例

from django.db import models

#学院信息
class Department(models.Model):
    d_id = models.AutoField(primary_key=True)
    d_name = models.CharField(max_length=30)


    def __str__(self):
        return f'd_id={self.d_id}, d_name={self.d_name}'

#学生信息表
class Student(models.Model):
    s_id = models.AutoField(primary_key=True)
    s_name = models.CharField(max_length=30)
    dept = models.ForeignKey('Department', on_delete=models.CASCADE)#级联删除

    def __str__(self):
        return f'd_id={self.s_id}, d_name={self.s_name}, dept={self.dept}'

#学生详情表
class Stu_detail(models.Model):
    stu_id = models.OneToOneField('Student', on_delete=models.CASCADE)  #一对一关系：删除学生表中的字段，详情表中的字段也会被删除
    age = models.IntegerField()
    gender = models.BooleanField(default=True)
    note = models.TextField()

    def __str__(self):
        return f'stu_id={self.stu_id}, s_name={self.s_name}, dept={self.gender}, note={self.note}'

#课程信息表
class Course(models.Model):
    c_id = models.AutoField(primary_key=True)
    c_name = models.CharField(max_length=50)
    stu_course = models.ManyToManyField('Student')  #多对多关系

    def __str__(self):
        return f'c_id={self.c_id}, c_name={self.c_name}, stu_course={self.stu_course}'

2.表关联数据添加

from django.shortcuts import render
from django.http import HttpResponse
from .models import Student,Course,Department,Stu_detail

def add_user(request):
    Department.objects.create(d_name='Music College')
    Department.objects.create(d_name='Artist College')
    Department.objects.create(d_name='Machine College')
    Department.objects.create(d_name='Fuck College')
    Department.objects.get_or_create(d_name='Fuck College')  ##插入不重复的数据
    Department.objects.filter(d_id__gt=4).delete()   
    return HttpResponse('数据添加成功！')

1).一对多关系的外键-数据创建(学院，学生)

**views.py**

    Student.objects.get_or_create(s_name='Jack', dept_id=1)
    Student.objects.get_or_create(s_name='Tom', dept_id=2)
    Student.objects.get_or_create(s_name='Bruce', dept_id=3)
    Student.objects.get_or_create(s_name='Jimy', dept_id=4)
====**或者通过主键表新建数据**========**========**======================
    d1 = Department.objects.get(d_id=1)
    d1.student_set.create(s_name='XiaoMing')
    d1.student_set.create(s_name='XiaoHong')

2).一对一关系的外键-数据创建（学生，学生详情）

**views.py**

    Stu_detail.objects.get_or_create(age=20, gender=1, note='fuck you all the time', stu_id_id=1)
    Stu_detail.objects.get_or_create(age=18, gender=1, note='gi gi gi gi,baby baby baby', stu_id_id=2)

3).多对多关系的外键-数据创建（课程，学生）

**views.py**

    #多对多中间表的数据创建：先获取课程，再将课程添加到学生中
    c1 = Course.objects.get(c_id=1)
    c2 = Course.objects.get(c_id=2)
    s1 = Student.objects.get(s_id=1)
    s1.course_set.add(c1, c2)
====**或者通过学生对象直接创建并关联该课程**======**======**=======================
    s1 = Student.objects.get(s_id=1)
    s1.course_set.create(c_name="Django") 

add可以做添加，也有直接修改的作用

3.表关系对象的访问

先实例化一个字段对象，再通过访问其外键名找到关联数据

def query(request):
    #一对多表属性访问
    d3 = Department.objects.get(d_id=3)  #学院的实例对象
    s1 = Student.objects.get(s_id=1)  #学生实例对象
    rs = s1.dept.d_name  #通过学生找到所属的学院
    rs = d3.student_set.all()  #学院中所有的学生


    #一对一表属性访问
    stu = Stu_detail.objects.get(id=1)  #学生详情对象
    rs = stu.stu_id.s_name


    #多对多属性访问
    s1 = Student.objects.get(s_id=1)
    rs = s1.course_set.all()
    
    c1 = Course.objects.get(c_id=1)  #课程实例对象
    rs = c1.stu_course.all()

    return HttpResponse(rs)

4.移除数据

多对多关联对象关系删除

def remove(request):

    s1 = Student.objects.get(s_id=1)
    c2 = Course.objects.get(c_id=1)
    #s1.course_set.remove(c2)
    s1.course_set.clear()
    return HttpResponse('课程移除完成')

5.多表查询

Django 提供一种强大而又直观的方式来“处理”查询中的关联关系，它在后台自动帮你处理JOIN。 若要跨越关联关系，只需使用关联的模型字段的名称，并使用双下划线分隔，直至你想要的字段：
# 查询学院名字为‘计算机学院’的学生的信息 Student.objects.filter(department__d_name='计算机学院')
它还可以反向工作。若要引用一个“反向”的关系，只需要使用该模型的小写的名称。
#查询学生名字中包含 '小' 的学生的学院信息 Department.objects.filter(student__s_name__contains='小')
# 查询学号为1的学生所有的课程 Course.objects.filter(student__s_id=1)
# 查询报了课程1的所有的学生
Student.objects.filter(course__c_id=1)
# 查询报了'python'课程的的学生的所属学院的信息
Department.objects.filter(student__course__c_name='python')