Django 模板语言 路由 视图

    1. 模板语言（字符串替换）
        1. 母版和继承
            1. 什么时候用母版？
                html页面有重复的代码，把它们提取出来放到一个单独的html文件。
                （比如：导航条和左侧菜单）
            2. 子页面如何使用母版？
                {% extends 'base.html' %}   --> 必须要放在子页面的第一行
                
                母版里面定义block(块)，子页面使用block(块)去替换母版中同名的块
        2. 组件
            1. 什么时候用组件？
                重复的代码,包装成一个独立的小html文件。
            2. 如何使用？
                {% include 'nav.html' %}
                
        3. Django模板语言中关于静态文件路径的灵活写法
            1. 利用Django模板语言内置的static方法帮我拼接静态文件的路径
                {% load static %}
                <link href="{% static 'bootstrap/css/bootstrap.min.css' %}" rel="stylesheet">
            2. 利用内置的get_static_prefix获取静态文件路径的别名，我们自行拼接路径
                {% load static %}
                <link href="{% get_static_prefix %}bootstrap/css/bootstrap.min.css" rel=stylesheet>
            3. as语法(一个路径多次用到，可以使用as保存到一个变量，后面就直接使用变量代替具体路径)
        4. 自定义的simple_tag
            比filter高级一点点
            它可以接受的参数个数大于2
        
        5. 自定义的inclusion_tag
            用来返回一段html代码（示例：返回ul标签）
            
            1. 定义阶段
                在app下面新建templatetags 文件夹（注意是Python包）
                新建一个py文件
                
                from django import template
                # 生成注册示例，名字必须是register
                register = template.Library()
                @register.inclusion_tag("ul.html")
                def show_ul(num):
                    num = 1 if num < 1 else int(num)
                    data = ["第{:0>3}号技师".format(i) for i in range(1, num+1)]
                    return {"data": data}

            2. 调用阶段
                {% load xx %}
                {% show_ul 10 %}
            
2. 今日内容
    1. 视图（接收请求返回响应那部分）
        1. CBV(class base view)和FBV(function base view)
    
        2. request对象
            1. 之前学过的
                1. request.method    --> 获取请求的方法（GET、POST等）
                2. request.GET       --> 通常用来获取URL里面的参数  
                    127.0.0.1:8000/edit_book/?id=1&name=yimi
                    request.GET --> {"id":1, "name":"yimi"}
                    request.GET.get("id")
                3. request.POST      --> 用来获取POST提交过来的数据
                    request.POST.get("book_name")
            2. 补充其他常用的：
                1. request.path_info   --> 获取用户请求的路径(不包含IP和端口和URL参数)
                2. request.body     
    
        3. response
            基础必备三件套(求学要严谨)
            1. HttpResponse        --> 返回字符串内容
            2. render              --> 返回一个html页面             
            3. redirect            --> 返回一个重定向（告诉浏览器再去访问另外的网址）
            
            4. JsonResponse
            
    2. 路由系统（urls.py）  http://www.cnblogs.com/liwenzhou/p/8271147.html
        1. 正则表达式的模糊匹配
        2. 分组匹配        --> 相当于给视图函数传递位置参数
        3. 分组命名匹配    --> 相当于给视图函数传递关键字参数
            (两个不要混合使用)
            
            
        4. 反向解析URL
            本质上就是给url匹配模式起别名，然后用过别名拿到具体的URL路径
            
            1. 怎么起别名?
                在url匹配模式中，定义name="别名"
            2. 如何使用？
                1. 在模板语言里面使用：
                    {% url "别名" %}  --> 得到具体的URL路径
                2. 在视图中如何使用：
                    from django.urls import reverse
                    
                    reverse("别名")  --> 得到具体的URL路径
            3. 如何传参数？
                1. 模板语言中：
                    {% url "别名" 2018 "nb" %}
                2. 视图函数中
                    传位置参数：
                        reverse("别名", args=(2018, "nb"))
                
                    传关键字参数：
                        reverse("别名" kwargs={"year": 2018, "title": "nb"})
            4. namespace
                为了防止不同的app下面的url匹配模式有重复的别名

