Django

1、settings.py
            项目的主设置文件
            1、BASE_DIR
                获取当前项目的根目录路径
            2、DEBUG ：调试模式
                开发过程：推荐使用True
                上线运行：推荐改为False
            3、ALLOWED_HOSTS
                设置允许访问本项目的地址列表
                如果不设置的话，只有本机能访问(localhost/127.0.0.1)能访问
                推荐写'*',表示任何地址都允许访问该项目(局域网)

                python3 manage.py runserver 0.0.0.0:8000
                ./manage.py runserver 0.0.0.0:8000
            4、INSTALLED_APPS
                指定已安装的应用，如果有自定义应用的话，需要在此位置进行注册
            5、MIDDLEWARE
                指定注册的中间件
            6、ROOT_URLCONF
                指定项目的基础路由配置文件
            7、TEMPLATES：指定模板的信息
            8、DATABASES：指定数据库的信息
            9、LANGUAGE_CODE
                指定网站的显示语言，如果要使用中文则可以修改为 zh-Hans
            10、TIME_ZONE
                指定时区，如果指定中国时区，则可以修改为  Asia/Shanghai
2、urls.py
    1、url函数
        url函数的语法：
        url(regex,views,kwargs=None,name=None)
        1、regex
            正则表达式，匹配请求的url
        2、views
            视图处理函数或其他的urls.py
        3、kwargs
            字典，用来向views传参，没有参数则可以省略
        4、name
            字符串，给url()起别名，主要在模板中使用
        ex:
            urlpatterns = [
                url(r'^run/$',run_views),
            ]
    2、通过 url 向 views 传参
        1、使用正则表达式传参
            使用子组传参，一个子组是一个参数，想要多个参数的话，可以使用多个子组
            子组 - ()
            urlpatterns = [
                #访问路径是run/的时候，交个run_views去处理
                url(r'^run/$',run_views),
                #访问路径是run/任意两位数字，交给run_args_views去处理
                url(r'^run/(\d{2})',run_args_views),
                #访问路径是run/四位数字/两位数字/，交给run1_views处理
                url(r'^run/(\d{4})/(\d{2})/$',run1_views),
            ]
            注意：
                1、在url()中，一个子组()表示一个参数
                2、在views.py中，对应的处理函数要根据url()中子组的个数，相应的定义参数，定义的参数要位于request之后
                ex:
                    1、
                        url(r'^run/(\d{2})',run1_views),

                        def run1_views(request,num)
                    2、
                        url(r'^run/(\d{2})/(\d{4})',run2_views)

                        def run2_views(request,num1,num2)
        2、使用url()第三个参数，字典传参
            url(r'^show/$',show_views,{'name':'laoshe','age':'89'})

            def show_views(request,name,age):
                name:表示的就是字典name参数的值
                age:表示的就是字典age参数的值
            注意：
                1、视图处理函数中，必须声明参数
                2、参数的名称和位置，必须要与字典中的名称和位置保持一致
3、Django 的模板(Templates)
    1、什么是模板
        模板就是要动态的给用户呈现的网页内容
        其实就是一个网页 - 前后端结合的一个网页
    2、模板的设置
        在 settings.py中 TEMPALTES 变量
        TEMPLATES = [
            {
                'BACKEND':'... ...',
                'DIRS':[... ...],
            }
        ]
        1、BACKEND：指定模板的搜索引擎，不用动
        2、DIRS：指定模板所存放目录们
            DIRS=['index.temp','music.temp']
            但是，如果DIRS中为空的话，那么Django会自动到每个应用中去搜索一个叫 templates 的目录来作为模板的管理目录
            推荐：
                1、DIRS内容保持为空
                2、在每个应用中，都创建一个 templates 目录
        3、APP_DIRS
            True：首先从DIRS中指定的目录中查找模板，如果没找到的话，再搜索templates目录
