Django框架笔记

第一章  Django的介绍

1.Django框架开发的项目属于B/S架构，通过浏览器访问项目
2.Django框架是采用MTV模式创建项目:
    2.1 M：mode 模型层  用于操作sql语句从数据库中获得或者修改数据
    2.2 T：template 模板   用于编写前端html网页
    2.3 V：view  视图       用于调度模型层获取数据和调度模板展示页面      views.py等价于 jsp课程中的servlet
3.Django框架安装需要注意对应的版本:
    3.1   django的版本为1.0左右的版本对应安装Python的版本2.0左右的版本
    3.2   django的版本为2.0左右的版本对应安装Python的版本3.0左右的版本

第二章  Django的配置和安装

1. Django的安装步骤请看《django的安装步骤文档》
2. 创建Django的项目:
    2.1  通过cmd打开dos窗口，在指定的文件夹路径下创建项目，指令为django-admin startproject  项目名称 (例如:Day317)
    2.2  检查当前项目中manage.py可以执行的命令是哪些，manage.py是整个项目的管理者，启动项目的入口，指令 python manage.py
    2.3  将项目运行在服务器上，指令为python manage.py runserver,只要没有报错，并显示了服务器的地址，打开浏览器访问服务器，浏览器上显示类似于火箭的标志，表示项目创建成功
3.使用pycharm开发软件开发项目，编写代码:
    3.1 打开pycharm开发软件，左上角点击file-->open-->找到刚刚创建的项目
    3.2 Python Console：就是Python的命令行窗口
    3.3 Terminal: 就是dos窗口
4.介绍创建的django项目中生成的五个文件:
    4.1 _init_.py:一个空文件，告诉 Python 该目录是一个 Python 包。
    4.2 settings.py:?该 Django 项目的设置/配置。（核心文件）
    4.3 urls.py:?该 Django 项目的 URL 声明; 一份由 Django 驱动的网站“目录”。用于配置网络访问地址
    4.4 wsgi.py:?一个 WSGI 兼容的 Web 服务器的入口，以便运行你的项目。
    4.5 manage.py:?一个实用的命令行工具，可让你以各种方式与该 Django 项目进行交互。
5.Setting.py文件的介绍:
    5.1 BASE_DIR：项目运行环境路径
    5.2 SECRET_KEY：启动Django服务器需要用的秘钥
    5.3 ALLOWED_HOSTS：用于设置访问的ip地址或者是主机名
    5.4 INSTALLED_APPS： Django自带的一些应用，如果后期创建了自己的应用，也需要添加进来
    5.5 MIDDLEWARE：中间件，Django自带的一些工具包
    5.6 ROOT_URLCONF：根目录，指向于urls.py文件
    5.7 TEMPLATES：模板，Django中模板指的就是html文件
    5.8 WSGI_APPLICATION：设置Django访问的网关
    5.9 DATABASES：使用的数据库的配置，默认为sqlite3，如果需要配置其他数据库，通过以上网址查找其他数据库对应的配置信息
    5.10 AUTH_PASSWORD_VALIDATORS ：设置密码认证
    5.11 # 设置语言以及编码格式 LANGUAGE_CODE = 'en-us'
    5.12 TIME_ZONE = 'UTC'
    5.13 STATIC_URL：访问静态文件的地址
6.创建Django子项目:
    1.打开pycharm软件的Terminal,输入创建子项目的指令 python manage.py startapp 子项目名称(例如: TaoBao)
    2.介绍子项目中生成的各个文件:
        2.1 Migrations：数据移植(迁移)模块，内容自动生成
        2.2 admin.py：该应用的后台管理系统配置
        2.3 apps.py：该应用的配置文件，Django版本1.9以后自动生成
        2.4 models.py：数据模块,使用ORM框架，类似于MVC模式中的models(模型)
        2.5 tests.py：自动化测试模块,Django提供了自动测试功能
        2.6 views.py：执行响应的代码所在的模块，代码逻辑处理的主要地点，项目中的大部分代码都在这里编写
    3.将创建的子项目名称添加至主项目的Setting.py文件 INSTALLED_APPS参数里面
    4.在子项目中views.py文件中写入以下代码:
        from django.http import HttpResponse
        from django.shortcuts import render
        # 导入所使用的类的包，快捷键是alt+enter
        # Create your views here.
        def index(request):
                  return HttpResponse("你好,django")
    5.在主项目的urls.py文件中设置浏览器访问的地址，代码如下:
        from TaoBao import views
        urlpatterns = [
                path('admin/', admin.site.urls),
                path('TaoBao/',views.index)
            ]
    6.重新运行该项目
    7.打开浏览器访问子项目的路径，显示“你好，Django”

