Django教程

Django简介

基本介绍

Django 是一个由 Python 编写的一个开放源代码的 Web 应用框架。

使用 Django，只要编写少量的代码，Python 的程序开发人员就可以轻松地完成一个正式网站所需要的大部分内容，并进一步开发出全功能的 Web 服务 Django 本身基于 MVC 模型，即 Model（模型）+ View（视图）+ Controller（控制器）设计模式，MVC 模式使后续对程序的修改和扩展简化，并且使程序某一部分的重复利用成为可能。

Django特点

• 强大的数据库功能
  拥有强大的数据库操作接口（QuerySet API），如需要也能执行原生SQL。
• 自带强大后台
  几行简单的代码就让你的网站拥有一个强大的后台，轻松管理内容！
• 优雅的网址
  用正则匹配网址，传递到对应函数，随意定义，如你所想！
• 模板系统
  强大，易扩展的模板系统，设计简易，代码，样式分开设计，更容易管理。
  注：前后端分离时，也可以用Django开发API，完全不用模板系统。
• 缓存系统
  与Memcache, Redis等缓存系统联用，更出色的表现，更快的加载速度。
• 国际化
  完全支持多语言应用，允许你定义翻译的字符，轻松翻译成不同国家的语言。

MVC 优势

• 开发快捷
• 低耦合
• 部署方便
• 可重用性高
• 维护成本低

MVC 与 MTV模型

MVC 模型
MVC 模式（Model–view–controller）是软件工程中的一种软件架构模式，把软件系统分为三个基本部分：模型（Model）、视图（View）和控制器（Controller）。

MVC 以一种插件式的、松耦合的方式连接在一起。

• 模型（M）- 编写程序应有的功能，负责业务对象与数据库的映射(ORM)。
• 视图（V）- 图形界面，负责与用户的交互(页面)。
• 控制器（C）- 负责转发请求，对请求进行处理。

简易图：

用户操作流程图：

MTV 模型

Django 的 MTV 模式本质上和 MVC 是一样的，也是为了各组件间保持松耦合关系，只是定义上有些许不同，Django 的 MTV 分别是指：

• M 表示模型（Model）：编写程序应有的功能，负责业务对象与数据库的映射(ORM)。
• T 表示模板 (Template)：负责如何把页面(html)展示给用户。
• V 表示视图（View）：负责业务逻辑，并在适当时候调用 Model和 Template。

除了以上三层之外，还需要一个 URL 分发器，它的作用是将一个个 URL 的页面请求分发给不同的 View 处理，View 再调用相应的 Model 和 Template，MTV 的响应模式如下所示：

简易图：

用户操作流程图：

解析：
用户通过浏览器向我们的服务器发起一个请求(request)，这个请求会去访问视图函数：

• 如果不涉及到数据调用，那么这个时候视图函数直接返回一个模板也就是一个网页给用户。
• 如果涉及到数据调用，那么视图函数调用模型，模型去数据库查找数据，然后逐级返回。

视图函数把返回的数据填充到模板中，最后返回网页给用户。

Django 版本对应的 Python 版本：

Django 版本	Python 版本
1.8	2.7, 3.2 , 3.3, 3.4, 3.5
1.9, 1.10	2.7, 3.4, 3.5
1.11	2.7, 3.4, 3.5, 3.6
2.0	3.4, 3.5, 3.6, 3.7
2.1, 2.2	3.5, 3.6, 3.7

Django安装

在安装 Django 前，系统需要已经安装了Python的开发环境。接下来我们来具体看下不同系统下Django的安装。

Window 下安装 Django

如果你还未安装Python环境需要先下载Python安装包。

1. Python 下载地址：https://www.python.org/downloads/
2. Django 下载地址：https://www.djangoproject.com/download/

注意：目前 Django 1.6.x 以上版本已经完全兼容 Python 3.x。

Python 安装(已安装的可跳过)

