Django总结三

回顾：

- 装饰器
    模板
        -
            def wrapper(func):
                def inner(*args, **args):
                    执行被执行函数之前的操作
                    res = func(*args, **args)
                    执行被装饰函数之后的操作
                    return res
                return inner

    - django有关命令
        - django安装
            - pip install -i yuan django==1.11.11
        - 创建项目
            - django-admin startproject 项目名
        通过manage.py执行
        CD 项目目录下
        - 创建app
            - python manager.py startapp appname
        - 启动项目
            - python mamager.py runserver
        - 数据库相关
            python manager.py makemigrations 记录models的变化，将变更记录记录到对应app下的migrations文件夹下
            python manager.py migrate 翻译成sql语句，去数据库执行

    - 配置settings.py
        - 数据库相关
            - EGNIGE： 引擎
            - NAME: 数据库名
            - HOST:IP
            - PORT：端口号  3306
            - USER: 用户名
            - PASSWORD: 密码

        - 静态文件相关
            - STATIC_URL = ‘static’   # 别名
            - STATICFILES_DIRS = [
                os.path.dirname(BASE_DIR, 'static')
            ]

        - APP
            - INSTALLED_APPS = [
                'appname'.apps.AppnameConfig,  # 注册
            ]
        - CSRF 中间件
            - 安全

        - TEMPLATES
            - ‘DIRS’:[os.path.join(BASE_DIR, 'templates')]
    - ORM
        - Django使用mysql数据库的配置
            - 手动创建mysql数据库
            - 在settings.py中配置
                - DATABASES
                    - 可以连接多个数据库
            - 告诉django使用pymysql连接数据库
                - 在与settings.py文件同级的目录下的__init__.py文件中写
                - import pymysql
                - pymysql.install_as_MySQldb()
            - 在models.py中写类
                - 继承models.Model
            - 执行命令
                - makemigrations
                - migrate
        - ORM操作
            - 查
                - 先导入models（用里面的类也就是表名）
                - all()   查询所有的对象  queryset  对象列表
                - filter(筛选条件)    查询所有满足条件的对象  对象列表
                - get(筛选条件)    只能查询有且只能有一个对象，没有或者多个就报错  对象

                - 属性：
                    - obj.id
                    - obj.name
                - 外键
                    - obj.外键名        -> 关联的对象
                    - obj。外键名_id    -> 数据库中关联对象的id
                    - obj.外键名.id  -> 相比上一个多了查询操作
                - 多对多
                    - obj.多对多名        -> Django管理的对象
                    - obj.多对多名.all() -> 管理的所有对象
            - 增加
                - create(字段=‘’，字段=‘’)
                    - 外键
                        - 外键字段 = 对象
                        - 外键_id = ‘’
                    - 多对多
                        - 多对多名.set([多个数据的id])
                        - 多对多名.set([多个对象])
                        - 多对多名.add()
            - 删除
                - obj.delete()            删除单个对象
                - obj.filter.delte()      删除多个对象
            - 编辑
                - obj.字段名 = ‘新数据’   boj.save()
                - updata(字段名=‘新数据’) 不需要save
                - 外键
                    - obj.外键名 = 对象          obj.save()
                    - obj.外键名_id = ‘新id’ obj.save()
                - 多对多
                    - obj.多对多名.set([多个对象])
                    - obj.多对多名.add()

与deflate过滤器功能一样
    - settings
        - 将datatime对象统一改为固定格式，不需要每个都用data过滤器
            -1 DATATIME_FORMAT = 'Y-m-d H:i:s'
            -2 USE_L10N = False

csrf_token （过滤器）
        - 这个标签用于跨站请求伪造保护。
        - 在页面的form表单里面写上
            - 用这个后就可以将中间件打开（这样就安全了，知道是我能够收取的）

母版（一个普通的html文件）
    - 减少代码的重复

    - 母版写好
        - 不同的地方用以下占位
        - {{ block contenter(name) }}

            {{ endblock }}
    - 子文件
        - {% extends '母版html' %}  # 继承母版

        - {% block contenter(name) %}  # 将母版中的站好位置额contenter填充
                自己的html文件
            {% endblock %}