1. 内容回顾
    1. ORM已经的学过的内容：
        1. Django项目如何使用ORM连接MySQL
            1. 手动创建数据库
            2. 在settings.py里面配置一下数据库的连接信息（告诉Django连接哪一个数据库）
                DATABASES = {
                    'default': {
                        'ENGINE': 'django.db.backends.mysql',  # 连接数据库的类型
                        'NAME': 'day62xiawu',  # 数据库名字
                        'HOST': '127.0.0.1',  # IP
                        'PORT': 3306,  # 端口
                        'USER': 'root',  # 用户名
                        'PASSWORD': '123456',  # 密码
                    }
                }
            3. 在和settings.py同目录下的__init__.py文件中，告诉Django用pymysql代替MySQLdb来连接数据库
                import pymysql
                pymysql.install_as_MySQLdb()
            4. 在app/models.py中，定义类，类一定要继承models.Model
                class Book(models.Model):
                    id = models.AutoField(primary_key=True)
                    title = models.CharField(max_length=32)
            5. 执行两条命令
                1. 在哪儿执行？
                    在项目的根目录（有manage.py文件的那个目录）
                2. 命令
                    python manage.py makemigrations   --> 将models.py文件中的改动记录在小本本（app/migrations/00xx_****.py）上
                    
                    python manage.py migrate           --> 将改动翻译成SQL语句，去数据库中执行
        2. 表和表之间的关系
            1. 一对多（出版社和书）
                publisher = models.ForeignKey(to="Publisher")
                
                在数据库中：
                    有没有publisher这个字段？
                    数据库中实际 生成的是一个 publisher_id 字段
                
            2. 多对多（作者和书）
                books = models.ManyToManyField(to="Book")
                
                在数据库中：
                    是通过第三张表建立的关系

        3. 增删改查操作
            1. 单表增删改查
                增：
                    models.Publisher.objects.create(name="沙河出版社")
                查：
                    models.Publisher.objects.get(id=1)
                    models.Publisher.objects.get(name="沙河出版社")
                删：
                    models.Publisher.objects.get(id=1).delete()
                改：
                    obj = models.Publisher.objects.get(id=1)
                    obj.name = "沙河第二出版社"
                    obj.save()
            2. 外键的增删改查
                增、删、查同上
                
                book_obj = models.Book.objects.get(id=1)
                
                book_obj.publisher 是什么？    *****
                    和我这本书关联的出版社对象
                    
                    book_obj.publisher.id    和我这本书关联的出版社的id值
                    book_obj.publisher.name  和我这本书关联的出版社的名称
                    
                book_obj.publisher_id 是什么？
                    和我这本书关联的出版社的id值
                    
            3. 多对多操作
                
                1. 查id为1的作者都写过的书？
                    author_obj = models.Author.objects.get(id=1)
                    author_obj.books.all()     --> 和我这个作者关联的所有书对象
                2. 想给作者绑定多本书？
                    author_obj = models.Author.objects.get(id=1)
                    author_obj.books.set([1,2,3]) --> 把id是1、2、3的书和我这个作者关联上
                
2. 今日内容

        1. Django ORM常用字段：
            1. AutoField       --> 自增
            2. CharField       --> varchar(xx)
            3. ForeignKey      --> 外键
            4. ManyToManyField --> 多对多关联
            
            5. DateField
            6. DateTimeField
            
            7. IntegerField
            
            
        2. 自定义char字段
            class FixedCharField(models.Field):
                """
                自定义的char类型的字段类
                """
                def __init__(self, max_length, *args, **kwargs):
                    self.max_length = max_length
                    super(FixedCharField, self).__init__(max_length=max_length, *args, **kwargs)

                def db_type(self, connection):
                    """
                    限定生成数据库表的字段类型为char，长度为max_length指定的值
                    """
                    return 'char(%s)' % self.max_length

            
            
        3. 常用的字段参数
            1. null
            2. default
            3. unique
            4. db_index
            
            5. DateField和DateTimeField才有的参数：
                auto_now_add=True     --> 创建数据的时候自动把当前时间赋值
                auto_add=True         --> 每次更新数据的时候更新当前时间
                
                上述两个不能同时设置！！！
            
            5. class Meta:
                 db_table = "表名"