安装 Python 你只需要下载 python-x.x.x.msi 文件，然后一直点击 “Next” 按钮即可。

安装完成后你需要设置 Python 环境变量。 右击计算机->属性->高级->环境变量->修改系统变量 path，添加 Python 安装地址

Django 安装

下载 Django 压缩包，解压并和 Python安装目录放在同一个根目录，进入 Django 目录，执行 python setup.py install，然后开始安装，Django 将要被安装到 Python 的 Lib下site-packages。

然后是配置环境变量，将这几个目录添加到系统环境变量中, 添加完成后就可以使用Django的django-admin.py命令新建工程了。

检查是否安装成功

输入以下命令进行检查:

>>> import django
>>> django.get_version()

如果输出了Django的版本号说明安装正确。

Linux 上安装 Django

yum 安装方法

以下安装位于 Centos Linux 环境下安装，如果是你的 Linux 系统是 ubuntu 请使用 apt-get 命令。
默认情况下 Linux 环境已经支持了Python。你可以在终端输入Python命令来查看是否已经安装。

Python 3.7.6 (default, Aug  1 2012, 05:14:39) 
[GCC 4.6.3] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> 

安装 setuptools

命令：

yum install python-setuptools

完成之后，就可以使用 easy_install 命令安装 django

easy_install django

之后我们在 Python 解释器输入以下代码：

$ python
Python 3.7.6 (default, May 15 2014, 14:49:08)
[GCC 4.8.0] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> import django
>>> django.VERSION
(2, 2, 12, 'final', 0)

我们可以看到输出了Django的版本号，说明安装成功。

pip 命令安装方法

如果你还未安装 pip 工具，可查看：Python pip 安装与使用。

sudo pip3 install Django

指定 Django 的下载版本（2.2.12 可以改成你要的版本）：

sudo pip3 install Django==2.2.12 

如果 pip < 1.4，安装方法如下：

pip install https://www.djangoproject.com/download/1.11a1/tarball/

源码安装方法

下载源码包：https://www.djangoproject.com/download/
输入以下命令并安装：

tar xzvf Django-X.Y.tar.gz    # 解压下载包
cd Django-X.Y                 # 进入 Django 目录
python setup.py install       # 执行安装命令

安装成功后 Django 位于 Python 安装目录的 site-packages 目录下。

创建Django项目

我们将介绍Django 管理工具及如何使用 Django 来创建项目，第一个项目我们以 HelloWorld 来命令项目。

版本说明：

• Python 3.6.10
• Django 2.2.12

Django 管理工具

安装 Django 之后，您现在应该已经有了可用的管理工具 django-admin.py。我们可以使用 django-admin.py 来创建一个项目:

我们可以来看下django-admin 的命令介绍:

$ django-admin.py

Type 'django-admin help <subcommand>' for help on a specific subcommand.

Available subcommands:

[django]
    check
    compilemessages
    createcachetable
    dbshell
    diffsettings
    dumpdata
    flush
    inspectdb
    loaddata
    makemessages
    makemigrations
    migrate
    runserver
    sendtestemail
    shell
    showmigrations
    sqlflush
    sqlmigrate
    sqlsequencereset
    squashmigrations
    startapp
    startproject
    test
    testserver
……省略部分……

创建python虚拟环境

在命令行输入如下命令创建python虚拟环境：

$ python3 -m venv venv3

进入虚拟环境：

$ source venv3/bin/activate

退出虚拟环境：

$ deactivate

虚拟环境安装Django:

$ pip install django==2.2.12

创建第一个项目

使用 django-admin.py 来创建 HelloWorld 项目：

django-admin.py startproject HelloWorld

创建完成后我们可以查看下项目的目录结构：

$ cd HelloWorld/
$ tree
HelloWorld/
├── HelloWorld
│   ├── __init__.py
│   ├── settings.py
│   ├── urls.py
│   └── wsgi.py
└── manage.py

目录说明：