自定义filter
    - 自定义过滤器只是带有一个或两个参数的Python函数:

        变量（输入）的值 - -不一定是一个字符串
        参数的值 - 这可以有一个默认值，或完全省略
        例如，在过滤器{{var | foo:'bar'}}中，过滤器foo将传递变量var和参数“bar”。

    - 创建 (步骤)
        - 先在app目录下创建一个templatetagspython包（名字必须这个）
        - 在目录中创建一个py文件
        - 在py文件中按照固定的格式自定义一个filter（就是一个函数）
        - 需要先导入 from django import template
            # 固定写法，生成一个注册实例对象
            register = template.Library()

            @register.filter()  # 告诉Django的模板语言我现在注册一个自定义的filter
            def add_str():pass  # 第一个参数是变量名， 第二个参数为参数（最多一个）

        - 使用：
            - 重启DJango项目
            - 在HTML页面中：{% load python文件名 %}
            - {{ name|add_str:'好人啊' }}

        - 例子：
            - 自定义过滤器只是带有一个或两个参数的Python函数:

                变量（输入）的值 - -不一定是一个字符串
                参数的值 - 这可以有一个默认值，或完全省略
                例如，在过滤器{{var | foo：“bar”}}中，过滤器foo将传递变量var和参数“bar”。

            - 自定义filter代码文件摆放位置：

                app01/
                    __init__.py
                    models.py
                    templatetags/  # 在app01下面新建一个package package
                        __init__.py
                        app01_filters.py  # 建一个存放自定义filter的py文件
                    views.py

            - 编写自定义filter

                from django import template
                register = template.Library()

                @register.filter
                def fill(value, arg):
                    return value.replace(" ", arg)

                @register.filter(name="addSB")
                def add_sb(value):
                    return "{} SB".format(value)

            - 使用自定义filter

                {# 先导入我们自定义filter那个文件 #}
                {% load app01_filters %}

                {# 使用我们自定义的filter #}
                {{ somevariable|fill:"__" }}
                {{ d.name|addSB }}

- tags
    - for
    - if-elif-else
        - 不支持连续判断
        - 不支持算数运行
    - with
    - csrf_token
        - 在表单中添加了一个隐藏的input标签
            - name csrfmiddlewaretoken
            - value asksdasdas(64位)

    - 组件 include
        - 可以将常用的页面内容如导航条，页尾信息等组件保存在单独的文件中，然后在需要使用的地方按如下语法导入即可。
            {% include 'navbar.html' %}

    - 静态文件相关（动态拿取STATIC_URL配置的名字）
        -
            {% load static %}
            <img src="{% static "images/hi.jpg" %}" alt="Hi!" />

            引用JS文件时使用：
            {% load static %}
            <script src="{% static "mytest.js" %}"></script>

            某个文件多处被用到可以存为一个变量
            {% load static %}
            {% static "images/hi.jpg" as myphoto %}
            <img src="{{ myphoto }}"></img>

        - get_static_prefix
            {% load static %}
            <img src="{% get_static_prefix %}images/hi.jpg" alt="Hi!" />

            或者
            {% load static %}
            {% get_static_prefix as STATIC_PREFIX %}

            <img src="{{ STATIC_PREFIX }}images/hi.jpg" alt="Hi!" />
            <img src="{{ STATIC_PREFIX }}images/hi2.jpg" alt="Hello!" />

    - 自定义simple_tag
        和自定义filter类似，只不过接收更灵活的参数。

        定义注册simple_tag
        @register.simple_tag

        @register.simple_tag(name="plus")
        def plus(a, b, c):
            return "{} + {} + {}".format(a, b, c)

        使用自定义simple_tag
        {% load app01_demo %}

        {# simple tag #}
        {% plus "" "" "abc" %}

    - inclusion_tag
        - 多用于返回html代码片段

        - 步骤
            - 在app下创建templatetags的python包
            - 在包下写py文件 mytags
            - 编辑文件
                - from django import template
                - register = template.Library()

            - 定义函数
                - 可接受参数
                - 返回一个字典
            - 函数加装饰器
                - @register.inclusion_tag('result.html')

        示例：

            templatetags/my_inclusion.py

                from django import template

                register = template.Library()

                @register.inclusion_tag('result.html')
                def show_results(n):
                    n = 1 if n < 1 else int(n)
                    data = ["第{}项".format(i) for i in range(1, n+1)]
                    return {"data": data}

            templates/result.html

                <ul>
                  {% for choice in data %}
                    <li>{{ choice }}</li>
                  {% endfor %}
                </ul>

            templates/index.html

                <!DOCTYPE html>
                <html lang="en">
                <head>
                  <meta charset="UTF-8">
                  <meta http-equiv="x-ua-compatible" content="IE=edge">
                  <meta name="viewport" content="width=device-width, initial-scale=1">
                  <title>inclusion_tag test</title>
                </head>
                <body>

                {% load my_inclusion %}

                {% show_results 10 %}
                </body>
                </html>

视图
    - Django的View（视图）
        一个视图函数（类），简称视图，是一个简单的Python 函数（类），它接受Web请求并且返回Web响应。

        响应可以是一张网页的HTML内容，一个重定向，一个404错误，一个XML文档，或者一张图片。

        无论视图本身包含什么逻辑，都要返回响应。代码写在哪里也无所谓，只要它在你当前项目目录下面。
        除此之外没有更多的要求了——可以说“没有什么神奇的地方”。为了将代码放在某处，大家约定成俗将
        视图放置在项目（project）或应用程序（app）目录中的名为views.py的文件中。 

    - 一个简单的视图
        - 下面是一个以HTML文档的形式返回当前日期和时间的视图：

            from django.http import HttpResponse
            import datetime

            def current_datetime(request):
                now = datetime.datetime.now()
                html = "<html><body>It is now %s.</body></html>" % now
                return HttpResponse(html)

            让我们来逐行解释下上面的代码：

            首先，我们从 django.http模块导入了HttpResponse类，以及Python的datetime库。

            接着，我们定义了current_datetime函数。它就是视图函数。每个视图函数都使用HttpRequest对象作为第一个参数，并且通常称之为request。

            注意，视图函数的名称并不重要；不需要用一个统一的命名方式来命名，以便让Django识别它。我们将其命名为current_datetime，是因为这个名称能够比较准确地反映出它实现的功能。

            这个视图会返回一个HttpResponse对象，其中包含生成的响应。每个视图函数都负责返回一个HttpResponse对象。

            Django使用请求和响应对象来通过系统传递状态。

            当浏览器向服务端请求一个页面时，Django创建一个HttpRequest对象，该对象包含关于请求的元数据。然后，Django加载相应的视图，将这个HttpRequest对象作为第一个参数传递给视图函数。

            每个视图负责返回一个HttpResponse对象。

    - CBV和FBV
        - class based view
        - function base view

        我们之前写过的都是基于函数的view，就叫FBV。还可以把view写成基于类的。

        就拿我们之前写过的添加班级为例：

        FBV版：

        # FBV版添加班级
        def add_class(request):
            if request.method == "POST":
                class_name = request.POST.get("class_name")
                models.Classes.objects.create(name=class_name)
                return redirect("/class_list/")
            return render(request, "add_class.html")

        CBV版：

        # CBV版添加班级
        from django.views import View

        class AddClass(View):

            def get(self, request):
                return render(request, "add_class.html")

            def post(self, request):
                class_name = request.POST.get("class_name")
                models.Classes.objects.create(name=class_name)
                return redirect("/class_list/")

        注意：
            使用CBV时，urls.py中也做对应的修改：
            # urls.py中
            url(r'^add_class/$', views.AddClass.as_view()),

    - 给视图加装饰器
        - 使用装饰器装饰FBV
            - FBV本身就是一个函数，所以和给
                def wrapper(func):
                    def inner(*args, **kwargs):
                        start_time = time.time()
                        ret = func(*args, **kwargs)
                        end_time = time.time()
                        print("used:", end_time-start_time)
                        return ret
                    return inner

                # FBV版添加班级
                @wrapper
                def add_class(request):
                    if request.method == "POST":
                        class_name = request.POST.get("class_name")
                        models.Classes.objects.create(name=class_name)
                        return redirect("/class_list/")
                    return render(request, "add_class.html")

        - 使用装饰器装饰CBV
            - 类中的方法与独立函数不完全相同，因此不能直接将函数装饰器应用于类中的方法 ，我们需要先将其转换为方法装饰器。

                Django中提供了method_decorator装饰器用于将函数装饰器转换为方法装饰器。

                # CBV版添加班级
                from django.views import View
                from django.utils.decorators import method_decorator

                class AddClass(View):

                    @method_decorator(wrapper)
                    def get(self, request):
                        return render(request, "add_class.html")

                    def post(self, request):
                        class_name = request.POST.get("class_name")
                        models.Classes.objects.create(name=class_name)
                        return redirect("/class_list/")
            - 扩展
                # 使用CBV时要注意，请求过来后会先执行dispatch()这个方法，如果需要批量对具体的请求处理方法，如get，post等做一些操作的时候，这里我们可以手动改写dispatch方法，这个dispatch方法就和在FBV上加装饰器的效果一样。

                class Login(View):

                    def dispatch(self, request, *args, **kwargs):
                        print('before')
                        obj = super(Login,self).dispatch(request, *args, **kwargs)
                        print('after')
                        return obj

                    def get(self,request):
                        return render(request,'login.html')

                    def post(self,request):
                        print(request.POST.get('user'))
                        return HttpResponse('Login.post')

    - Request对象和Response对象
        - request对象
            - 当一个页面被请求时，Django就会创建一个包含本次请求原信息的HttpRequest对象。
                Django会将这个对象自动传递给响应的视图函数，一般视图函数约定俗成地使用 request 参数承接这个对象。

            - 请求相关的常用值
                path_info     返回用户访问url，不包括域名
                method        请求中使用的HTTP方法的字符串表示，全大写表示。
                GET           包含所有HTTP  GET参数的类字典对象
                POST          包含所有HTTP POST参数的类字典对象
                body          请求体，byte类型 request.POST的数据就是从body里面提取到的

            - 属性
                所有的属性应该被认为是只读的，除非另有说明
                    - request属性相关
                        属性：
                            django将请求报文中的请求行、头部信息、内容主体封装成 HttpRequest 类中的属性。
                            除了特殊说明的之外，其他均为只读的。

                            0.HttpRequest.scheme
                               表示请求方案的字符串（通常为http或https）

                            1.HttpRequest.body

                            　　一个字符串，代表请求报文的主体。在处理非 HTTP 形式的报文时非常有用，例如：二进制图片、XML,Json等。

                            　　但是，如果要处理表单数据的时候，推荐还是使用 HttpRequest.POST 。

                            　　另外，我们还可以用 python 的类文件方法去操作它，详情参考 HttpRequest.read() 。

                            2.HttpRequest.path

                            　　一个字符串，表示请求的路径组件（不含域名）。

                            　　例如："/music/bands/the_beatles/"

                            3.HttpRequest.method

                            　　一个字符串，表示请求使用的HTTP 方法。必须使用大写。

                            　　例如："GET"、"POST"

                            4.HttpRequest.encoding

                            　　一个字符串，表示提交的数据的编码方式（如果为 None 则表示使用 DEFAULT_CHARSET 的设置，默认为 'utf-8'）。
                               这个属性是可写的，你可以修改它来修改访问表单数据使用的编码。
                               接下来对属性的任何访问（例如从 GET 或 POST 中读取数据）将使用新的 encoding 值。
                               如果你知道表单数据的编码不是 DEFAULT_CHARSET ，则使用它。

                            5.HttpRequest.GET 

                            　　一个类似于字典的对象，包含 HTTP GET 的所有参数。详情请参考 QueryDict 对象。

                            6.HttpRequest.POST

                            　　一个类似于字典的对象，如果请求中包含表单数据，则将这些数据封装成 QueryDict 对象。

                            　　POST 请求可以带有空的 POST 字典 —— 如果通过 HTTP POST 方法发送一个表单，但是表单中没有任何的数据，QueryDict 对象依然会被创建。
                               因此，不应该使用 if request.POST  来检查使用的是否是POST 方法；应该使用 if request.method == "POST" 

                            　　另外：如果使用 POST 上传文件的话，文件信息将包含在 FILES 属性中。

                             7.HttpRequest.COOKIES

                            　　一个标准的Python 字典，包含所有的cookie。键和值都为字符串。

                            8.HttpRequest.FILES

                            　　一个类似于字典的对象，包含所有的上传文件信息。
                               FILES 中的每个键为<input type="file" name="" /> 中的name，值则为对应的数据。

                            　　注意，FILES 只有在请求的方法为POST 且提交的<form> 带有enctype="multipart/form-data" 的情况下才会
                               包含数据。否则，FILES 将为一个空的类似于字典的对象。

                            9.HttpRequest.META

                             　　一个标准的Python 字典，包含所有的HTTP 首部。具体的头部信息取决于客户端和服务器，下面是一些示例：

                                CONTENT_LENGTH —— 请求的正文的长度（是一个字符串）。
                                CONTENT_TYPE —— 请求的正文的MIME 类型。
                                HTTP_ACCEPT —— 响应可接收的Content-Type。
                                HTTP_ACCEPT_ENCODING —— 响应可接收的编码。
                                HTTP_ACCEPT_LANGUAGE —— 响应可接收的语言。
                                HTTP_HOST —— 客服端发送的HTTP Host 头部。
                                HTTP_REFERER —— Referring 页面。
                                HTTP_USER_AGENT —— 客户端的user-agent 字符串。
                                QUERY_STRING —— 单个字符串形式的查询字符串（未解析过的形式）。
                                REMOTE_ADDR —— 客户端的IP 地址。
                                REMOTE_HOST —— 客户端的主机名。
                                REMOTE_USER —— 服务器认证后的用户。
                                REQUEST_METHOD —— 一个字符串，例如"GET" 或"POST"。
                                SERVER_NAME —— 服务器的主机名。
                                SERVER_PORT —— 服务器的端口（是一个字符串）。
                             　　从上面可以看到，除 CONTENT_LENGTH 和 CONTENT_TYPE 之外，请求中的任何 HTTP 首部转换为 META 的键时，
                                都会将所有字母大写并将连接符替换为下划线最后加上 HTTP_  前缀。
                                所以，一个叫做 X-Bender 的头部将转换成 META 中的 HTTP_X_BENDER 键。

                            10.HttpRequest.user

                            　　一个 AUTH_USER_MODEL 类型的对象，表示当前登录的用户。

                            　　如果用户当前没有登录，user 将设置为 django.contrib.auth.models.AnonymousUser 的一个实例。你可以通过 is_authenticated() 区分它们。

                                例如：

                                if request.user.is_authenticated():
                                    # Do something for logged-in users.
                                else:
                                    # Do something for anonymous users.

                                 　　user 只有当Django 启用 AuthenticationMiddleware 中间件时才可用。

                                 -------------------------------------------------------------------------------------

                                匿名用户
                                class models.AnonymousUser

                                django.contrib.auth.models.AnonymousUser 类实现了django.contrib.auth.models.User 接口，但具有下面几个不同点：

                                id 永远为None。
                                username 永远为空字符串。
                                get_username() 永远返回空字符串。
                                is_staff 和 is_superuser 永远为False。
                                is_active 永远为 False。
                                groups 和 user_permissions 永远为空。
                                is_anonymous() 返回True 而不是False。
                                is_authenticated() 返回False 而不是True。
                                set_password()、check_password()、save() 和delete() 引发 NotImplementedError。
                                New in Django 1.8:
                                新增 AnonymousUser.get_username() 以更好地模拟 django.contrib.auth.models.User。

                            11.HttpRequest.session

                             　　一个既可读又可写的类似于字典的对象，表示当前的会话。只有当Django 启用会话的支持时才可用。
                                完整的细节参见会话的文档。

                        - 方法
                            - 请求相关方法
                                1.HttpRequest.get_host()

                                　　根据从HTTP_X_FORWARDED_HOST（如果打开 USE_X_FORWARDED_HOST，默认为False）和 HTTP_HOST 头部信息返回请求的原始主机。
                                   如果这两个头部没有提供相应的值，则使用SERVER_NAME 和SERVER_PORT，在PEP 3333 中有详细描述。

                                　　USE_X_FORWARDED_HOST：一个布尔值，用于指定是否优先使用 X-Forwarded-Host 首部，仅在代理设置了该首部的情况下，才可以被使用。

                                　　例如："127.0.0.1:8000"

                                　　注意：当主机位于多个代理后面时，get_host() 方法将会失败。除非使用中间件重写代理的首部。

                                2.HttpRequest.get_full_path()

                                　　返回 path，如果可以将加上查询字符串。

                                　　例如："/music/bands/the_beatles/?print=true"

                                3.HttpRequest.get_signed_cookie(key, default=RAISE_ERROR, salt='', max_age=None)

                                　　返回签名过的Cookie 对应的值，如果签名不再合法则返回django.core.signing.BadSignature。

                                　　如果提供 default 参数，将不会引发异常并返回 default 的值。

                                　　可选参数salt 可以用来对安全密钥强力攻击提供额外的保护。max_age 参数用于检查Cookie 对应的时间戳以确保Cookie 的时间不会超过max_age 秒。

                                        >>> request.get_signed_cookie('name')
                                        'Tony'
                                        >>> request.get_signed_cookie('name', salt='name-salt')
                                        'Tony' # 假设在设置cookie的时候使用的是相同的salt
                                        >>> request.get_signed_cookie('non-existing-cookie')
                                        ...
                                        KeyError: 'non-existing-cookie'    # 没有相应的键时触发异常
                                        >>> request.get_signed_cookie('non-existing-cookie', False)
                                        False
                                        >>> request.get_signed_cookie('cookie-that-was-tampered-with')
                                        ...
                                        BadSignature: ...
                                        >>> request.get_signed_cookie('name', max_age=60)
                                        ...
                                        SignatureExpired: Signature age 1677.3839159 > 60 seconds
                                        >>> request.get_signed_cookie('name', False, max_age=60)
                                        False

                                4.HttpRequest.is_secure()

                                　　如果请求时是安全的，则返回True；即请求通是过 HTTPS 发起的。

                                5.HttpRequest.is_ajax()

                                　　如果请求是通过XMLHttpRequest 发起的，则返回True，方法是检查 HTTP_X_REQUESTED_WITH 相应的首部是否是字符串'XMLHttpRequest'。

                                　　大部分现代的 JavaScript 库都会发送这个头部。如果你编写自己的 XMLHttpRequest 调用（在浏览器端），你必须手工设置这个值来让 is_ajax() 可以工作。

                                　　如果一个响应需要根据请求是否是通过AJAX 发起的，并且你正在使用某种形式的缓存例如Django 的 cache middleware，
                                   你应该使用 vary_on_headers('HTTP_X_REQUESTED_WITH') 装饰你的视图以让响应能够正确地缓存。

                            - 注意：键值对的值是多个的时候,比如checkbox类型的input标签，select标签，需要用：

                                request.POST.getlist("hobby")

        - Response对象
            - 与由Django自动创建的HttpRequest对象相比，HttpResponse对象是我们的职责范围了。我们写的每个视图都需要实例化，填充和返回一个HttpResponse。
                HttpResponse类位于django.http模块中。

            - 使用
                - 传递字符串
                    from django.http import HttpResponse
                    response = HttpResponse("Here's the text of the Web page.")
                    response = HttpResponse("Text only, please.", content_type="text/plain")
                - 设置或删除响应头信息
                    response = HttpResponse()
                    response['Content-Type'] = 'text/html; charset=UTF-8'
                    del response['Content-Type']
            - 属性
                HttpResponse.content：响应内容
                HttpResponse.charset：响应内容的编码
                HttpResponse.status_code：响应的状态码

    - JsonRequest对象
        - JsonResponse是HttpResponse的子类，专门用来生成JSON编码的响应。

            from django.http import JsonResponse

            response = JsonResponse({'foo': 'bar'})
            print(response.content)

            b'{"foo": "bar"}'
            默认只能传递字典类型，如果要传递非字典类型需要设置一下safe关键字参数。

            response = JsonResponse([1, 2, 3], safe=False)

    - Django shortcut functions
        - render()
            结合一个给定的模板和一个给定的上下文字典，并返回一个渲染后的 HttpResponse 对象。

            参数：

            request： 用于生成响应的请求对象。
            template_name：要使用的模板的完整名称，可选的参数
            context：添加到模板上下文的一个字典。默认是一个空字典。如果字典中的某个值是可调用的，视图将在渲染模板之前调用它。
            content_type：生成的文档要使用的MIME类型。默认为 DEFAULT_CONTENT_TYPE 设置的值。默认为'text/html'
            status：响应的状态码。默认为200。
            useing: 用于加载模板的模板引擎的名称。
            一个简单的例子：

            from django.shortcuts import render

            def my_view(request):
                # 视图的代码写在这里
                return render(request, 'myapp/index.html', {'foo': 'bar'})
            上面的代码等于：

            from django.http import HttpResponse
            from django.template import loader

            def my_view(request):
                # 视图代码写在这里
                t = loader.get_template('myapp/index.html')
                c = {'foo': 'bar'}
                return HttpResponse(t.render(c, request))

        - redirect()
                参数可以是：

                一个模型：将调用模型的get_absolute_url() 函数
                一个视图，可以带有参数：将使用urlresolvers.reverse 来反向解析名称
                一个绝对的或相对的URL，将原封不动的作为重定向的位置。
                默认返回一个临时的重定向；传递permanent=True 可以返回一个永久的重定向。

                示例:

                你可以用多种方式使用redirect() 函数。
                传递一个具体的ORM对象（了解即可）
                将调用具体ORM对象的get_absolute_url() 方法来获取重定向的URL：

                from django.shortcuts import redirect
                def my_view(request):
                    ...
                    object = MyModel.objects.get(...)
                    return redirect(object)

                传递一个视图的名称
                def my_view(request):
                    ...
                    return redirect('some-view-name', foo='bar')

                传递要重定向到的一个具体的网址
                def my_view(request):
                    ...
                    return redirect('/some/url/')

                当然也可以是一个完整的网址

                def my_view(request):
                    ...
                    return redirect('http://example.com/')
                默认情况下，redirect() 返回一个临时重定向。以上所有的形式都接收一个permanent 参数；如果设置为True，将返回一个永久的重定向：

                def my_view(request):
                    ...
                    object = MyModel.objects.get(...)
                    return redirect(object, permanent=True)　　
                扩展阅读： 

                临时重定向（响应状态码：302）和永久重定向（响应状态码：301）对普通用户来说是没什么区别的，它主要面向的是搜索引擎的机器人。
                A页面临时重定向到B页面，那搜索引擎收录的就是A页面。
                A页面永久重定向到B页面，那搜索引擎收录的就是B页面。

- 总结
    - CBV 和 FBV
        - class based view
            - 改我的urls用 类名.as_view()
        - function base view

        - CBV流程
            - 定义CBV
                - from djaogo.viwes import View
                - class AddPress(View)
                    def get(self, request, *args, **kwargs):pass
                    def post(self, request, *args, **kwargs):pass
            - 使用
                - 我的urls用 views.类名.as_view()
            - 流程
                - 类名.as_view()  -》 view函数
                - 当请求到来的时候执行view函数
                    - 实例化自己写的类
                        - self = cls(**initkwargs)
                    - self.request = request
                    - 执行self.dispath(request, *args, **kwargs)
                        - 执行父类中的dispatch方法
                            - 判断请求方式是否被运行 http_method_names = []
                                - 允许的情况
                                    - handler = 通过反射获取get post 方法
                                - 不允许的情况
                                    - handler = 不允许的方法 http_method_not_allowed()
                                - handler(request, *args, **kwargs)  # 执行这个handler
                        - 返回HttpResponse对象
                    - 返回HttpResponse对象给Django

            - 给CBV方法加装饰器
                - from django.utils.decorators import method_decorator
                    - 直接在类名上加
                        @method_decorator(timer,name='get')  # 指定类中的具体方法
                        class AddPress(View):pass

                    - 在类中的函数加
                        @method_decorator(timer)  # 直接在方法上写装饰器
                        def get(self, request):pass

                    - 注意：
                        与正常的函数加装饰器不同，给Django中的类加装饰器需要用到Django自己的方法

                - 例子
                    from django.views import View

                    from django.utils.decorators import method_decorator

                    # @method_decorator(timer,name='post')
                    # @method_decorator(timer,name='get')
                    class AddPress(View):
                        # http_method_names = ['get','post']

                        # @method_decorator(timer)
                        def dispatch(self, request, *args, **kwargs):
                            print('执行之前')
                            ret = super().dispatch(request, *args, **kwargs)
                            print('执行之后')
                            return ret

                        # @method_decorator(timer)
                        def get(self, request):
                            print('get')
                            print(self.request)
                            return render(self.request, 'add_press2.html')

                        # @method_decorator(timer)
                        def post(self, request):
                            print('post')
                            press_name = request.POST.get('name')
                            Press.objects.create(name=press_name)
                            return redirect('/press_list/')

            - 给FBV方法加装饰器
                - 普通加法
                @wapper
                def test(req):pass

    - request
        print(request.method)  8种
        print(request.GET)
        print(request.POST)
        print(request.FILES)

        print(request.path_info)  不包括域名端口和参数
        print(request.body)
        print(request.scheme)
        print(request.path)
        print(request.encoding)
        print(request.META)

        print(request.get_host())  域名和端口
        print(request.get_full_path()) 包括参数没有域名
        print(request.is_secure())
        print(request.is_ajax())

    - response
        from django.shortcuts import render, HttpResponse, redirect
            1. HttpResponse    HttpResponse('字符串')
            2. render(request,'html文件名',{})    —— 》 HTML代码
            3. redirect('跳转的地址)   Locationn:跳转的地址
            4. from django.http import JsonResponse
                HttpResponse(json.dumps(ret))  # Content-Type: text/html; charset=utf-8
                ret = {'name': 'ward', 'age': 20}
                JsonResponse(ret)      # Content-Type: application/json

路由
    - URLconf配置
        - 基本格式

            from django.conf.urls import url
            urlpatterns = [
                 url(正则表达式, views视图，参数，别名),
            ]

        - 参数说明
            - 正则表达式：一个正则表达式字符串
            - views视图：一个可调用对象，通常为一个视图函数
            - 参数：可选的要传递给视图函数的默认值参数（字典形式）
            - 别名：一个可选的name参数

            - 实例：
                from django.conf.urls import url
                from . import views

                urlpatterns = [
                    url(r'^articles/2003/$', views.special_case_2003),
                    url(r'^articles/([0-9]{4})/$', views.year_archive),
                    url(r'^articles/([0-9]{4})/([0-9]{2})/$', views.month_archive),
                    url(r'^articles/([0-9]{4})/([0-9]{2})/([0-9]+)/$', views.article_detail),
                ]
    - 正则表达式详解
        - 基本配置
            from django.conf.urls import url

            from . import views

            urlpatterns = [
                url(r'^articles/2003/$', views.special_case_2003),
                url(r'^articles/([0-9]{4})/$', views.year_archive),
                url(r'^articles/([0-9]{4})/([0-9]{2})/$', views.month_archive),
                url(r'^articles/([0-9]{4})/([0-9]{2})/([0-9]+)/$', views.article_detail),
            ]

        - 注意事项
            - urlpatterns中的元素按照书写顺序从上往下逐一匹配正则表达式，一旦匹配成功则不再继续。
            - 若要从URL中捕获一个值，只需要在它周围放置一对圆括号（分组匹配）。
            - 不需要添加一个前导的反斜杠，因为每个URL 都有。例如，应该是^articles 而不是 ^/articles。
            - 每个正则表达式前面的'r' 是可选的但是建议加上。

        - 补充说明
            - # 是否开启URL访问地址后面不为/跳转至带有/的路劲的配置项
            - APPEND_SLASH = True
            - Django settings.py配置文件中默认没有 APPEND_SLASH 这个参数，
              但 Django 默认这个参数为 APPEND_SLASH = True。 其作用就是自动在网址结尾加'/'。
            -
                其效果就是：

                我们定义了urls.py：

                from django.conf.urls import url
                from app01 import views

                urlpatterns = [
                    url(r'^blog/$', views.blog),
                ]
                访问 http://www.example.com/blog 时，默认将网址自动转换为 http://www.example/com/blog/ 。

                如果在settings.py中设置了 APPEND_SLASH=False，此时我们再请求 http://www.example.com/blog 时就会提示找不到页面。

    - 分组命名匹配
        - 上面的示例使用简单的正则表达式分组匹配（通过圆括号）来捕获URL中的值并以位置参数形式传递给视图。
        - 在更高级的用法中，可以使用分组命名匹配的正则表达式组来捕获URL中的值并以关键字参数形式传递给视图。
        - 在Python的正则表达式中，分组命名正则表达式组的语法是(?P<name>pattern)
            其中name是组的名称，pattern是要匹配的模式。

            - 下面是以上URLconf 使用命名组的重写：
                from django.conf.urls import url
                from . import views

                urlpatterns = [
                    url(r'^articles/2003/$', views.special_case_2003),
                    url(r'^articles/(?P<year>[0-9]{4})/$', views.year_archive),
                    url(r'^articles/(?P<year>[0-9]{4})/(?P<month>[0-9]{2})/$', views.month_archive),
                    url(r'^articles/(?P<year>[0-9]{4})/(?P<month>[0-9]{2})/(?P<day>[0-9]{2})/$', views.article_detail),
                ]

                - 这个实现与前面的示例完全相同，只有一个细微的差别：捕获的值作为关键字参数而不是位置参数传递给视图函数。

                    例如，针对URL /articles/2017/12/相当于按以下方式调用视图函数：

                    views.month_archive(request, year="", month="")
                    在实际应用中，使用分组命名匹配的方式可以让你的URLconf更加明晰且不容易产生参数顺序问题的错误，
                    但是有些开发人员则认为分组命名组语法太丑陋、繁琐。至于究竟应该使用哪一种，你可以根据自己的喜好来决定。

        - URLconf匹配的位置
            URLconf在请求的URL上查找，将它当作一个普通的Python字符串。不包括GET和POST参数以及域名
            例如，
                - http://www.example.com/myapp/ 请求中，URLconf 将查找 /myapp/ 。
                - 在http://www.example.com/myapp/?page=3 请求中，URLconf 仍将查找 /myapp/ 。
                - URLconf 不检查请求的方法。换句话讲，所有的请求方法 —— 同一个URL的POST、GET、HEAD等等 —— 都将路由到相同的函数。

        - 捕获的参数永远都是字符串
            - 每个在URLconf中捕获的参数都作为一个普通的Python字符串传递给视图，无论正则表达式使用的是什么匹配方式。
                - 例如，下面这行URLconf 中：
                    url(r'^articles/(?P<year>[0-9]{4})/$', views.year_archive),
                    传递到视图函数views.year_archive() 中的year参数永远是一个字符串类型。

        - 视图函数中指定默认值
            -
                # urls.py中
                from django.conf.urls import url

                from . import views

                urlpatterns = [
                    url(r'^blog/$', views.page),
                    url(r'^blog/page(?P<num>[0-9]+)/$', views.page),
                ]

                # views.py中，可以为num指定默认值
                def page(request, num=""):
                    pass

                在上面的例子中，两个URL模式指向相同的view - views.page - 但是第一个模式并没有从URL中捕获任何东西。
                如果第一个模式匹配上了，page()函数将使用其默认参数num=“1”,如果第二个模式匹配，page()将使用正则表达式捕获到的num值。

        - include其他的URLconfs
            - 路由的分发
                #At any point, your urlpatterns can “include” other URLconf modules. This
                #essentially “roots” a set of URLs below other ones.

                #For example, here’s an excerpt of the URLconf for the Django website itself.
                #It includes a number of other URLconfs:

                from django.conf.urls import include, url

                urlpatterns = [
                   url(r'^admin/', admin.site.urls),
                   url(r'^blog/', include('blog.urls')),  # 可以包含其他的URLconfs文件
                ]

    - 命名URL和URL反向解析
        - 在使用Django 项目时，一个常见的需求是获得URL的最终形式，以用于嵌入到生成的内容中（视图中和显示给用户的URL等）或者用于处理服务器端的导航（重定向等）。
        人们强烈希望不要硬编码这些URL（费力、不可扩展且容易产生错误）或者设计一种与URLconf 毫不相关的专门的URL 生成机制，因为这样容易导致一定程度上产生过期的URL。

        - 换句话讲，需要的是一个DRY 机制。除了其它有点，它还允许设计的URL 可以自动更新而不用遍历项目的源代码来搜索并替换过期的URL。
        - 获取一个URL 最开始想到的信息是处理它视图的标识（例如名字），查找正确的URL 的其它必要的信息有视图参数的类型（位置参数、关键字参数）和值。
        - Django 提供一个办法是让URL 映射是URL 设计唯一的地方。你填充你的URLconf，然后可以双向使用它

        - 根据用户/浏览器发起的URL 请求，它调用正确的Django 视图，并从URL 中提取它的参数需要的值。
        - 根据Django 视图的标识和将要传递给它的参数的值，获取与之关联的URL。

        - 第一种方式是我们在前面的章节中一直讨论的用法。第二种方式叫做反向解析URL、反向URL 匹配、反向URL 查询或者简单的URL 反查。
        - 在需要URL 的地方，对于不同层级，Django 提供不同的工具用于URL 反查
            在模板中：使用url模板标签。
            在Python 代码中：使用django.core.urlresolvers.reverse() 函数。
            在更高层的与处理Django 模型实例相关的代码中：使用get_absolute_url() 方法。
            上面说了一大堆，你可能并没有看懂。（那是官方文档的生硬翻译）。

        - 简单来说就是可以给我们的URL匹配规则起个名字，一个URL匹配模式起一个名字。
        - 这样我们以后就不需要写死URL代码了，只需要通过名字来调用当前的URL。
            - 举个简单的例子：

                url(r'^home', views.home, name='home'),  # 给我的url匹配模式起名为 home
                url(r'^index/(\d*)', views.index, name='index'),  # 给我的url匹配模式起名为index
                这样：
                在模板里面可以这样引用：
                {% url 'home' %}

                在views函数中可以这样引用：
                from django.urls import reverse
                reverse("index", args=("", ))

                例子：
                考虑下面的URLconf：

                from django.conf.urls import url

                from . import views

                urlpatterns = [
                    # ...
                    url(r'^articles/([0-9]{4})/$', views.year_archive, name='news-year-archive'),
                    # ...
                ]

                根据这里的设计，某一年nnnn对应的归档的URL是/articles/nnnn/。

                你可以在模板的代码中使用下面的方法获得它们：

                <a href="{% url 'news-year-archive' 2012 %}">2012 Archive</a>

                <ul>
                {% for yearvar in year_list %}
                <li><a href="{% url 'news-year-archive' yearvar %}">{{ yearvar }} Archive</a></li>
                {% endfor %}
                </ul>

                在Python 代码中，这样使用：

                from django.urls import reverse
                from django.shortcuts import redirect

                def redirect_to_year(request):
                    # ...
                    year = 2006
                    # ...
                    return redirect(reverse('news-year-archive', args=(year,)))

                如果出于某种原因决定按年归档文章发布的URL应该调整一下，那么你将只需要修改URLconf 中的内容。
                在某些场景中，一个视图是通用的，所以在URL 和视图之间存在多对一的关系。对于这些情况，当反查URL 时，只有视图的名字还不够。

                注意：
                为了完成上面例子中的URL 反查，你将需要使用命名的URL 模式。URL 的名称使用的字符串可以包含任何你喜欢的字符。不只限制在合法的Python 名称。
                当命名你的URL 模式时，请确保使用的名称不会与其它应用中名称冲突。如果你的URL 模式叫做comment，而另外一个应用中也有一个同样的名称，当你在模板中使用这个名称的时候不能保证将插入哪个URL。
                在URL 名称中加上一个前缀，比如应用的名称，将减少冲突的可能。我们建议使用myapp-comment 而不是comment。

    - 命名空间模式
        - 即使不同的APP使用相同的URL名称，URL的命名空间模式也可以让你唯一反转命名的URL。

            举个例子：

            project中的urls.py

            from django.conf.urls import url, include

            urlpatterns = [
                url(r'^app01/', include('app01.urls', namespace='app01')),
                url(r'^app02/', include('app02.urls', namespace='app02')),
            ]
            app01中的urls.py

            from django.conf.urls import url
            from app01 import views

            app_name = 'app01'
            urlpatterns = [
                url(r'^(?P<pk>\d+)/$', views.detail, name='detail')
            ]

            app02中的urls.py

            from django.conf.urls import url
            from app02 import views

            app_name = 'app02'
            urlpatterns = [
                url(r'^(?P<pk>\d+)/$', views.detail, name='detail')
            ]

            现在，我的两个app中 url名称重复了，我反转URL的时候就可以通过命名空间的名称得到我当前的URL。

            语法：

            '命名空间名称:URL名称'

            模板中使用：

            {% url 'app01:detail' pk=12 pp=99 %}
            views中的函数中使用

            v = reverse('app01:detail', kwargs={'pk':11})
             这样即使app中URL的命名相同，我也可以反转得到正确的URL了。

    - url命名和反向解析
        1. 命名
            # url(r'^press_list/$', views.press_list,name='press_list'),
            url(r'^pre/$', views.press_list,name='press_list'),  

            分组：
            url(r'^home/([0-9]{4})/([0-9]{2})/$', views.home,name='home'),

            命名分组：
             url(r'^home/(?P<year>[0-9]{4})/(?P<month>[0-9]{2})/$', views.home,name='home'),

        2. 反向解析
            1. 在视图中应用
                from django.urls import  reverse

                reverse('press_list')   ——》 '/press_list/'   '/pre/'

                分组：
                reverse('home',args=('',''))    ——》'/app01/home/2008/09/'

                命名分组：
                reverse('home',args=('',''))    ——》'/app01/home/2008/09/'
                reverse('home',kwargs={'year':'','month':''})

            2. 在模板中的应用

                {% url 'press_list' %}  ——》  '/press_list/'  '/pre/'

                分组：
                {% url 'home' '' '' %}   ——》'/app01/home/2008/10/'

                命名分组：
                {% url 'home' '' '' %}   ——》'/app01/home/2008/10/'
                {% url 'home' month=''  year='' %}   ——》'/app01/home/2018/10/' 

    2. namespace
        url(r'app02/', include('app02.urls',namespace='app02')),
        url(r'app01/',include('app01.urls',namespace='app01')),

        reverse('app01:home',kwargs={'year':'','month':''})
        reverse('app02:home',kwargs={'year':'','month':''})

        {% url 'app02:home' '' ''  %}