第三章 URL分发机制

    1.使用urls.py文件匹配一级目录
    2.使用正则表达式匹配浏览器的访问地址re_path()
    3.匹配多级目录的访问地址
    4.匹配带参数的浏览器地址，需要注意urls文件的获得参数的变量名要和views文件中对应的方法的变量名一致
    5.使用路径转换器获得参数的数据类型：
        5.1 str：匹配除了路径分隔符（/）之外的非空字符串。在未指定转换器时，默认使用str。获取的数据为字符串。
        5.2 int：匹配0及正整数。获取的数据为int类型。
        5.3 slug：匹配字母、数字以及横杠、下划线组成的字符串。获取的数据为字符串。
        5.4 uuid：匹配格式化的UUID，如 075194d3-6885-417e-a8a8-6c931e272f00。获取的数据为UUID实例。
        5.5 path：匹配任何非空字符串，包含了路径分隔符（/）。获取的数据为字符串
    6.使用正则表达式匹配地址上携带的参数信息
    7.在urls文件匹配浏览器地址的参数数据的同时，也可以将额外的数据传递给views文件
    8.使用浏览器匹配携带数据的地址和不携带数据的地址时，启用默认值
    9.反向解析获得不带参数的浏览器访问地址
    10.反向解析获得带参数的浏览器的访问地址，并改变地址访问其他地址
    11.使用render方法跳转至html文件，并通过字典形式将数据发送至html页面上

《以上笔记相关代码，请查看上课代码（Day317）项目》

第四章  模型与数据库

    1.模型的概念
        模型是项目的数据来源。
        每个模型都是一个Python类，并且映射到一个数据库表。
        模型的每个属性相当于数据库表的一个字段。
        使用模型对象可完成各种数据库表操作。
    2.定义模型，创建对应于数据库表的Python类
        from django.db import models

        # Create your models here.
        #定义的Python类对应的是数据库中的数据库表
        #类中的全局变量对应于数据库表中的字段名
        #把这个过程称为对象关系型映射，简称ORM
        #可以不用添加主键，django会自动扫描，如果没有发现定义主键，会自动创建
        class  Student(models.Model):
                name=models.CharField(max_length=20)
                age=models.IntegerField()
                sex=models.CharField(max_length=2)
                phone=models.CharField(max_length=11)
                address=models.TextField()
    3.生成迁移文件，指令如下: 
        完成模型的定义和配置后，在使用数据库之前，还需执行数据库迁移操作。
        将定义的Python类开始制作生成数据库表的迁移文件，指令为: python manage.py makemigrations
    4.根据迁移文件生成数据库表，执行的指令为: python manage.py migrate
    5.即可查看生成的数据库的表文件Sqlite3数据库
    6.数据操作:  

        使用tests.py文件进行测试，需要加上以下代码允许测试