• HelloWorld: 项目的容器。
• manage.py: 一个实用的命令行工具，可让你以各种方式与该 Django 项目进行交互。
• HelloWorld/init.py: 一个空文件，告诉 Python 该目录是一个 Python 包。
• HelloWorld/settings.py: 该 Django 项目的设置/配置。
• HelloWorld/urls.py: 该 Django 项目的 URL 声明; 一份由 Django 驱动的网站"目录"。
• HelloWorld/wsgi.py: 一个 WSGI 兼容的 Web 服务器的入口，以便运行你的项目。

接下来我们进入 HelloWorld 目录输入以下命令，启动服务器：

python manage.py runserver 0.0.0.0:8000

0.0.0.0 让其它电脑可连接到开发服务器，8000 为端口号。如果不说明，那么端口号默认为 8000。
在浏览器输入你服务器的 ip（这里我们输入本机 IP 地址： 127.0.0.1:8000） 及端口号，如果正常启动，输出结果如下：

创建应用

在先前创建的 HelloWorld 目录下的 HelloWorld 目录新建一个应用：

python manage.py startapp app01

目录结构如下：

Django 路由

路由简单的来说就是根据用户请求的 URL 链接来判断对应的处理程序，并返回处理结果，也就是 URL 与 Django 的视图建立映射关系。
Django 路由在 urls.py 配置，urls.py 中的每一条配置对应相应的处理方法。
Django 不同版本 urls.py 配置有点不一样：

Django1.1.x 版本

url() 方法：普通路径和正则路径均可使用，需要自己手动添加正则首位限制符号。

from django.conf.urls import url # 用 url 需要引入

urlpatterns = [
    url(r'^admin/$', admin.site.urls),
    url(r'^index/$', views.index), # 普通路径
    url(r'^articles/([0-9]{4})/$', views.articles), # 正则路径
]

Django 2.2.x 之后的版本

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), # 正则路径
]

总结：Django1.1.x 版本中的 url 和 Django 2.2.x 版本中的 re_path 用法相同。

视图和 URL 配置

在创建的 app01 目录下 views.py 文件输入如下代码：

from django.http import HttpResponse
 
def hello(request):
    return HttpResponse("Hello world ! ")

接着，绑定 URL 与视图函数。修改HelloWorld目录下的urls.py 文件：

from django.contrib import admin
from django.urls import path
from app01.views import hello   # 引入app01下的视图函数

urlpatterns = [
    path('admin/', admin.site.urls),
    path('', hello),  #添加访问路径
]

完成后，启动 Django 开发服务器，并在浏览器访问打开浏览器并访问：

注意：项目中如果代码有改动，服务器会自动监测代码的改动并自动重新载入，所以如果你已经启动了服务器则不需手动重启。

path() 函数

Django path() 可以接收四个参数，分别是两个必选参数：route、view 和两个可选参数：kwargs、name。

语法格式：

path(route, view, kwargs=None, name=None)

• route: 字符串，表示 URL 规则，与之匹配的 URL 会执行对应的第二个参数 view。
• view: 用于执行与正则表达式匹配的 URL 请求。
• kwargs: 视图使用的字典类型的参数。
• name: 用来反向获取 URL。

Django2. 0中可以使用 re_path() 方法来兼容 1.x 版本中的 url() 方法，一些正则表达式的规则也可以通过 re_path() 来实现 。

from django.urls import include, re_path

urlpatterns = [
    re_path(r'^index/$', views.index, name='index'),
    re_path(r'^bio/(?P<username>\w+)/$', views.bio, name='bio'),
    re_path(r'^weblog/', include('blog.urls')),
    ...
]

正则路径中的分组

正则路径中的无名分组
无名分组按位置传参，一一对应。

views 中除了 request，其他形参的数量要与 urls 中的分组数量一致。

urlpatterns = [
    path('admin/', admin.site.urls),
    re_path("^index/([0-9]{4})/$", views.index),
]

