一 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("<p>数据添加成功！</p>")

获取数据

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("<p>" + response + "</p>")

更新数据

修改数据可以使用 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("<p>修改成功</p>")

删除数据

删除数据库中的对象只需调用该对象的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("<p>删除成功</p>")

详细的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 表单：

<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>菜鸟教程(runoob.com)</title>
</head>
<body>
    <form action="/search/" method="get">
        <input type="text" name="q">
        <input type="submit" value="搜索">
    </form>
</body>
</html>

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：

<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>菜鸟教程(runoob.com)</title>
</head>
<body>
    <form action="/search-post/" method="post">
        {% csrf_token %}
        <input type="text" name="q">
        <input type="submit" value="搜索">
    </form>
 
    <p>{{ rlt }}</p>
</body>
</html>

在模板的末尾，我们增加一个 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("<a href='https://www.runoob.com/'>菜鸟教程</a>")

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<m>[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 "路由别名" %} 反向解析。

<form action="{% url 'login' %}" method="post">

正则路径（无名分组）

在 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 "路由别名" 符合正则匹配的参数 %} 反向解析。

<form action="{% url 'login' 10 %}" method="post">

正则路径（有名分组）

在 urls.py 中给路由起别名，name="路由别名"。

re_path(r"^login/(?P<year>[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名称：路由别名" %}

实例：

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)

反向解析

普通路径

正则路径（无名分组）

正则路径（有名分组）

命名空间

普通路径

相关文章