4）Django模型，表单，视图，路由
目录
一 Django模型
Django ORM
数据库配置
Django 如何使用 mysql 数据库
实例
定义模型
创建 APP
数据库操作
添加数据
获取数据
更新数据
删除数据
二 Django 表单
HTTP 请求
GET 方法
POST 方法
Request 对象
QueryDict对象
三 Django视图
视图层
请求对象: HttpRequest 对象（简称 request 对象）
1、GET
2、POST
3、body
4、path
5、method
响应对象：HttpResponse 对象
四 Django路由
正则路径中的分组
正则路径中的无名分组
正则路径中的有名分组
正则路径中的有名分组
路由分发(include)
反向解析
普通路径
正则路径（无名分组）
正则路径（有名分组）
命名空间
普通路径
一 Django模型
Django 对各种数据库提供了很好的支持，包括：PostgreSQL、MySQL、SQLite、Oracle。
Django 为这些数据库提供了统一的调用API。 我们可以根据自己业务需求选择不同的数据库。
Django ORM
Django 模型使用自带的 ORM。
对象关系映射（Object Relational Mapping，简称 ORM ）用于实现面向对象编程语言里不同类型系统的数据之间的转换。
ORM 在业务逻辑层和数据库层之间充当了桥梁的作用。
ORM 是通过使用描述对象和数据库之间的映射的元数据，将程序中的对象自动持久化到数据库中。
使用 ORM 的好处：
- 提高开发效率。
- 不同数据库可以平滑切换。
使用 ORM 的缺点：
- ORM 代码转换为 SQL 语句时，需要花费一定的时间，执行效率会有所降低。
- 长期写 ORM 代码，会降低编写 SQL 语句的能力。
ORM 解析过程:
- 1、ORM 会将 Python 代码转成为 SQL 语句。
- 2、SQL 语句通过 pymysql 传送到数据库服务端。
- 3、在数据库中执行 SQL 语句并将结果返回。
ORM 对应关系表：
数据库配置
Django 如何使用 mysql 数据库
创建 MySQL 数据库( ORM 无法操作到数据库级别，只能操作到数据表)语法：
create database 数据库名称 default charset=utf8; # 防止编码问题，指定为 utf8例如我们创建一个名为 runoob 数据库，编码指定为 utf8：
create database runoob default charset=utf8;
我们在项目的 settings.py 文件中找到 DATABASES 配置项，将其信息修改为：
接下来，告诉 Django 使用 pymysql 模块连接 mysql 数据库：
实例
# 在与 settings.py 同级目录下的 __init__.py 中引入模块和进行配置
import pymysql
pymysql.install_as_MySQLdb()
定义模型
创建 APP
Django 规定，如果要使用模型，必须要创建一个 app。我们使用以下命令创建一个 TestModel 的 app:
django-admin startapp TestModel我们修改 TestModel/models.py 文件，代码如下
# models.py
from django.db import models
class Test(models.Model):
name = models.CharField(max_length=20)以上的类名代表了数据库表名，且继承了models.Model，类里面的字段代表数据表中的字段(name)，数据类型则由CharField（相当于varchar）、DateField（相当于datetime）， max_length 参数限定长度。
接下来在 settings.py 中找到INSTALLED_APPS这一项，如下：
在命令行中运行：
$ python manage.py migrate # 创建表结构
$ python manage.py makemigrations TestModel # 让 Django 知道我们在我们的模型有一些变更
$ python manage.py migrate TestModel # 创建表结构表名组成结构为：应用名_类名（如：TestModel_test）。
注意：尽管我们没有在 models 给表设置主键，但是 Django 会自动添加一个 id 作为主键。
数据库操作
接下来我们在 HelloWorld 目录中添加 testdb.py 文件（下面介绍），并修改 urls.py：
urls：
from django.urls import path
from . import views,testdb
urlpatterns = [
path('runoob/', views.runoob),
path('testdb/', testdb.testdb),
]添加数据
添加数据需要先创建对象，然后再执行 save 函数，相当于SQL中的INSERT：
testdb.py
# -*- coding: utf-8 -*-
from django.http import HttpResponse
from TestModel.models import Test
# 数据库操作
def testdb(request):
test1 = Test(name='runoob')
test1.save()
return HttpResponse("数据添加成功！
")
获取数据
Django提供了多种方式来获取数据库的内容，如下代码所示：
testdb.py
# -*- coding: utf-8 -*-
from django.http import HttpResponse
from TestModel.models import Test
# 数据库操作
def testdb(request):
# 初始化
response = ""
response1 = ""
# 通过objects这个模型管理器的all()获得所有数据行，相当于SQL中的SELECT * FROM
list = Test.objects.all()
# filter相当于SQL中的WHERE，可设置条件过滤结果
response2 = Test.objects.filter(id=1)
# 获取单个对象
response3 = Test.objects.get(id=1)
# 限制返回的数据 相当于 SQL 中的 OFFSET 0 LIMIT 2;
Test.objects.order_by('name')[0:2]
#数据排序
Test.objects.order_by("id")
# 上面的方法可以连锁使用
Test.objects.filter(name="runoob").order_by("id")
# 输出所有数据
for var in list:
response1 += var.name + " "
response = response1
return HttpResponse("" + response + "
")更新数据
修改数据可以使用 save() 或 update():
# -*- coding: utf-8 -*-
from django.http import HttpResponse
from TestModel.models import Test
# 数据库操作
def testdb(request):
# 修改其中一个id=1的name字段，再save，相当于SQL中的UPDATE
test1 = Test.objects.get(id=1)
test1.name = 'Google'
test1.save()
# 另外一种方式
#Test.objects.filter(id=1).update(name='Google')
# 修改所有的列
# Test.objects.all().update(name='Google')
return HttpResponse("修改成功
")删除数据
删除数据库中的对象只需调用该对象的delete()方法即可：
# -*- coding: utf-8 -*-
from django.http import HttpResponse
from TestModel.models import Test
# 数据库操作
def testdb(request):
# 删除id=1的数据
test1 = Test.objects.get(id=1)
test1.delete()
# 另外一种方式
# Test.objects.filter(id=1).delete()
# 删除所有数据
# Test.objects.all().delete()
return HttpResponse("删除成功
")详细的orm介绍可去查看另外一篇博客：
2）Django ORM框架_笙念&的博客-CSDN博客_django orm框架ORM意思是对象关系映射，Django ORM描述Django数据模型类和数据库之间的映射关系，通俗来说就是让一个类和一个数据表进行对应，这使得ORM在数据库层和业务逻辑层之间起到了桥梁的作用。https://blog.csdn.net/lclchong/article/details/127659354
二 Django 表单
HTML表单是网站交互性的经典方式。
HTTP 请求
HTTP协议以"请求－回复"的方式工作。客户发送请求时，可以在请求中附加数据。服务器通过解析请求，就可以获得客户传来的数据，并根据URL来提供特定的服务。
GET 方法
我们在之前的项目中创建一个 search.py 文件，用于接收用户的请求：
from django.http import HttpResponse
from django.shortcuts import render
# 表单
def search_form(request):
return render(request, 'search_form.html')
# 接收请求数据
def search(request):
request.encoding='utf-8'
if 'q' in request.GET and request.GET['q']:
message = '你搜索的内容为: ' + request.GET['q']
else:
message = '你提交了空表单'
return HttpResponse(message)在模板目录 templates 中添加 search_form.html 表单：
菜鸟教程(runoob.com)
urls.py 规则修改为如下形式：
from django.conf.urls import url
from . import views,testdb,search
urlpatterns = [
url(r'^hello/$', views.runoob),
url(r'^testdb/$', testdb.testdb),
url(r'^search-form/$', search.search_form),
url(r'^search/$', search.search),
]
POST 方法
上面我们使用了 GET 方法，视图显示和请求处理分成两个函数处理。
提交数据时更常用 POST 方法。我们下面使用该方法，并用一个URL和处理函数，同时显示视图和处理请求。
我们在 templates 创建 post.html：
菜鸟教程(runoob.com)
{{ rlt }}
在模板的末尾，我们增加一个 rlt 记号，为表格处理结果预留位置。
表格后面还有一个 {% csrf_token %} 的标签。csrf 全称是 Cross Site Request Forgery。这是 Django 提供的防止伪装提交请求的功能。POST 方法提交的表格，必须有此标签。
在HelloWorld目录下新建 search2.py 文件并使用 search_post 函数来处理 POST 请求：
# -*- coding: utf-8 -*-
from django.shortcuts import render
from django.views.decorators import csrf
# 接收POST请求数据
def search_post(request):
ctx ={}
if request.POST:
ctx['rlt'] = request.POST['q']
return render(request, "post.html", ctx)urls.py 规则修改为如下形式：
from django.conf.urls import url
from . import views,testdb,search,search2
urlpatterns = [
url(r'^hello/$', views.hello),
url(r'^testdb/$', testdb.testdb),
url(r'^search-form/$', search.search_form),
url(r'^search/$', search.search),
url(r'^search-post/$', search2.search_post),
]
Request 对象
每个视图函数的第一个参数是一个 HttpRequest 对象，就像下面这个 runoob() 函数
from django.http import HttpResponse
def runoob(request):
return HttpResponse("Hello world")
HttpRequest对象包含当前请求URL的一些信息：
Request对象也有一些有用的方法：
QueryDict对象
在HttpRequest对象中, GET和POST属性是django.http.QueryDict类的实例。
QueryDict类似字典的自定义类，用来处理单键对应多值的情况。
QueryDict实现所有标准的词典方法。还包括一些特有的方法：
三 Django视图
视图层
一个视图函数，简称视图，是一个简单的 Python 函数，它接受 Web 请求并且返回 Web 响应。
响应可以是一个 HTML 页面、一个 404 错误页面、重定向页面、XML 文档、或者一张图片...
无论视图本身包含什么逻辑，都要返回响应。代码写在哪里都可以，只要在 Python 目录下面，一般放在项目的 views.py 文件中。
每个视图函数都负责返回一个 HttpResponse 对象，对象中包含生成的响应。
视图层中有两个重要的对象：请求对象(request)与响应对象(HttpResponse)。
请求对象: HttpRequest 对象（简称 request 对象）
以下介绍几个常用的 request 属性。
1、GET
数据类型是 QueryDict，一个类似于字典的对象，包含 HTTP GET 的所有参数。
有相同的键，就把所有的值放到对应的列表里。
取值格式：对象.方法。
get()：返回字符串，如果该键对应有多个值，取出该键的最后一个值。
实例
def runoob(request):
name = request.GET.get("name")
return HttpResponse('姓名：{}'.format(name))
2、POST
数据类型是 QueryDict，一个类似于字典的对象，包含 HTTP POST 的所有参数。
常用于 form 表单，form 表单里的标签 name 属性对应参数的键，value 属性对应参数的值。
取值格式： 对象.方法。
get()：返回字符串，如果该键对应有多个值，取出该键的最后一个值。
实例
def runoob(request):
name = request.POST.get("name")
return HttpResponse('姓名：{}'.format(name))
3、body
数据类型是二进制字节流，是原生请求体里的参数内容，在 HTTP 中用于 POST，因为 GET 没有请求体。
在 HTTP 中不常用，而在处理非 HTTP 形式的报文时非常有用，例如：二进制图片、XML、Json 等。
实例
def runoob(request):
name = request.body
print(name)
return HttpResponse("菜鸟教程")
4、path
获取 URL 中的路径部分，数据类型是字符串。
实例
def runoob(request):
name = request.path
print(name)
return HttpResponse("菜鸟教程")
5、method
获取当前请求的方式，数据类型是字符串，且结果为大写。
实例
def runoob(request):
name = request.method
print(name)
return HttpResponse("菜鸟教程")
响应对象：HttpResponse 对象
响应对象主要有三种形式：HttpResponse()、render()、redirect()。
HttpResponse(): 返回文本，参数为字符串，字符串中写文本内容。如果参数为字符串里含有 html 标签，也可以渲染。
实例
def runoob(request):
# return HttpResponse("菜鸟教程")
return HttpResponse("菜鸟教程")
render(): 返回文本，第一个参数为 request，第二个参数为字符串（页面名称），第三个参数为字典（可选参数，向页面传递的参数：键为页面参数名，值为views参数名）。
实例
def runoob(request):
name ="菜鸟教程"
return render(request,"runoob.html",{"name":name})
redirect()：重定向，跳转新页面。参数为字符串，字符串中填写页面路径。一般用于 form 表单提交后，跳转到新页面。
实例
def runoob(request):
return redirect("/index/")
render 和 redirect 是在 HttpResponse 的基础上进行了封装：
- render：底层返回的也是 HttpResponse 对象
- redirect：底层继承的是 HttpResponse 对象
四 Django路由
路由简单的来说就是根据用户请求的 URL 链接来判断对应的处理程序，并返回处理结果，也就是 URL 与 Django 的视图建立映射关系。
Django 路由在 urls.py 配置，urls.py 中的每一条配置对应相应的处理方法。
- path：用于普通路径，不需要自己手动添加正则首位限制符号，底层已经添加。
- re_path：用于正则路径，需要自己手动添加正则首位限制符号。
实例
from django.urls import re_path # 用re_path 需要引入
urlpatterns = [
path('admin/', admin.site.urls),
path('index/', views.index), # 普通路径
re_path(r'^articles/([0-9]{4})/$', views.articles), # 正则路径
]
正则路径中的分组
正则路径中的无名分组
无名分组按位置传参，一一对应。
views 中除了 request，其他形参的数量要与 urls 中的分组数量一致。
urls：
#urls.py
urlpatterns = [
path('admin/', admin.site.urls),
re_path("^index/([0-9]{4})/$", views.index),
]views：
from django.shortcuts import HttpResponse
def index(request, year):
print(year) # 一个形参代表路径中一个分组的内容，按顺序匹配
return HttpResponse('菜鸟教程')
正则路径中的有名分组
语法：
(?P<组名>正则表达式)
有名分组按关键字传参，与位置顺序无关。
views 中除了 request，其他形参的数量要与 urls 中的分组数量一致， 并且 views 中的形参名称要与 urls 中的组名对应。
urls：
urlpatterns = [
path('admin/', admin.site.urls),
re_path("^index/(?P[0-9]{4})/(?P[0-9]{2})/$", views.index),
]views：
from django.shortcuts import HttpResponse
def index(request, year, month):
print(year,month) # 一个形参代表路径中一个分组的内容，按关键字对应匹配
return HttpResponse('菜鸟教程')
正则路径中的有名分组
路由分发(include)
存在问题：Django 项目里多个app目录共用一个 urls 容易造成混淆，后期维护也不方便。
解决：使用路由分发（include），让每个app目录都单独拥有自己的 urls。
步骤：
- 1、在每个 app 目录里都创建一个 urls.py 文件。
- 2、在项目名称目录下的 urls 文件里，统一将路径分发给各个 app 目录。
实例
from django.contrib import admin
from django.urls import path,include # 从 django.urls 引入 include
urlpatterns = [
path('admin/', admin.site.urls),
path("app01/", include("app01.urls")),
path("app02/", include("app02.urls")),
]
在各自 app 目录下，写自己的 urls.py 文件，进行路径跳转。
app01 目录:
from django.urls import path,re_path
from app01 import views # 从自己的 app 目录引入 views
urlpatterns = [
re_path(r'^login/(?P[0-9]{2})/$', views.index, ),
] app02 目录:
from django.urls import path,re_path
from app02 import views # 从自己的 app 目录引入views
urlpatterns = [
re_path("^xxx/(?P[0-9]{4})/$", views.xxx),
]
反向解析
随着功能的增加，路由层的 url 发生变化，就需要去更改对应的视图层和模板层的 url，非常麻烦，不便维护。
这时我们可以利用反向解析，当路由层 url 发生改变，在视图层和模板层动态反向解析出更改后的 url，免去修改的操作。
反向解析一般用在模板中的超链接及视图中的重定向。
普通路径
在 urls.py 中给路由起别名，name="路由别名"。
path("login1/", views.login, name="login")
在 views.py 中，从 django.urls 中引入 reverse，利用 reverse("路由别名") 反向解析:
return redirect(reverse("login"))
在模板 templates 中的 HTML 文件中，利用 {% url "路由别名" %} 反向解析。
正则路径（无名分组）
在 urls.py 中给路由起别名，name="路由别名"。
re_path(r"^login/([0-9]{2})/$", views.login, name="login")
在 views.py 中，从 django.urls 中引入 reverse，利用 reverse("路由别名"，args=(符合正则匹配的参数,)) 反向解析。
return redirect(reverse("login",args=(10,)))
在模板 templates 中的 HTML 文件中利用 {% url "路由别名" 符合正则匹配的参数 %} 反向解析。
正则路径（有名分组）
在 urls.py 中给路由起别名，name="路由别名"。
re_path(r"^login/(?P[0-9]{4})/$", views.login, name="login")
在 views.py 中，从 django.urls 中引入 reverse，利用 reverse("路由别名"，kwargs={"分组名":符合正则匹配的参数}) 反向解析。
return redirect(reverse("login",kwargs={"year":3333}))
在模板 templates 中的 HTML 文件中，利用 {% url "路由别名" 分组名=符合正则匹配的参数 %} 反向解析。
命名空间
命名空间（英语：Namespace）是表示标识符的可见范围。
一个标识符可在多个命名空间中定义，它在不同命名空间中的含义是互不相干的。
一个新的命名空间中可定义任何标识符，它们不会与任何重复的标识符发生冲突，因为重复的定义都处于其它命名空间中。
存在问题：路由别名 name 没有作用域，Django 在反向解析 URL 时，会在项目全局顺序搜索，当查找到第一个路由别名 name 指定 URL 时，立即返回。当在不同的 app 目录下的urls 中定义相同的路由别名 name 时，可能会导致 URL 反向解析错误。
解决：使用命名空间。
普通路径
定义命名空间（include 里面是一个元组）格式如下：
include(("app名称：urls"，"app名称"))
实例：
path("app01/", include(("app01.urls","app01")))
path("app02/", include(("app02.urls","app02")))
在 app01/urls.py 中起相同的路由别名。
在 views.py 中使用名称空间，语法格式如下：
reverse("app名称：路由别名")
实例：
在 templates 模板的 HTML 文件中使用名称空间，语法格式如下：
{% url "app名称：路由别名" %}
实例：