from django.shortcuts import HttpResponse

def index(request，year):
    print(year) # 一个形参代表路径中一个分组的内容，按顺序匹配
    return HttpResponse('Django教程')

正则路径中的有名分组

语法：

(?P<组名>正则表达式)

有名分组按关键字传参，与位置顺序无关。
views 中除了 request，其他形参的数量要与 urls 中的分组数量一致， 并且 views 中的形参名称要与 urls 中的组名对应。

urlpatterns = [
    path('admin/', admin.site.urls),
    re_path("^index/(?P<year>[0-9]{4})/(?P<month>[0-9]{2})/$", views.index),
]

from django.shortcuts import HttpResponse
def index(request, year, month):
    print(year,month) # 一个形参代表路径中一个分组的内容，按关键字对应匹配
    return HttpResponse('Django教程')

路由分发(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'^xxx/(?P<m>[0-9]{2})/$', views.xxx),
] 

app02 目录:

from django.urls import path,re_path
from app02 import views # 从自己的 app 目录引入views 
urlpatterns = [ 
    re_path("^xxx/(?P<n>[0-9]{4})/$", views.xxx), 
]

在各自 app 目录下的 views.py 文件中写各自的视图函数。

Django 模板

本章为大家介绍 Django 模板的应用，模板是一个文本，用于分离文档的表现形式和内容。

模板应用实例

我们接着上一章节的项目将在 HelloWorld 目录底下创建 templates 目录并建立 hello.html文件，整个目录结构如下：

hello.html 文件代码如下：

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Hello</title>
</head>
<body>
    <h1>{{ hello }}</h1>
</body>
</html>

从模板中我们知道变量使用了双括号。
接下来我们需要向Django说明模板文件的路径，修改HelloWorld/settings.py，修改 TEMPLATES 中的 DIRS 为 [BASE_DIR+"/templates",]，如下所示:

...
TEMPLATES = [
    {
        'BACKEND': 'django.template.backends.django.DjangoTemplates',
        'DIRS': [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',
            ],
        },
    },
]
...

我们现在修改 views.py，增加一个新的视图函数，用于向模板提交数据：

from django.http import HttpResponse
from django.shortcuts import render


def hello(request):
    return HttpResponse("Hello world!")


def hello2(request):
    return render(request, 'app01/hello.html', {'hello': 'HelloWorld!'})

修改HelloWorld/HelloWorld/urls.py 文件代码如下：

from django.contrib import admin
from django.urls import path
from app01.views import hello, hello2

urlpatterns = [
    path('admin/', admin.site.urls),
    path('', hello),
    path('hello2/', hello2),
]

可以看到，我们这里使用 render 来替代之前使用的 HttpResponse。render 还使用了一个字典作为参数。字典中元素的键值 hello 对应了模板中的变量 {{ hello }}。
再次访问 http://127.0.0.1:8000/hello2，可以看到页面：

这样我们就完成了使用模板来输出数据，从而实现数据与视图分离。

Django 模型

Django 对各种数据库提供了很好的支持，包括：PostgreSQL、MySQL、SQLite、Oracle。
Django 为这些数据库提供了统一的调用API。 我们可以根据自己业务需求选择不同的数据库。
MySQL 是 Web 应用中最常用的数据库。本章节我们将以 Mysql 作为实例进行介绍。
如果你没安装 mysql 驱动，可以执行以下命令安装：

pip install mysqlclient

Django ORM

Django 模型使用自带的 ORM。
对象关系映射（Object Relational Mapping，简称 ORM ）用于实现面向对象编程语言里不同类型系统的数据之间的转换。
ORM 在业务逻辑层和数据库层之间充当了桥梁的作用。
ORM 是通过使用描述对象和数据库之间的映射的元数据，将程序中的对象自动持久化到数据库中。

使用 ORM 的好处：

• 提高开发效率。
• 不同数据库可以平滑切换。

