Django小笔记-定义模型

定义模型

    django对各种数据库提供了很好的支持，django为这些数据库提供了统一的调用API，可以根据不同的业务需求选择不同的数据库

    配置数据库
        在project/__init__.py中添加 import pymysql
                                    pymysql.install_as_MySQLdb()

        修改settings.py文件
                DATABASES = {
                    'default': {
                        'ENGINE': 'django.db.backends.mysql',
                        'NAME': "kaishen",
                        'USER':'root',
                        'PASSWORD':'123456',
                        'HOST':'127.0.0.1',
                        'PORT':'3306',
                    }
                }

        ORM（对象-关系-映射）
            任务
                1、根据对象的类型生成表结构
                2、将对象、列表的操作转换为sql语句
                3、将sql语句查询到的结果转换为对象、列表

    模型、属性、字段、表之间的关系
        一个模型类在数据库中对应一张表，在模型类中定义的属性，对应该模型对照表中的一个字段

    定义模型时的属性
        命名时，遵守标识符规则

        字段类型
            使用时需要引入django.db.models包，字段类型如下：
            AutoField：自动增长的IntegerField，通常不用指定，不指定时Django会自动创建属性名为id的自动增长属性。

            BooleanField：布尔字段，值为True或False。

            NullBooleanField：支持Null、True、False三种值。

            CharField(max_length=字符长度)：字符串，参数max_length表示最大字符个数。

            TextField：大文本字段，一般超过4000个字符时使用。

            IntegerField：整数

            DecimalField(max_digits=None, decimal_places=None)：十进制浮点数
            参数max_digits表示总位数
            参数decimal_places表示小数位数

            FloatField：浮点数 

            DateField[auto_now=False, auto_now_add=False])：日期
            参数auto_now表示每次保存对象时，自动设置该字段为当前时间，用于”最后一次修改”的时间戳，它总是使用当前日期，默认为false
            参数auto_now_add表示当对象第一次被创建时自动设置当前时间，用于创建的时间戳，它总是使用当前日期，默认为false
            参数auto_now_add和auto_now是相互排斥的，组合将会发生错误 

            TimeField：时间，参数同DateField

            DateTimeField：日期+时间，参数同DateField

            FileField：上传文件字段

            ImageField：继承于FileField，对上传的内容进行校验，确保是有效的图片

        字段选项
            通过选项实现对字段的约束，选项如下：
            null：如果为True，表示允许为空，默认值是False

            blank：如果为True，则该字段允许为空白，默认值是False 
            对比：null是数据库范畴的概念，blank是表单验证证范畴的

            db_column：字段的名称，如果未指定，则使用属性的名称

            db_index：若值为True, 则在表中会为此字段创建索引，默认值是False

            default：默认值

            primary_key：若为True，则该字段会成为模型的主键字段，默认值是False，一般作为AutoField的选项使用

            unique：如果为True, 这个字段在表中必须有唯一值，默认值是False

        关系字段类型
            关系型数据库的关系包括三种类型： 
            ForeignKey：一对多，将字段定义在多的一端中

            ManyToManyField：多对多，将字段定义在两端中

            OneToOneField：一对一，将字段定义在任意一端中
    

    创建模型类

    元选项
        在模型类中定义Meta类，用于设置元信息

        db_table：定义数据表名（推荐使用小写字母），数据表名默认为项目名小写_类名小写
        ordering：对象的默认排序字段，获取对象的列表时使用
            eg：ordering['id']  升序
                ordering['-id']  降序

    模型成员
        类属性
            objects：是Manager类型的一个对象，作用是与数据库进行交互。当定义模型类时，没有指定管理器，则django为模型创建一个名为objects的管理器

            自定义管理器：class Students(models.Model):
                            stuObj = models.Manager()  #当自定义管理器后，objects（默认的管理器）就不存在了，即当为模型指定模型管理器后，django就不再为模型类生成objects模型管理器

            自定义管理器Manager类:
                模型管理器是django的模型进行与数据交互的接口，一个模型可以有多个模型管理器

                作用：向管理器中添加额外的方法；修改管理器返回的原始查询集（一般重写get_queryset（））

                实例：class StudentsManager(models.Manager):
                        def get_queryset(self):
                            return super(StudentsManager, self).get_queryset().filter(isDelete=False)

                     class Students(models.Model):
                        stuObj = models.Manager()   #自定义模型管理器,当自定义管理器后，objects（默认的管理器）就不存在了，即当为模型指定模型管理器后，django就不再为模型类生成objects模型管理器
                        stuObj2 = StudentsManager()

        创建对象
            目的：向数据库中添加数据

            当创建对象时，django不会对数据库进行读写，当调用save（）方式时才与数据库交互，讲对象保存到数据库表中

            注意：__init__方法已经在父类models.Model中使用，在自定义的模型中无法使用

            方法：
                1、在模型类中增加一个类方法
                    class Students(models.Model):
                        # 定义一个类方法创建对象
                        @classmethod
                        def createSutdent(cls, name, age, gender, contend, grade, lastT, createT, isD=False):
                            stu = cls(sname=name, sage=age, sgender=gender, scontend=contend, sgrade=grade, lastTime=lastT,
                                      createtime=createT, isDelete=isD)
                            return stu

                    def addstudent(request):
                        grade = Grades.objects.get(pk=1)
                        stu = Students.createStudent("刘德华",34,True,"我叫刘德华",grade,"2018-8-27","2018-8-27")
                        stu.save()
                        return HttpResponse("smi")

                    urlpatterns = [
                        # url(r"^$",views.index),     #引入views下的index.py文件   ^$:正则表达式，匹配字符串
                        url(r'^students/$',views.students),
                        url(r'^addstudent/$',views.addstudent)
                    ]

                2、在自定义管理器中添加一个方法
                    class StudentsManager(models.Manager):
                        def get_queryset(self):
                            return super(StudentsManager, self).get_queryset().filter(isDelete=False)       #filter过滤

                        def createStudent(self,name, age, gender, contend, grade, lastT, createT, isD=False):
                            stu = self.model()
                            stu.sname = name
                            stu.sage = age
                            stu.sgender = gender
                            stu.scontend = contend
                            stu.sgrade = grade
                            stu.lastTIme = lastT
                            stu.createTime = createT
                            return stu

        模型查询
            概述：  1、查询集表示从数据库获取的对象集合
                    2、查询集可以有多个过滤器
                    3、过滤器就是一个函数，基于所给的参数限制查询集结果
                    4、从sql角度来说，查询集合select语句等价，过滤器就像where条件

            查询集：1、在管理器上调用过滤器方法返回查询集
                    2、查询集经过过滤器筛选后返回新的查询集，所以可以写成链式调用（多个过滤器）
                    3、惰性执行（创建查询集不会带来任何数据库的访问，直到调用数据时，才会访问数据）
                    4、直接访问数据的情况（迭代、序列化、与if合用）
                    5、返回查询集的方法称为过滤器
                        all（）返回查询集中所有数据
                        filter（）返回符合条件的数据
                            filter（键=值）
                            filter（键=值，键=值）
                            filter（键=值）.filter（键=值）
                        exclude（）过滤掉符合条件的数据
                        order_by()排序
                        values（）一条数据就是一个对象（字典），返回一个列表
                    6、返回单个数据
                        get（）返回当前查询集中的对象个数
                            注意：若没有找到符合条件的对象，会引发“模型类.DoesNotExist”异常
                                  若找到多个对象，会引发“模型类.MultipleObjectsReturned”异常
                        count（）返回当前查询集中的对象个数
                        first（）返回查询集中的第一个对象
                        last（）返回查询集中最后一个对象
                        exist（）判断查询集中是否有数据，如有返回True，没有返回False
                    7、限制查询集（查询返回列表，可以使用下标的方法进行限制，等同于sql中的limit语句）
                        注意：下标不能是负数
                        实例：#显示前五条学生信息
                                def students3(request):
                                    studentsList = Students.stuObj2.all()[0:5]
                                    return render(request,'myApp/students.html',{"students":studentsList})

                    8、查询集的缓存
                        概述：每个查询集都包含一个缓存，来最小化的对数据库访问;
                              在新建的查询集中，缓存首次为空，第一次对查询集求值，会发生数据缓存，django会将查询出来的数据做一个缓存，并返回查询结果，以后的查询直接使用查询集的缓存

                    9、字段查询
                        概述：实现了sql中where语句，作为方法filter（）、exclude（）、get（）的参数
                        语法：属性名称__(双下划线)比较运算符=值
                        外键：属性名_id
                        转义：sql中like语句中使用%是为了匹配占位，若要匹配数据中的%，需要转义（where like '\%'）
                              filter(sname__contains='%')

                        比较运算符：
                            exact，判断（大小写敏感，即区分大小写）
                                filter（isDelete=False）

                            contains，是否包含（大小写敏感）
                            实例：#查询名字里包含“孙”的学生信息
                                    def studentsearch(request):
                                        studentsList = Students.stuObj2.filter(sname__contains="孙")
                                        return render(request,'myApp/students.html',{"students":studentsList})

                            startswith，endswith，以value开头或者结尾（大小写敏感）
                            实例：#查询名字里以“孙”开头的学生信息
                                    def studentsearch2(request):
                                        studentsList = Students.stuObj2.filter(sname__startswith="孙")
                                        return render(request,'myApp/students.html',{"students":studentsList})

                            （以上四个在前面加上i，则表示不区分大小写（iexact，icontains，istartswith，iendswith））

                            isnull，isnotnull，是否为空
                                filter（sname__isnull=False）

                            in，是否包含在范围内
                            实例：#查询id值为2468的学生信息
                                def studentsearch3(request):
                                    studentsList = Students.stuObj2.filter(pk__in=[2,4,6,8])
                                    return render(request,'myApp/students.html',{"students":studentsList})

                             gt(>)、gte(>=)、lt(<)、lte(<=)
                             实例：#查询年龄大于等于30的学生信息
                                def studentsearch4(request):
                                    studentsList = Students.stuObj2.filter(sage__gte=30)
                                    return render(request,'myApp/students.html',{"students":studentsList})

                            year、month、day、week_day、hour、minute、second，日期
                            实例：#查询日期为2018年入学的学生信息
                                def studentsearch5(request):
                                    studentsList = Students.stuObj2.filter(lastTime__year=2018)
                                    return render(request,'myApp/students.html',{"students":studentsList})

                            跨关联查询
                                实例：def studentsearch6(request):
                                        studentsList = Grades.objects.filter(students__sontend__contains="薛燕美")
                                        print(studentsList)
                                        return render(request,'myApp/students.html',{"students":studentsList})

                            查询快捷 pk，代表的主键

                        聚合函数
                            使用agggregate（）函数返回聚合函数的值
                            Avg(均值)、Count(对查询中符合条件的结果的个数)、Max(最大值)、Min(最小值)、Sum(和)
                            实例：from django.db.models  import Max,Min
                                def studentsearch6(request):
                                    maxAge = Students.stuObj2.aggregate(Max('sage'))
                                    print(maxAge)
                                    return HttpResponse("*****")

                        F对象
                            可以使用模型的A属性与B属性进行比较
                            实例：from django.db.models import F
                                def grades1(request):
                                    g = Grades.objects.filter(ggirlnum__gt=F('gboynum'))
                                    print(g)
                                    return HttpResponse("$$$$$$$$$")

                            支持F对象的算术运算
                            实例：from django.db.models import F
                                def grades1(request):
                                    g = Grades.objects.filter(ggirlnum__gt=F('gboynum')+20)
                                    print(g)
                                    return HttpResponse("$$$$$$$$$")

                        Q对象
                            概述：过滤器的方法中的关键字参数，条件为And模式
                            需求：进行or查询
                            解决：使用Q对象
                            实例：from django.db.models import Q
                                def studentsearch7(request):
                                    studentsList = Students.stuObj2.filter(Q(pk__lte=3) | Q(sage__gt=50))
                                    return render(request, 'myApp/students.html', {"students": studentsList})

                            只有一个Q时，就是用于匹配
                            studentsList = Students.stuObj2.filter(~Q(pk__lte=3))    #取反