4、模板的语法
        1、变量
            1、作用：允许将后端的数据传递给模板，在模板中，会根据变量的值进行显示
            2、在Django中允许传递给模板做变量的数据类型
                数字，字符串，列表，元组，字典，函数，对象
            3、变量的语法
                1、loader
                    dic = {
                        '变量名1':'值1',
                        '变量名2':'值2',
                    }

                    t = loader.get_template('xxx.html')
                    html = t.render(dic)
                    return HttpResponse(html)

                    在模板中显示变量：{{变量名}}
                2、render
                    dic = {
                        '变量名1':'值1',
                        '变量名2':'值2',
                    }
                    return render(request,'xxx.html',dic)
            
        2、标签
            1、什么是标签
                允许将服务器端的一些功能嵌入到模板中
            2、语法
                {% 标签内容 %}
            3、常用标签
                1、for
                    {% for 变量 in 列表|元组|字典 %}
                    {% endfor %}
                    允许使用 for 提供的内置变量 - forloop
                    1、forloop.counter
                        记录当前循环的次数，从1开始
                    2、forloop.first
                        是否是第一次循环(第一项)
                    3、forloop.last
                        是否是最后一次循环(最后一项)
                2、if
                    1、
                        {% if 条件 %}
                            满足条件运行的内容
                        {% endif %}

                        条件中允许使用 比较运算符(>,<,>=,<=,==,!=)，逻辑运算符(not,and,or)
                        注意：and 和 or 不能同时出现
                    2、
                        {% if 条件 %}
                            满足条件运行的内容
                        {% else %}
                            不满足条件运行的内容
                        {% endif %}
                    3、
                        {% if 条件1 %}
                            满足条件1运行的内容
                        {% elif 条件2 %}
                            满足条件2运行的内容
                        {% elif 条件3 %}
                            满足条件3运行的内容
                        {% else %}
                            以上条件都不满足的时候运行的内容
                        {% endif %}
        3、过滤器
            1、作用
                过滤数据
                在显示变量的数据之前，允许对数据进行筛选或改变
            2、语法
                {{变量|过滤器:参数}}
            3、简单的过滤器
                1、{{value|upper}}
                    将value变为大写字符
                2、{{value|lower}}
                    将value编写小写字符
                3、{{value|add:num}}
                    将num累加到value之后
                4、{{value|floatformat:n}}
                    将value四舍五入到n位小数
                5、{{value|truncatechars:n}}
                    将字符串截取到n位(包含...)
5、模板静态文件
    1、静态文件
        1、什么是静态文件
            不需要嵌入服务器端内容的文件，一律都是静态文件，如：图片，css，js，html  都是静态文件
        2、Django中静态文件的处理
            需要在settings.py 中设置静态文件的访问路径和存储路径
            1、指定静态文件的访问路径
                STATIC_URL=/static/

                http://localhost:8000/static/***
                作用：
                    当访问路径是 http://localhost:8000/static/*** 一律到静态文件存储路径中去搜索静态文件
            2、定义静态文件的存储路径
                STATICFILES_DIRS

                STATICFILES_DIRS=(BASE_DIR,目录名)
                允许在项目中以及所有的应用中都创建对应名称得到目录

                STATICIFILES_DIRS=(BASE_DIR,static)
                在项目的 static 目录中以及所有应用中的 static 目录中 存放的都是静态文件
        3、访问静态文件
            1、直接使用 localhost:8000/static/***/***
                <img src="/static/****/***">
            2、使用  {% static %} 访问静态资源
                1、在模板的最顶层增加
                    {% load static %}
                2、在使用静态文件时
                    {%static%}表示的就是静态文件的访问路径
                    <img src="{% static 'img/huiyuan.jpg'%}">
6、模型 - Model
    1、什么是模型
        模型，是根据数据库中数据表的结构来创建出来的class。每一张表到编程语言中就是一个class，表中的每一个列，到编程语言中就是class的一个属性。并且在模型中还可以完成对数据的CRUD操作
    2、创建和使用模型 - ORM
        1、什么是ORM
            ORM:Object Relational Mapping
            中文：对象关系映射
            简称：ORM，O/RM，O/R Mapping

            三大特征：
                1、数据表 到 类(class)的映射
                    将数据表 自动 生成一个 class 类
                    同时也允许将一个class类 自动生成数据库中的一张表
                2、数据类型的映射
                    允许将表中的字段的数据类型 自动 映射成编程语言中对应的数据类型

                    也允许将编程语言的数据类型 自动 映射成 表中的字段的数据类型

                3、关系映射
                    在编程语言中允许将表与表之间的关系映射出来

                    表与表之间的关系也可以自动映射到编程语言的class 中

                    数据库表中的关联关系：
                    一对一，一对多，多对多
        2、ORM的优点
            1、提高了开发的效率，能够自动完成表到对象的映射
            2、不用SQL编码，也能够完成对数据的CRUD操作，可以省略庞大的数据访问层
    3、创建 和 配置数据库
        1、创建数据库(支持中文)
            create database 数据库名 default charset utf8 collate utf8_general_ci;

            创建数据库：webdb
        2、配置数据库(Django)
            在 settings.py 中配置数据库的信息
            DATABASES = {
                'default':{
                    'ENGINE':'... ...',
                    'NAME':'...',
                }
            }
            连接MySQL的配置如下：
                1、ENGINE : 引擎
                    django.db.backends.mysql
                2、NAME : 要连接到的数据库名
                3、USER:登录到数据库的用户名，一般为root
                4、PASSWORD:登录到数据库的密码
                5、HOST:要连接的主机，本机的话 localhost 或 127.0.0.1
                6、PORT:指定端口，MYSQL的是 3306
            注意：
                Django中连接mysql的话依赖 pymysql
                安装：sudo pip3 install pymysql==0.7.11

                在主目录中 __init__.py
                    import pymysql
                    pymysql.install_as_MySQLdb()
    4、字段类型  和  字段选项
        1、字段类型(Field Type)
            1、BooleanField()
            2、CharField()
            3、DateField()
            4、DateTimeField()
            5、DecimalField()
            6、EmailField() #存电子邮件 - varchar
            7、FloatField()
            8、ImageField() #存图片路径 - varchar
                ImageField(upload_to='static/***/***')
            9、IntergerField()
            10、URLField()
            11、TextField() #存大量文本数据 - text
        2、字段选项(Field Option)
            1、max_length
                指定数据的最大长度
                在CharField()必须要设置的选项
            2、default
                为当前字段指定默认值
            3、null
                指定当前字段是否允许为空，默认值是 false