ORM 解析过程:

1. ORM 会将 Python 代码转成为 SQL 语句。
2. SQL 语句通过 pymysql 传送到数据库服务端。
3. 在数据库中执行 SQL 语句并将结果返回。

ORM 对应关系表：

数据库配置

Django 如何使用 mysql 数据库

创建 MySQL 数据库( ORM 无法操作到数据库级别，只能操作到数据表)语法：

create database 数据库名称 default charset=utf8; # 防止编码问题，指定为 utf8

例如创建 hello 数据库，编码指定为 utf8：

create database hello default charset=utf8;   

我们在项目的 settings.py 文件中找到 DATABASES 配置项，将其信息修改为：

DATABASES = { 
    'default': 
    { 
        'ENGINE': 'django.db.backends.mysql',    # 数据库引擎
        'NAME': 'hello', # 数据库名称
        'HOST': '192.168.10.36', # 数据库地址，本机 ip 地址 192.168.10.36 
        'PORT': 3306, # 端口 
        'USER': 'root',  # 数据库用户名
        'PASSWORD': 'qj12345678@', # 数据库密码
    }  
}

如果你使用了 Python2.x 版本这里添加了中文注释，所以你需要在 HelloWorld/settings.py 文件头部添加 # -- coding: UTF-8 --。

上面包含数据库名称和用户的信息，它们与 MySQL 中对应数据库和用户的设置相同。Django 根据这一设置，与 MySQL 中相应的数据库和用户连接起来。
接下来，告诉 Django 使用 pymysql 模块连接 mysql 数据库：

定义模型

我们修改 app01/models.py 文件，代码如下：

from django.db import models


class Test(models.Model):
    name = models.CharField(max_length=50)
    age = models.IntegerField(default=0)

    def __str__(self):
        return self.name

以上的类名代表了数据库表名，且继承了models.Model，类里面的字段代表数据表中的字段(name,age)，数据类型则由CharField（相当于varchar）、DateField（相当于datetime）和IntegerField（相当于int）等， max_length 参数限定长度。

接下来在 settings.py 中找到INSTALLED_APPS这一项，如下：

INSTALLED_APPS = (
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'app01',               # 添加此项
)

在命令行中运行：

$ python manage.py makemigrations   # 让 Django 知道我们的模型有一些变更
$ python manage.py migrate   # 创建表结构

看到几行 “Applying … OK” 的字样，你的数据表就创建好了。

Django Admin 管理工具

Django 提供了基于 web 的管理工具。
Django 自动管理工具是 django.contrib 的一部分。你可以在项目的 settings.py 中的 INSTALLED_APPS 看到它：

INSTALLED_APPS = (
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
)

django.contrib是一套庞大的功能集，它是Django基本代码的组成部分。

激活管理工具

通常我们在生成项目时会在 urls.py 中自动设置好。

配置项如下所示：

# urls.py
from django.conf.urls import url
from django.contrib import admin
 
urlpatterns = [
    url(r'^admin/', admin.site.urls),
]

当这一切都配置好后，Django 管理工具就可以运行了。

使用管理工具

启动开发服务器，然后在浏览器中访问 http://127.0.0.1:8000/admin/，得到如下界面：

你可以通过命令 python manage.py createsuperuser 来创建超级用户，如下所示：

$ python manage.py createsuperuser
Username (leave blank to use 'root'): admin
Email address: admin@runoob.com
Password:
Password (again):
Superuser created successfully.

之后输入用户名密码登录，界面如下：

为了让 admin 界面管理某个数据模型，我们需要先注册该数据模型到 admin。
修改app01/admin.py:

from django.contrib import admin
from app01.models import Test
 
# Register your models here.
admin.site.register(Test)

刷新后即可看到 Test 数据表。

数据库操作

修改app01下的views.py文件如下：

from django.http import HttpResponse
from django.shortcuts import render
from .models import Test


def hello(request):
    return HttpResponse("Hello world!")