import os
# 测试文件经过settings.py的允许
os.environ.setdefault("DJANGO_SETTINGS_MODULE","Day1102.settings")
import django
django.setup()

        6.1 添加数据
            #第一种添加数据的方式:
            #导入模型类
            from BaiDu.models import Student  
            #创建模型类对象，并赋值
            stu=Student(name="张三",age=20,sex="男",phone="18188888888",address="江西省南昌市")
            #调用保存方法，django开始将数据添加至数据库，执行sql语句
            stu.save()

            #第二种添加数据的方式
            from BaiDu.models import Student
            stu1=Student.objects.create(name="张三疯",age=100,sex="男",phone="18166666666",address="山东省")
            #查看数据的代码
            stu.name,stu.age,stu.sex,stu.phone,stu.address,stu.id
            ('张三', 20, '男', '18188888888', '江西省南昌市', 1)

            注意:添加的数据的id如果已经存在于数据库表中，添加的新数据就会完全覆盖以前的数据
            以上添加数据的方式等价于SQL语句的以下代码:
                insert into BaiDu_Student(name,age,sex,phone,address) values("张三",20,"男","18188888888"，“江西省南昌市”)
        6.2 查询数据
            #查询学生表中所有数据
            list=Student.objects.all()
            #循环打印列表中的所有学生信息
            for s in list:
                   print(s.id,s.name,s.age,s.sex,s.phone,s.address) 
             
            #输出的结果为:
                1 张三 20 男 18188888888 江西省南昌市
                2 张三疯 100 男 18166666666 山东省

            #将所有数据按指定的字段进行排序获得
            list=Student.objects.order_by('age')
            for s in list:
                   print(s.id,s.name,s.age,s.sex,s.phone,s.address) 

            结果为:
            1 张三 20 男 18188888888 江西省南昌市
            2 张三疯 100 男 18166666666 山东省

            #根据指定的字段进行降序排列
            list=Student.objects.order_by('-age')
            for s in list:
                   print(s.id,s.name,s.age,s.sex,s.phone,s.address) 
   
            结果为:
            2 张三疯 100 男 18166666666 山东省
            1 张三 20 男 18188888888 江西省南昌市

            
            #根据条件查询，查询年龄等于100岁的同学的信息
            #  select *  from BaiDu_Student where age=100
            list=Student.objects.filter(age=100)
            for s in list:
                   print(s.id,s.name,s.age,s.sex,s.phone,s.address) 
   
            结果为:
            2 张三疯 100 男 18166666666 山东省

            #条件查询，与filter方法相反，表示不等于
            #查询年龄不等于100岁的学生信息
            list=Student.objects.exclude(age=100)
            for s in list:
                   print(s.id,s.name,s.age,s.sex,s.phone,s.address) 
   
            结果为:
            1 张三 20 男 18188888888 江西省南昌市

            #获得单条数据，查询id等于1的学生
            list=Student.objects.filter(id=1)
            for s in list:
                   print(s.id,s.name,s.age,s.sex,s.phone,s.address) 
   
            结果为:
            1 张三 20 男 18188888888 江西省南昌市
            #第二种方式
            stu=Student.objects.get(id=1)

            stu.id,stu.name,stu.age,stu.sex,stu.phone,stu.address

            结果为:
            (1, '张三', 20, '男', '18188888888', '江西省南昌市')

            注意:当条件匹配出多条数据符合要求的时候，不能使用get方法执行，应该使用filter作为查询条件的方法，使用get方法，如果没有查询到数据，也会出错

            #当查询多条数据获得结果后，如果不想通过循环遍历的方式查看结果，那么可以使用转换成字典和列表的方法
            #将查询的结果转换成字典，进行打印输出
            list.values()

            结果为:
                              {'id': 2, 'name': '张三疯', 'age': 100, 'sex': '男', 'phone': '18166666666', 'address': '山东省'}]>

            #将查询的结果转换成列表
            list.values_list()

            结果为:
            

            #查看部分数据，例如只查看姓名和手机号
            #采用字典的方式查看数据
            list.values('name','phone')
            
            #采用列表的方式查看数据
            list.values_list('name','phone')
            
        6.3 字段查找
            #根据条件进行运算符的操作
            #查询id为2和4和6的学生信息
            #select * from BaiDu_Student where id=2 or id=4 or id=6
            #select * from BaiDu_Student where id in(2,4,6)
            list=Student.objects.filter(id__in=(2,4,6))
            list.values_list()
            
            结果为:
            

            #查询学号大于3的所有学生信息
            list=Student.objects.filter(id__gt=3)
            list.values("id","name")

            #查询地址在江西省的所有同学的信息
            list=Student.objects.filter(address__contains="江西省")
            list.values("id","name","address")
            
            #查询姓张的所有同学
            list=Student.objects.filter(name__startswith="张")
            # select * from BaiDu_Student where name like '张%'
            list.values("name")

            #查询姓名中最后一个字是疯字的同学
            #select * from BaiDu_Student where name like '%疯'
            list=Student.objects.filter(name__endswith="疯")
            list.values("name")

            #查询学号大于等于2，小于等于5的所有学生信息
            # select * from student where id>=2 and id<=5

            #查询名字叫张三并且性别为男
            list=Student.objects.filter(name="张三",sex="男").values()
            list
            
            
            #查询学号大于等于2，小于等于5的所有学生信息
            list=Student.objects.filter(id__gte=2,id__lte=5)
            list.values("id","name")
            
            
            #查询学号大于等于2，小于等于5的所有学生信息
            # select * from student where id between 2 and 5
            list=Student.objects.filter(id__range=(2,5))
            list.values("id","name")
            

            #使用正则表达式匹配手机号最后一个数字是6的手机号
            list=Student.objects.filter(phone__regex="^[0-9]{10}6$")
            list.values("id","name","phone")
            

        6.4 修改语句
            #修改id为2的学生的年龄改为25岁
            #第一步，把要修改的这个学生先查询出来
            stu=Student.objects.get(id=2)
            #第二步，把查询出来的这个学生的对象中的年龄重新赋值为25
            stu.age=25
            #第三步，把修改后的这个对象同步保存到数据库中
            stu.save()

            #将学号大于等于3的学生的年龄都改为22岁
            list=Student.objects.filter(id__gte=3)
            for l in list:
                    l.age=22
                    l.save()
            
            #第二种修改的方式
            #第一步，把要修改的学生先查询出来
            stu=Student.objects.filter(id=1)    
            #第二步，调用update方法直接修改
            stu.update(name="李四")

            #将整张表的所有学生的地址都修改了，改为江西青年职业学院
            Student.objects.update(address="江西青年职业学院")
        
        6.5 删除语句
            #删除学号为6的学生
            #第一步，把要删除的学生查询出来
            stu=Student.objects.get(id=6)
            #第二步，调用delete方法将查询出来的学生删除掉
            stu.delete()

            #删除所有学生信息
            #第一步 将所有学生查询出来
            list=Student.objects.all()
            #第二步，将所有学生进行删除
            list.delete()

            #统计查询出来的学生的个数
            # select COUNT(*) from student
            list=Student.objects.all()
            //写法一
            list.count()
            //写法二
            len(list)
            
            #使用切片操作获得数据
            #涉及的区间范围是包头不包尾
            list=Student.objects.all()[:2]
            list.values("id","name")
            
            list=Student.objects.all()[2:]
            list.values("id","name")
            

            #查询学生表中是否存在女学生
            list=Student.objects.filter(sex="女")
            list.count()
            #查询出来的查询集也可以作为boolean类型，当没有查询查询到数据，那么为false，如果集合中有一条或一条以上数据，那么为true
            if list:
                    print("学生表中有女学生")
            else :
                    print("学生表中没有女学生")
    
            #用于判断查询集中是否存在数据，存在为true，不存在为false
            if list.exists():
                    print("学生表中有女学生")
            else :
                    print("学生表中没有女学生")
    

            #查询年龄为20岁，性别为男的所有学生
            #第一种
            list=Student.objects.filter(age=20)&Student.objects.filter(sex="男")
            list.values()
            #第二种
            list=Student.objects.filter(age=20,sex="男")
            list.values()
            #第三种
            from django.db.models import Q
            list=Student.objects.filter(Q(age=20)&Q(sex="男"))
            list.values()

            
            #查询学号为7和学号为10
            list=Student.objects.filter(id__in=[7,10])
            list.values()
            
            list=Student.objects.filter(id=7)|Student.objects.filter(id=10)
            list.values()
            
            
        6.6 特殊查询表达式
                
            F()表达式的使用
                #王五同学的Python程序设计课程的平时成绩减5分
                #写法一
                s=Score.objects.get(name="王五",project="Python程序设计")
                s.ps=s.ps-5
                s.save()
                
                #王五同学的Python程序设计课程的平时成绩加5分
                #写法二
                from django.db.models import F
                s=Score.objects.get(name="王五",project="Python程序设计")
                s.ps=F("ps")+5
                s.save()
                
                #如果想查看修改后的数据，可以有以下两种方式
                #第一种重新根据条件查询数据库:
                s=Score.objects.get(name="王五",project="Python程序设计")
                #第二种刷新数据库，得到修改的数据:
                s.refresh_from_db()

                #查询出综合成绩大于平时成绩的所有学生的课程数据
                list=Score.objects.filter(zh__gt=F("ps"))
                list.values()

            数据库函数表达式
                #查询每一个学生名字中的第一个字
                from django.db.models.functions import Left
                #表示从数据库中获得每一个名字从左开始获得第一个字赋值给abc变量
                list=Score.objects.annotate(abc=Left('name',1))
                #输出第一条数据的abc变量的值和第一条数据的姓名这个字段的值
                list[0].abc,list[0].name

                #查询每一个学生名字中的最后一个字
                from django.db.models.functions import Right
                list=Score.objects.annotate(abc=Right('name',1))
                for li in list:
                        print(li.abc,li.name)
                        
                    
                #查询每条记录中课程的字符串长度
                from django.db.models.functions import Length
                list=Score.objects.annotate(abc=Length('project'))
                for li in list:
                        print(li.abc,li.project)
    

            聚合函数表达式
                Django提供的聚合函数如下：
                    Avg：求平均值。
                    Count：求数量。
                    Max：求最大值。
                    Min：求最小值。
                    StdDev：求标准差。
                    Sum：求和。
                    Variance：求差额。

                #查询期末成绩的平均分，最高分，最低分
                from django.db.models import Avg,Max,Min
                Score.objects.aggregate(Avg("qm"),Max("qm"),Min("qm"))

                结果:
                {'qm__avg': 57.9, 'qm__max': 80, 'qm__min': 20}

                #给结果取别名
                Score.objects.aggregate(a=Avg("qm"),b=Max("qm"),c=Min("qm"))
                结果:
                {'a': 57.9, 'b': 80, 'c': 20}

                #查询Django框架开发这门课程的期末成绩的平均分，最高分，最低分
                list=Score.objects.filter(project="Django框架开发")
                list.aggregate(Avg("qm"),Max("qm"),Min("qm"))

                #查询出所有学生的成绩中，综合分数最高的那门课程名称和学生姓名
                maxScore=Score.objects.aggregate(Max("zh"))
                list=Score.objects.filter(zh=maxScore["zh__max"])
                list.values("name","project")
            
                #查询出共有多少门期末成绩

                #查询所有期末成绩的总分

                #查询每一个学生的所有成绩的总分
                # select name, SUM(qm) from BaiDu_Score group by name
                from django.db.models import Sum
                list=Score.objects.values("name").annotate(total=Sum("qm"))
                for li in list:
                    print(li["name"],li["total"])

                #查询每门课程的综合成绩平均分
                    
            使用原始Sql语句执行数据库操作
                raw方法的使用
                    #查询所有成绩信息
                    list=Score.objects.raw("select * from BaiDu_score")
                    #返回值是RawQuerySet查询集，而并不是QuerySet这个查询集，
                    #所有在循环输出的时候，不能使用values方法转换成字典或者使用values_list方法转换成元组
                    #只能使用循环遍历的方式输出结果
                    for li in list:
                            print(li.name,li.project)
                    
                    #当执行sql语句需要传入参数数据时候，可以将数据单独提出来，sql语句上使用%s作为占位符，把位置先占下来
                    #写法一
                    list=Score.objects.raw("select * from BaiDu_score limit 3,5")
                    for li in list:
                            print(li.id,li.name,li.project)
                        #写法二
                    list=Score.objects.raw("select * from BaiDu_score limit %s,%s",[3,5])
                    for li in list:
                            print(li.id,li.name,li.project)
    
                    #使用sql语句进行删除操作
                    d=Score.objects.raw("delete from BaiDu_score where id=%s",[4])
                    n=d.query._execute_query()

                    #使用sql语句进行修改和添加操作
