06 django视图层

视图层

　　视图就是一个函数，请求过来后要做什么事情都在这个函数里，也就是具体处理请求的功能。

　　熟练掌握两个视图层对象：请求对象(request)和响应对象(HttpResponse)。

HttpRequest对象

from django.shortcuts import render,redirect,HttpResponse
from views_app01.tools import Mysql

# Create your views here.


def index(request):
    return render(request,'index.html',{'word':'嗯哼'})


# HttpRequest对象
def login(request):
    # request属性  django将请求报文中的请求行、首部信息、内容主体封装成 HttpRequest 类中的属性
    # body  是post请求参数，一个字符串，代表请求报文的主体。在处理非 HTTP 形式的报文时非常有用，例如：二进制图片、XML,Json等
    print('request.body:
',request.body)

    # method 请求方式 get post 等
    method = request.method
    print('method:
',method)

    # path  一个字符串，表示请求的路径组件（不含域名）
    print('path:
',request.path)

    # encoding   一个字符串，表示提交的数据的编码方式（如果为 None 则表示使用 DEFAULT_CHARSET 的设置，默认为 'utf-8'）
    # 这个属性是可写的，你可以修改它来修改访问表单数据使用的编码
    print('encoding:
', request.encoding)

    # META  一个标准的Python 字典，包含所有的HTTP 首部。具体的头部信息取决于客户端和服务器
    print('META:
', request.META)
    '''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 键。'''

    # FILES 一个类似于字典的对象，包含所有的上传文件信息
    # FILES 中的每个键为<input type="file" name="" /> 中的name，值则为对应的数据
    # FILES 只有在请求为POST 且提交的<form> 带有enctype="multipart/form-data" 的情况才会包含数据。否则，FILES 将为一个空的类似于字典的对象。
    print('FILES:
', request.FILES)

    # COOKIES  一个标准的Python 字典，包含所有的cookie。键和值都为字符串。
    print('COOKIES:
', request.COOKIES)

    # session 一个既可读又可写的类似于字典的对象，表示当前的会话。只有当Django 启用会话的支持时才可用。
    print('session:
', request.session)

    # user 一个 AUTH_USER_MODEL 类型的对象，表示当前登录的用户
    # 如果用户当前没有登录，user 将设置为 django.contrib.auth.models.AnonymousUser 的一个实例。你可以通过 is_authenticated() 区分它们
    print('user:
', request.user)


    # request方法
    # get_full_path  返回 path，如果可以将加上查询字符串,即get请求后面的查询参数，如：/app01/login/?a=1&b=2。
    print('get_full_path:
',request.get_full_path())

    # is_ajax
    print('is_ajax:
',request.is_ajax())
    '''如果请求是通过XMLHttpRequest 发起的，则返回True，方法是检查 HTTP_X_REQUESTED_WITH 相应的首部是否是字符串'XMLHttpRequest'。
　　大部分现代的 JavaScript 库都会发送这个头部。如果你编写自己的 XMLHttpRequest 调用（在浏览器端），你必须手工设置这个值来让 is_ajax() 可以工作。
　　如果一个响应需要根据请求是否是通过AJAX 发起的，并且你正在使用某种形式的缓存例如Django 的 cache middleware，
   你应该使用 vary_on_headers('HTTP_X_REQUESTED_WITH') 装饰你的视图以让响应能够正确地缓存'''

    if method.lower() == 'post':
        # 如果使用 POST 上传文件的话，文件信息将包含在 FILES 属性中。
        # 注意：键值对的值是多个的时候,比如checkbox类型的input标签，select标签，需要用：request.POST.getlist("hobby")
        req_data = request.POST  # 一个类似于字典的对象，如果请求中包含表单数据，则将这些数据封装成 QueryDict 对象。
        print('request.POST:
',req_data)
        user = req_data.get('user')
        pwd = req_data.get('pwd')
        mysql_check = Mysql('localhost', 3306, 'root', 'root', dbname='oldboy', charset="utf8")
        sql = "select * from user_info WHERE  name=%s and password=%s"
        res = mysql_check.exec_sql(sql, user, pwd)
        if res and isinstance(res,list):
            return render(request, 'index.html')
        else:
            return HttpResponse('username or password is wrong!')
    else:
        print('request.GET:
',request.GET)  # 一个类似于字典的对象，包含 HTTP GET 的所有参数。详情请参考 QueryDict 对象
        return render(request, 'login.html')

HttpResponse 对象

# HttpResponse 对象
#响应对象主要有三种形式：HttpResponse()    render()    redirect()
def regist(request):
    method = request.method
    if method.lower() == 'post':
        req_data = request.POST
        user = req_data.get('user')
        pwd = req_data.get('pwd')
        if user and pwd:
            mysql_check = Mysql('localhost', 3306, 'root', 'root', dbname='oldboy', charset="utf8")
            sql = "select * from user_info WHERE  name=%s"
            res = mysql_check.exec_sql(sql, user)
            if res and isinstance(res,list):
                return HttpResponse('username is already exits!')
            insert_sql = 'insert into user_info (name,password) VALUES (%s,%s) '
            mysql_check.exec_sql(insert_sql, user,pwd)

            # redirect() 重定向
            # return redirect("/app01/index")  # 传递要重定向的一个硬编码的URL
            return redirect("http://127.0.0.1:8080/app01/index/")  # 也可以是一个完整的URL
            '''
            1）301和302的区别。
            　　301和302状态码都表示重定向，就是说浏览器在拿到服务器返回的这个状态码后会自动跳转到一个新的URL地址，这个地址可以从响应的Location首部中获取
              （用户看到的效果就是他输入的地址A瞬间变成了另一个地址B）——这是它们的共同点。
            　　他们的不同在于。301表示旧地址A的资源已经被永久地移除了（这个资源不可访问了），搜索引擎在抓取新内容的同时也将旧的网址交换为重定向之后的网址；
            　　302表示旧地址A的资源还在（仍然可以访问），这个重定向只是临时地从旧地址A跳转到地址B，搜索引擎会抓取新的内容而保存旧的网址。 302好于301
            2）重定向原因：
                （1）网站调整（如改变网页目录结构）；
                （2）网页被移到一个新地址；
                （3）网页扩展名改变(如应用需要把.php改成.Html或.shtml)。
                    这种情况下，如果不做重定向，则用户收藏夹或搜索引擎数据库中旧地址只能让访问客户得到一个404页面错误信息，访问流量白白丧失；
                    再者某些注册了多个域名的网站，也需要通过重定向让访问这些域名的用户自动跳转到主站点等。'''

        # HttpResponse()括号内直接跟一个具体的字符串作为响应体。
        return HttpResponse('username or password can not be empty !')

    # render(request, template_name[, context]）
    # 结合一个给定的模板和一个给定的上下文字典，并返回一个渲染后的 HttpResponse 对象。
    # render方法就是将一个模板页面中的模板语法进行渲染，最终渲染成一个html页面作为响应体
    '''request： 用于生成响应的请求对象。
    template_name：要使用的模板的完整名称，可选的参数
    context：添加到模板上下文的一个字典。默认是一个空字典。如果字典中的某个值是可调用的，视图将在渲染模板之前调用它。'''
    return render(request,'register.html',{'word':'hello world!'})

04 django视图层django_viewsdjango_viewsurls.py

from django.contrib import admin
from django.urls import path,re_path,include

urlpatterns = [
    path('admin/', admin.site.urls),
    re_path(r'^app01/', include(('views_app01.urls','views_app01'))),
]

04 django视图层django_viewsdjango_viewssettings.py

"""
Django settings for django_views project.

Generated by 'django-admin startproject' using Django 2.2.3.

For more information on this file, see
https://docs.djangoproject.com/en/2.2/topics/settings/

For the full list of settings and their values, see
https://docs.djangoproject.com/en/2.2/ref/settings/
"""

import os

# Build paths inside the project like this: os.path.join(BASE_DIR, ...)
BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))


# Quick-start development settings - unsuitable for production
# See https://docs.djangoproject.com/en/2.2/howto/deployment/checklist/

# SECURITY WARNING: keep the secret key used in production secret!
SECRET_KEY = '%ob8cq%r^)u&s@4fgd7qy+5$49ssg%+*-skaddqh1=a+@ypj33'

# SECURITY WARNING: don't run with debug turned on in production!
DEBUG = True

ALLOWED_HOSTS = []


# Application definition

INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'views_app01.apps.ViewsApp01Config',
]

MIDDLEWARE = [
    'django.middleware.security.SecurityMiddleware',
    'django.contrib.sessions.middleware.SessionMiddleware',
    'django.middleware.common.CommonMiddleware',
    # 'django.middleware.csrf.CsrfViewMiddleware',
    'django.contrib.auth.middleware.AuthenticationMiddleware',
    'django.contrib.messages.middleware.MessageMiddleware',
    'django.middleware.clickjacking.XFrameOptionsMiddleware',
]

ROOT_URLCONF = 'django_views.urls'

TEMPLATES = [
    {
        'BACKEND': 'django.template.backends.django.DjangoTemplates',
        'DIRS': [os.path.join(BASE_DIR,  'templates')],
        'APP_DIRS': True,
        'OPTIONS': {
            'context_processors': [
                'django.template.context_processors.debug',
                'django.template.context_processors.request',
                'django.contrib.auth.context_processors.auth',
                'django.contrib.messages.context_processors.messages',
            ],
        },
    },
]

WSGI_APPLICATION = 'django_views.wsgi.application'


# Database
# https://docs.djangoproject.com/en/2.2/ref/settings/#databases

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.sqlite3',
        'NAME': os.path.join(BASE_DIR, 'db.sqlite3'),
    }
}


# Password validation
# https://docs.djangoproject.com/en/2.2/ref/settings/#auth-password-validators

AUTH_PASSWORD_VALIDATORS = [
    {
        'NAME': 'django.contrib.auth.password_validation.UserAttributeSimilarityValidator',
    },
    {
        'NAME': 'django.contrib.auth.password_validation.MinimumLengthValidator',
    },
    {
        'NAME': 'django.contrib.auth.password_validation.CommonPasswordValidator',
    },
    {
        'NAME': 'django.contrib.auth.password_validation.NumericPasswordValidator',
    },
]


# Internationalization
# https://docs.djangoproject.com/en/2.2/topics/i18n/

LANGUAGE_CODE = 'en-us'

TIME_ZONE = 'UTC'

USE_I18N = True

USE_L10N = True

USE_TZ = True


# Static files (CSS, JavaScript, Images)
# https://docs.djangoproject.com/en/2.2/howto/static-files/

STATIC_URL = '/static/'

STATICFILES_DIRS = [
    os.path.join(BASE_DIR,'statics'),  # 指定静态文件地址，所有的静态文件都放这个目录
]

TEMPLATE_DIRS = (os.path.join(BASE_DIR,  'templates'),)

04 django视图层django_viewsviews_app01urls.py

from views_app01 import views
from django.urls import path,re_path


urlpatterns = [
    path('index/', views.index),
    re_path('^login/', views.login, name='log'),
    re_path('^regist/', views.regist, name='reg'),
]

04 django视图层django_viewsviews_app01views.py

from django.shortcuts import render,redirect,HttpResponse
from views_app01.tools import Mysql

# Create your views here.


def index(request):
    return render(request,'index.html',{'word':'嗯哼'})


# HttpRequest对象
def login(request):
    # request属性  django将请求报文中的请求行、首部信息、内容主体封装成 HttpRequest 类中的属性
    # body  是post请求参数，一个字符串，代表请求报文的主体。在处理非 HTTP 形式的报文时非常有用，例如：二进制图片、XML,Json等
    print('request.body:
',request.body)

    # method 请求方式 get post 等
    method = request.method
    print('method:
',method)

    # path  一个字符串，表示请求的路径组件（不含域名）
    print('path:
',request.path)

    # encoding   一个字符串，表示提交的数据的编码方式（如果为 None 则表示使用 DEFAULT_CHARSET 的设置，默认为 'utf-8'）
    # 这个属性是可写的，你可以修改它来修改访问表单数据使用的编码
    print('encoding:
', request.encoding)

    # META  一个标准的Python 字典，包含所有的HTTP 首部。具体的头部信息取决于客户端和服务器
    print('META:
', request.META)
    '''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 键。'''

    # FILES 一个类似于字典的对象，包含所有的上传文件信息
    # FILES 中的每个键为<input type="file" name="" /> 中的name，值则为对应的数据
    # FILES 只有在请求为POST 且提交的<form> 带有enctype="multipart/form-data" 的情况才会包含数据。否则，FILES 将为一个空的类似于字典的对象。
    print('FILES:
', request.FILES)

    # COOKIES  一个标准的Python 字典，包含所有的cookie。键和值都为字符串。
    print('COOKIES:
', request.COOKIES)

    # session 一个既可读又可写的类似于字典的对象，表示当前的会话。只有当Django 启用会话的支持时才可用。
    print('session:
', request.session)

    # user 一个 AUTH_USER_MODEL 类型的对象，表示当前登录的用户
    # 如果用户当前没有登录，user 将设置为 django.contrib.auth.models.AnonymousUser 的一个实例。你可以通过 is_authenticated() 区分它们
    print('user:
', request.user)


    # request方法
    # get_full_path  返回 path，如果可以将加上查询字符串,即get请求后面的查询参数，如：/app01/login/?a=1&b=2。
    print('get_full_path:
',request.get_full_path())

    # is_ajax
    print('is_ajax:
',request.is_ajax())
    '''如果请求是通过XMLHttpRequest 发起的，则返回True，方法是检查 HTTP_X_REQUESTED_WITH 相应的首部是否是字符串'XMLHttpRequest'。
　　大部分现代的 JavaScript 库都会发送这个头部。如果你编写自己的 XMLHttpRequest 调用（在浏览器端），你必须手工设置这个值来让 is_ajax() 可以工作。
　　如果一个响应需要根据请求是否是通过AJAX 发起的，并且你正在使用某种形式的缓存例如Django 的 cache middleware，
   你应该使用 vary_on_headers('HTTP_X_REQUESTED_WITH') 装饰你的视图以让响应能够正确地缓存'''

    if method.lower() == 'post':
        # 如果使用 POST 上传文件的话，文件信息将包含在 FILES 属性中。
        # 注意：键值对的值是多个的时候,比如checkbox类型的input标签，select标签，需要用：request.POST.getlist("hobby")
        req_data = request.POST  # 一个类似于字典的对象，如果请求中包含表单数据，则将这些数据封装成 QueryDict 对象。
        print('request.POST:
',req_data)
        user = req_data.get('user')
        pwd = req_data.get('pwd')
        mysql_check = Mysql('localhost', 3306, 'root', 'root', dbname='oldboy', charset="utf8")
        sql = "select * from user_info WHERE  name=%s and password=%s"
        res = mysql_check.exec_sql(sql, user, pwd)
        if res and isinstance(res,list):
            return render(request, 'index.html')
        else:
            return HttpResponse('username or password is wrong!')
    else:
        print('request.GET:
',request.GET)  # 一个类似于字典的对象，包含 HTTP GET 的所有参数。详情请参考 QueryDict 对象
        return render(request, 'login.html')


# HttpResponse 对象
#响应对象主要有三种形式：HttpResponse()    render()    redirect()
def regist(request):
    method = request.method
    if method.lower() == 'post':
        req_data = request.POST
        user = req_data.get('user')
        pwd = req_data.get('pwd')
        if user and pwd:
            mysql_check = Mysql('localhost', 3306, 'root', 'root', dbname='oldboy', charset="utf8")
            sql = "select * from user_info WHERE  name=%s"
            res = mysql_check.exec_sql(sql, user)
            if res and isinstance(res,list):
                return HttpResponse('username is already exits!')
            insert_sql = 'insert into user_info (name,password) VALUES (%s,%s) '
            mysql_check.exec_sql(insert_sql, user,pwd)

            # redirect() 重定向
            # return redirect("/app01/index")  # 传递要重定向的一个硬编码的URL
            return redirect("http://127.0.0.1:8080/app01/index/")  # 也可以是一个完整的URL
            '''
            1）301和302的区别。
            　　301和302状态码都表示重定向，就是说浏览器在拿到服务器返回的这个状态码后会自动跳转到一个新的URL地址，这个地址可以从响应的Location首部中获取
              （用户看到的效果就是他输入的地址A瞬间变成了另一个地址B）——这是它们的共同点。
            　　他们的不同在于。301表示旧地址A的资源已经被永久地移除了（这个资源不可访问了），搜索引擎在抓取新内容的同时也将旧的网址交换为重定向之后的网址；
            　　302表示旧地址A的资源还在（仍然可以访问），这个重定向只是临时地从旧地址A跳转到地址B，搜索引擎会抓取新的内容而保存旧的网址。 302好于301
            2）重定向原因：
                （1）网站调整（如改变网页目录结构）；
                （2）网页被移到一个新地址；
                （3）网页扩展名改变(如应用需要把.php改成.Html或.shtml)。
                    这种情况下，如果不做重定向，则用户收藏夹或搜索引擎数据库中旧地址只能让访问客户得到一个404页面错误信息，访问流量白白丧失；
                    再者某些注册了多个域名的网站，也需要通过重定向让访问这些域名的用户自动跳转到主站点等。'''

        # HttpResponse()括号内直接跟一个具体的字符串作为响应体。
        return HttpResponse('username or password can not be empty !')

    # render(request, template_name[, context]）
    # 结合一个给定的模板和一个给定的上下文字典，并返回一个渲染后的 HttpResponse 对象。
    # render方法就是将一个模板页面中的模板语法进行渲染，最终渲染成一个html页面作为响应体
    '''request： 用于生成响应的请求对象。
    template_name：要使用的模板的完整名称，可选的参数
    context：添加到模板上下文的一个字典。默认是一个空字典。如果字典中的某个值是可调用的，视图将在渲染模板之前调用它。'''
    return render(request,'register.html',{'word':'hello world!'})

04 django视图层django_viewsviews_app01 ools.py

# -*- coding: utf-8 -*-
# @Time    : 2019/7/16 10:42
# @Author  : Xiao

import pymysql


class Mysql(object):
    def __init__(self, host, port, user, pwd, dbname="", charset="utf8"):
        """初始化数据库信息以及连接"""
        self.host = host
        self.port = port
        self.user = user
        self.pwd = pwd
        self.dbname = dbname
        self.charset = charset
        self.conn = None  # 给析构函数用的，如果存在链接，则需要关闭链接，没有就不用管
        self.conn = self.get_conn
        self.cur = None
        self.cur = self.get_cur

    @property
    def get_conn(self):
        """根据传参判断是否有传数据库名，然后做不同的链接操作"""
        try:
            if self.dbname:
                conn = pymysql.connect(host=self.host, port=self.port, user=self.user,
                                            password=self.pwd, database=self.dbname, charset=self.charset)
                return conn
            else:
                conn = pymysql.connect(host=self.host, port=self.port, user=self.user,
                                            password=self.pwd, charset=self.charset)
                return conn
        except Exception as e:
            print(e)

    @property
    def get_cur(self):
        """获取游标"""
        if self.conn:
            return self.conn.cursor()

    def exec_sql(self, sql, *args):
        """
        执行sql，根据不同的sql语法做不同的操作：
        查询就返回查询结果列表，其他成功就返回受影响的行数整型，报错返回报错信息字符串
        *args是为了防止sql注入，自己拼接的sql语法字符串可能被sql注入,
        这里的用法是sql不需要自己拼接，直接将变量按顺序传进来，pymysql自动拼接，而且避免了sql注入的问题
        如：
        sql = "insert into test.student VALUES (19,%s,'English',%s);"
        res = test_mysql.exec_sql(sql,"yangxga",100)
        """
        try:
            rows = self.cur.execute(sql, args)  # rows记录受影响的行
            if sql.strip().lower().startswith('select') or sql.strip().lower().startswith('show'):
                res = self.cur.fetchall()
                res = self.format_res(res)
                return res
            else:
                self.conn.commit()  # 非查询语句需要提交才能生效
                res = rows
                return res
        except Exception as e:
            print(e)
            return e

    @staticmethod
    def format_res(res):
        """格式化数据库查找到的结果，如果"""
        res_lis = []
        if res:
            for i in res:
                res_lis.append(i)
        return res_lis

    def __del__(self):
        """析构函数，关闭鼠标，断开连接"""
        if self.cur:
            self.cur.close()
        if self.conn:
            self.conn.close()

04 django视图层django_viewstemplatesindex.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>首页</title>
    <style type="text/css">
        h3{
            margin: 10px 12px;
            float: left;
            overflow: hidden;
        }
        button{
            margin: 12px;
            overflow: hidden;
        }
    </style>
</head>
<body>
<h3>欢迎进入首页  {{ word }}</h3>
<button id="btn_reg">注册</button>
<button id="btn_login">登陆</button>
<form action="">
    <img src="/static/index.jpg">
</form>
</body>
<script type="text/javascript">
    window.onload = function () {
        var tmp_reg = document.getElementById('btn_reg');
        var tmp_login = document.getElementById('btn_login');
        tmp_reg.onclick = function () {
            window.open('/app01/regist',target='_self')
        };
        tmp_login.onclick = function () {
            window.open('/app01/login',target='_self')
        }
    }
</script>
</html>

04 django视图层django_viewstemplates egister.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>注册</title>
</head>
<body>
<h3>注册  {{ word }}</h3>
<form action="{% url 'views_app01:reg' %}" method="post">
    <label for="user">用户名：</label>
    <input type="text" name="user" id="user">
    <label for="pwd">密码：</label>
    <input type="password" name="pwd" id="pwd">
    <input type="submit" value="注册">
</form>
</body>
</html>

04 django视图层django_viewstemplateslogin.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>登录</title>
</head>
<body>
<h3>登录</h3>
{#<form action="http://127.0.0.1:8080/app01/login/" method="post">#}
{# "{% url 'log' %}" 模板，log为url控制器里路径的别名#}
{#请求login页面，视图函数已经将 {% url 'log' %} 反向解析为配置的别名所指定的路径，返回的页面实际后台已经处理为如下#}
{#<form action="{% url 'log' %}" method="post">  ----->  <form action="/app01/login/" method="post">#}
<form action="{% url 'views_app01:log' %}" method="post">
    <label for="user">用户名：</label>
    <input type="text" name="user" id="user">
    <label for="pwd">密码：</label>
    <input type="password" name="pwd" id="pwd">
    <input type="submit" value="登录">
</form>
</body>
</html>