def hello2(request):
    return render(request, 'app01/hello.html', {'hello': 'HelloWorld!'})


def hello3(request):
    users = Test.objects.all()
    return render(request, 'app01/testdb.html', {'users': users})

修改HelloWorld下的urls.py文件如下：

from django.contrib import admin
from django.urls import path
from app01.views import hello, hello2, hello3

urlpatterns = [
    path('admin/', admin.site.urls),
    path('', hello),
    path('hello2/', hello2),
    path('hello3/', hello3),
]

修改模板文件testdb.html如下：

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>TestDB</title>
</head>
<body>
<ul>
    {% for user in users %}
        <li>{{ user.name }}</li>
    {% endfor %}
</ul>
</body>
</html>

启动开发服务器，然后在浏览器中访问 http://127.0.0.1:8000/hello3/，得到如下界面：

Django 视图

视图层

一个视图函数，简称视图，是一个简单的 Python 函数，它接受 Web 请求并且返回 Web 响应。
响应可以是一个 HTML 页面、一个 404 错误页面、重定向页面、XML 文档、或者一张图片…
无论视图本身包含什么逻辑，都要返回响应。代码写在哪里都可以，只要在 Python 目录下面，一般放在项目的 views.py 文件中。
每个视图函数都负责返回一个 HttpResponse 对象，对象中包含生成的响应。

视图层中有两个重要的对象：请求对象(request)与响应对象(HttpResponse)。

请求对象: HttpRequest 对象（简称 request 对象）

以下介绍几个常用的 request 属性。

1、GET

数据类型是 QueryDict，一个类似于字典的对象，包含 HTTP GET 的所有参数。
有相同的键，就把所有的值放到对应的列表里。
取值格式：对象.方法。
get()：返回字符串，如果该键对应有多个值，取出该键的最后一个值。

def test(request):
    name = request.GET.get("name")
    return HttpResponse('姓名：{}'.format(name))

2、POST

数据类型是 QueryDict，一个类似于字典的对象，包含 HTTP POST 的所有参数。
常用于 form 表单，form 表单里的标签 name 属性对应参数的键，value 属性对应参数的值。
取值格式： 对象.方法。
get()：返回字符串，如果该键对应有多个值，取出该键的最后一个值。

def test(request):
    name = request.POST.get("name")
    return HttpResponse('姓名：{}'.format(name))

3、body

数据类型是二进制字节流，是原生请求体里的参数内容，在 HTTP 中用于 POST，因为 GET 没有请求体。在 HTTP 中不常用，而在处理非 HTTP 形式的报文时非常有用，例如：二进制图片、XML、Json 等。

def test(request):
    name = request.body
    print(name)
    return HttpResponse("Django教程")

4、path

获取 URL 中的路径部分，数据类型是字符串。

def test(request):
    name = request.path
    print(name)
    return HttpResponse("Django教程")

5、method

获取当前请求的方式，数据类型是字符串，且结果为大写。

def test(request):
    name = request.method
    print(name)
    return HttpResponse("Django教程")

响应对象：HttpResponse 对象

响应对象主要有三种形式：HttpResponse()、render()、redirect()。

• HttpResponse(): 返回文本，参数为字符串，字符串中写文本内容。如果参数为字符串里含有 html 标签，也可以渲染。

def test(request):
    return HttpResponse("<h1>Django教程</h1>")

• render(): 返回文本，第一个参数为request，第二个参数为字符串（页面名称），第三个参数为字典（可选参数，向页面传递的参数：键为页面参数名，值为views参数名）。

def test(request):
    name ="Django教程"
    return render(request,"test.html",{"name":name})

• redirect()：重定向，跳转新页面。参数为字符串，字符串中填写页面路径。一般用于 form 表单提交后，跳转到新页面。

def test(request):
    return redirect("/index/")

render 和 redirect 是在 HttpResponse 的基础上进行了封装。