（第四章的代码请查看Day331项目）

    第五章 视图

    视图（View）是Django的MTV架构中的重要组成部分，它实现业务逻辑处理，决定如何处理用户请求(request)和生成响应内容(response)，并在Web页面或其他文档中显示响应结果。
    （详细笔记请查看Day0421项目的views.py文件）

第六章  模板(Template)

    Template:模板类，用于创建模板，使用Python创建html页面的模板
    在django服务器中，需要将Python代码的数据发送给html页面上显示，需要用 {{ key }}获得Python代码存储在字典集合中的数据
    def one(request):
            #创建html模板
            t=Template("

收到Python提交的数据为:{{ name }}

")
            #存储在Python中数据
            c=Context({"name":"刘强东"})
            #将Python数据渲染到html模板上
            return HttpResponse(t.render(c))

    ?构造函数Template()将模板字符串作为参数来创建模板对象。
    构造函数Context()用字典对象创建上下文对象，用于封装传递给模板的数据。
    模板对象的render()方法接收上下文对象参数，执行渲染操作，将数据填入模板，生成HTML代码。

    Template对象适用于处理比较简单的模板。相对复杂的模板则应使用模板文件。

    因为在字符串中手动编写html格式的页面效率太低，尤其是操作比较复杂的html页面时，所有在django中将html页面单独创建，提高开发效率
    并在views文件的方法中使用get_template方法将创建的html文件加载至Python代码。使用get_template加载html文件，不用通过Context对象封装字典，
    直接将字典发送至html文件上进行同步

    TemplateResponse：用于整合加载html文件，渲染字典的数据与html文件，将渲染后的html文件通过request转发给浏览器

    render():快捷方法，使用该方法进行渲染数据和跳转页面效率是最高的，速度是最快的

    在django中定义html模板，在html模板中定义变量的时候，{{ 变量 }}
    变量名由字母、数字和下划线组成，但不能以下划线开头
    Django在渲染模板时，会将遇到的变量替换为上下文中对应的变量值。
    如果变量是对象，可使用点号（.）访问其属性或方法。

    {% comment %}
    多行注释

    {% endcomment %}

    {#  单行注释 #}

    过滤器:
    
    {{ tq | default:"阴天" }}:表示当字典中的key为tq的值为false或者为空时，模板上的对应的这个变量名就会启用后面的默认值，
        否则显示的就是字典中的数据
    
    for循环的使用
    {% for  x in list %}

    {% endfor%}
    
    if判断的使用
    {% if  判断条件 %}

    {% elif 判断条件%}

    {% else %}

    {% endif %}
（本章知识点的详细内容请见项目Day0512）

第七章 后台管理系统

什么是Admin？
    Admin是Django自带的一个功能强大的自动化数据管理界面
    被授权的用户可直接在Admin中管理数据库
    Django提供了许多针对Admin的定制功能

首先要建立数据库，包含在models.py定义模型类，生成迁移文件，将所有迁移文件转换成对应的数据的表，然后才能执行创建超级用户
要操作后台管理系统，需要管理员的账号和密码，先要创建管理员的账号和密码，创建的指令为:python manage.py createsuperuser

因为后台管理系统默认使用英文显示页面，如果需要后台管理系统为中文格式，那么在主项目的Setting.py文件中LANGUAGE_CODE = 'en-us'，en-us：英语
把这个参数改为 "zh-Hans"

如果需要使用后台管理系统去操作指定的数据库表，那么需要在admin.py文件中进行授权，表示授予admin.py文件指定的后台管理系统操作数据库表的权限