7、模型中的 CRUD
    1、通过 ORM 向 DB 中增加数据
        1、Entry.objects.create(属性=值,属性=值)
            Entry：具体要操作的Model类

            ex:
                Author.objects.create(name='zsf',age=85)
        2、创建一个 Models 对象，通过对象的 save() 完成增加
            obj = Author(names='laoshe',age=65)
            obj.save()

        3、使用字典构建对象，通过 save() 完成增加
            dic = {
                '属性1':'值1',
                '属性2':'值2',
            }

            obj = Entry(**dic)
            obj.save()
        
        练习：
            使用三种方式，分别向 Book,Publisher 中各增加三条数据
    2、查询操作(重难点)
        通过 Entry.objects 调用查询接口
        1、基本查询操作
            语法：all()
            用法：Entry.objects.all()
            返回：QuerySet

            ex:
            Author.objects.all()
            等同于：select * from index_author
            
            返回结果：
            <QuerySet [<Author: Author object>, <Author: Author object>, <Author: Author object>]>
        
        2、查询指定列
            语法：values('列1','列2',...)
            用法：Entry.objects.values('列1','列2',...)
            返回：QuerySet

            ex:
                Author.objects.values('names','age')
                等同于：select name,age from index_author
            注意：
                values()可以用在所有的返回查询结果集的方法的后面

                Author.objects.all().values('names','age')

            <QuerySet [{'age': 65, 'names': 'ZhuZiqing'}, {'age': 68, 'names': 'laoshe'}, {'age': 59, 'names': 'MoYan'}]>
        3、排序函数
            语法：order_by('列1','列2')
            用法：Entry.objects.order_by('-列1','列2')
                默认的排序规则是升序
                如果需要降序，则在列前添加一个 "-"
            ex:
                1、Author.objects.order_by('age')
                2、Author.objects.all().order_by('-age');
        4、对条件取反
            语法：exclude()
            用法：Entry.objects.exclude(条件)
            ex:
                1、Author.objects.exclude(id=3)
                    select * from author where not (id=3)
                2、Author.objects.exclude(id=3,age=85)
                    select * from author where not (id=3 and age=85)
        5、根据条件查询部分行数据(重难点)
            方法：filter(参数)
            用法：Entry.objects.filter(参数)
            1、使用 Entry 中的属性作为查询参数
                多个参数的话，使用 , 隔开，映射到sql语句上，是使用 and 来进行关联的
                ex:
                    1、Author.objects.filter(id=1)
                        select * from author where id=1
                    2、Author.objects.filter(id=1,name='莫言')
                        select * from author where id=1 and name='莫言'
            2、通过 Field Lookup(查询表达式)完成复杂条件的构建
                查询表达式：每个查询表达式都是一个独立的查询条件，可以用在所有的有查询条件的位置处
                1、__exact
                    作用：精确查询，等值判断
                    用法：Entry.objects.filter(属性__exact=值)
                    ex:
                        Author.objects.filter(id__exact=1)
                        select * from author where id=1
                2、__contains
                    作用：筛选出属性中包含指定关键字的记录(模糊查询)
                    ex:
                        Author.objects.filter(names__contains='ao')
                        select * from author where names like '%ao%'
                3、__lt
                    作用：筛选出属性值小于指定值的记录
                4、__lte
                    作用：筛选出属性值小于等于指定值的记录
                5、__gt
                    作用：筛选出属性值大于指定值的记录
                6、__gte
                    作用：筛选出属性值大于等于指定值的记录
                7、__startswith
                    作用：筛选出以指定关键字开始的记录
                8、__endswith
                    作用：筛选出以指定关键结尾的记录
        6、查询只返回一条数据
            语法：get(条件)
            用法：Entry.objects.get(查询条件/表达式)
            注意：
                该函数只适用于 返回一条记录时使用
    3、修改数据
        1、修改单个数据
            1、通过 get() 得到要修改的实体对象
            2、通过实体对象的属性修改属性值
            3、再通过实体对象的save()保存回数据库
            ex:
                au = Author.objects.get(id=1)
                au.names = "老舍"
                au.age = 45
                au.save()

        2、批量修改数据
            调用查询结果集的 update() 完成批量修改
            Entry.objects.all().update(属性=值,属性=值)

            ex:
                Author.objects.all().update(age=75)
    4、删除数据
        调用实体对象/查询结果集的 delete() 即可
        1、删除单个对象
            obj = Author.objects.get(id=1)
            obj.delete()
        2、删除多个对象
            Author.objects.all().delete()
    5、F()操作
        1、作用
            在执行操作中，获取某列的值时使用
        2、语法
            F('列名')

            from django.db.models import F
            Author.objecs.all().update(age=F('age')+10)
    6、Q()操作
        Author.objects.filter(id=1,age=35)
        select * from author where id=1 and age=35

        作用：在查询条件中，可以完成或(or)的操作
        语法：
            from django.db.models import Q
            Q(表达式)|Q(表达式)

            ex:查询Author实体中，id为6或年龄大于等于70的人的信息
            Author.objects.filter(Q(id=6)|Q(age__gte=70))
            select * from index_author where id=6 or age>=70

    7、原生的数据库操作方法
        1、查询
            函数：raw(sql语句)
            语法：Entry.objects.raw(sql)
        2、增删改
            def doSQL(request):
                with connection.cursor() as cursor:
                    sql = "delete from author"
                    cursor.execute(sql)
                    return HttpResponse('...')
8、使用后台管理 Models
    1、后台的配置
        登录地址：http://localhost:8000/admin

        创建后台管理员：
        ./manage.py createsuperuser
        Username:输入用户名，默认为 tarena
        Email Address:电子邮件
        Password:密码
        Password(again):重复密码

    2、基本管理
        1、在应用中的 admin.py 中注册要管理的实体类
            1、admin.py
                作用：注册需要管理的Models，只有在此注册的Models才允许被管理
            2、注册Models
                from .models import *

                admin.site.register(Entry)
                admin.site.register(Entry)
        2、修改 models.py 处理显示内容
            1、在models.py中 为各个 class 追加
                def __str__(self):
                    return self.属性名
            2、通过 Models 类的内部类 Meta 定义每个类的展现形式
                class Author(models.Model):
                    ... ...
                    class Meta:
                        1、db_table
                            指定该实体类对应到的表的名称
                        2、verbose_name
                            定义当前实体类在后台管理的列表页中的名称(单数形式)
                        3、verbose_name_plural
                            效果同上，是复数形式
                        4、ordering
                            指定实体数据列表页中的排序规则
                            取值是一个列表，默认按升序排序，降序则需要手动添加 负号

    3、高级管理
        1、在 admin.py 中创建高级管理类
            1、定义 EntryAdmin，继承自admin.ModelAdmin
                class AuthorAdmin(admin.ModelAdmin):
                    pass
            2、注册高级管理类
                admin.site.register(Entry,EntryAdmin)

                admin.site.register(Author,AuthorAdmin)
        2、定制高级管理信息
            1、list_display
                作用：指定在 列表页中 能够显示的字段们
                取值：由属性名称组成的元组或列表
                ex:
                    list_display=['names','age','email']
            2、list_display_links
                作用：指定在列表页中也能链接到详情页的字段们
                取值：由属性名称组成的元组或列表
                注意：取值必须出现在list_display的取值中
            3、list_editable
                作用：指定在列表页中就允许被编辑的字段们
                取值：由属性名称组成的元素或列表
                注意：取值不能出现在list_display_links,但必须出现在list_display中
            4、search_fields
                作用：添加允许被搜索的字段们
                取值：由属性名称组成的元组或列表
            5、list_filter
                作用：在列表的右侧增加过滤器实现快速筛选
                取值：由属性名称组成的元组或列表
            6、date_hierarchy
                作用：在列表页的顶端增加一个时间选择器。取值必须是DateField或DateTimeField的值
            7、fields
                作用：在详情页面中，指定显示哪些字段并按照什么样的顺序显示
                取值：由属性名称组成的元组或列表
            8、fieldsets
                作用：在详情页中，对字段们进行分组显示
                注意：fieldsets 与 fields 不能共存
                语法：
                    fieldsets = (
                        #分组1
                        (
                            '分组名称',{
                                'fields':('属性1','属性2'),
                                'classes':('collapse',),
                            }
                        ),
                    )