---

Python Django 教程：Web 应用开发入门

在当今互联网时代，Web 应用程序无处不在，从简单的个人博客到复杂的电子商务平台和社交网络。掌握 Web 开发技能已成为许多程序员和技术爱好者的追求。Python 作为一种功能强大且易于学习的编程语言，在 Web 开发领域也占据着重要地位，而 Django 则是 Python 生态系统中最流行、功能最全面的 Web 框架之一。本教程旨在为初学者提供一个全面的 Django 入门指南，带你一步步走进 Django Web 开发的世界。

一、 什么是 Django？

Django 是一个基于 Python 的高级 Web 框架，它遵循 MVT（Model-View-Template） 架构模式，旨在鼓励快速开发和简洁、实用的设计。它的核心理念是 DRY (Don’t Repeat Yourself – 不要重复自己)，通过提供一套完整的工具和库，帮助开发者避免编写重复的代码，专注于应用程序的核心逻辑。

Django 的主要特点：

1. 功能完备（Batteries Included）: Django 自带了许多 Web 开发中常用的功能模块，如 ORM（对象关系映射）、用户认证系统、管理后台、表单处理、URL 路由、模板引擎、缓存系统等。这意味着开发者无需从零开始构建这些基础功能，可以快速启动项目。
2. 强大的 ORM: Django 的 ORM 使得开发者可以使用 Python 代码来操作数据库，而无需编写复杂的 SQL 语句。它支持多种数据库后端（如 PostgreSQL, MySQL, SQLite, Oracle），并能很好地处理数据库迁移。
3. 自动化的管理后台: Django 提供了一个开箱即用的管理界面（Admin Interface），只需进行少量配置，就能方便地对数据库中的数据进行增删改查操作，极大地提高了开发和维护效率。
4. 完善的 URL 路由系统: Django 提供了灵活且强大的 URL 分发器，可以将 URL 映射到相应的视图函数或类，易于设计清晰、易于维护的 URL 结构。
5. 强大的模板系统: Django 内置的模板引擎支持模板继承、变量、标签、过滤器等功能，可以方便地将后端数据渲染到 HTML 页面中，实现前后端分离。
6. 安全性: Django 内置了多种安全防护机制，可以有效防御常见的 Web 攻击，如跨站脚本（XSS）、跨站请求伪造（CSRF）、SQL 注入等。
7. 可扩展性: Django 遵循模块化设计，易于扩展。社区拥有大量第三方应用和库，可以方便地集成到 Django 项目中。
8. 庞大的社区和丰富的文档: Django 拥有一个活跃的全球社区和极其完善的官方文档，遇到问题时可以轻松找到解决方案和学习资源。

二、 准备工作：环境搭建

在开始 Django 开发之前，你需要确保你的开发环境已经准备就绪。

1. 安装 Python: Django 是基于 Python 的，所以首先需要安装 Python。你可以从 Python 官网 (https://www.python.org/) 下载适合你操作系统的最新稳定版本。安装时，请确保勾选 “Add Python to PATH”（或类似选项），以便在命令行中直接使用 python 命令。

   • 验证安装：打开命令行（Windows 下的 CMD 或 PowerShell，macOS/Linux 下的 Terminal），输入 python --version 或 python3 --version，如果能看到 Python 版本号，则表示安装成功。

2. 安装 pip: pip 是 Python 的包管理工具，通常会随 Python 一起安装。

   • 验证安装：在命令行输入 pip --version 或 pip3 --version。

3. 使用虚拟环境 (强烈推荐): 为了保持项目依赖的隔离性，避免不同项目间的库版本冲突，强烈建议为每个 Django 项目创建一个独立的虚拟环境。Python 3.3+ 内置了 venv 模块来创建虚拟环境。

   • 创建虚拟环境: 在你打算存放项目的目录下，打开命令行，运行：
     bash
python -m venv myenv
# 或者 python3 -m venv myenv
# "myenv" 是你为虚拟环境取的名字，可以自定义
     这会在当前目录下创建一个名为 myenv 的文件夹，包含 Python 解释器的一个副本和 pip 等工具。
   • 激活虚拟环境:
     • Windows:
       bash
myenv\Scripts\activate
     • macOS/Linux:
       bash
source myenv/bin/activate
       激活成功后，命令行提示符前通常会显示虚拟环境的名称（如 (myenv)）。之后所有通过 pip 安装的库都将安装在这个虚拟环境中。
   • 退出虚拟环境: 在命令行输入 deactivate 即可。

三、 安装 Django

确保你的虚拟环境已经激活，然后使用 pip 安装 Django：

bash
pip install django

pip 会自动下载并安装最新稳定版的 Django 及其依赖项。

验证安装：在命令行输入：

“`bash
python -m django –version

或者 django-admin –version

“`

如果能看到 Django 的版本号，则表示安装成功。

四、 创建你的第一个 Django 项目

一个 Django 项目 (Project) 是一个 Django 实例的配置和应用的集合。可以把它看作是整个 Web 应用程序的容器。

在你的工作目录下（确保虚拟环境已激活），运行以下命令创建一个新项目：

“`bash
django-admin startproject myproject .

“myproject” 是你项目的名称，可以自定义

注意命令末尾的 “.”，表示在当前目录下创建项目文件，而不是再创建一个额外的目录。

如果省略 “.”, 它会在当前目录下创建一个名为 “myproject” 的文件夹，并将项目文件放在里面。

“`

执行完毕后，当前目录下会生成以下文件和目录结构：

.
├── manage.py # 一个命令行工具，用于与 Django 项目进行交互
└── myproject/ # 项目的 Python 包 (与项目同名)
├── __init__.py # 表明这是一个 Python 包
├── asgi.py # ASGI 兼容的 Web 服务器入口点 (用于异步)
├── settings.py # 项目的配置文件
├── urls.py # 项目的 URL 声明 (路由配置)
└── wsgi.py # WSGI 兼容的 Web 服务器入口点 (用于同步)

• manage.py: 非常重要的工具。你会经常使用它来执行各种 Django 命令，如运行开发服务器、创建数据库表、创建应用等。
• myproject/: 项目的主目录。
  • __init__.py: 空文件，告诉 Python 这个目录应该被视为一个 Python 包。
  • settings.py: 包含了项目的所有配置信息，如数据库设置、静态文件路径、已安装应用列表、中间件、模板设置等。这是你需要经常修改的文件。
  • urls.py: 项目级的 URL 配置文件。定义了网站的 URL 路由规则，将 URL 映射到相应的视图。
  • wsgi.py 和 asgi.py: 用于部署项目到生产环境时与 WSGI/ASGI 兼容的 Web 服务器交互的入口文件。

五、 运行开发服务器

Django 自带一个轻量级的 Web 服务器，主要用于开发和测试。在项目根目录下（包含 manage.py 的目录），运行：

bash
python manage.py runserver

你会看到类似以下的输出：

“`
Watching for file changes with StatReloader
Performing system checks…

System check identified no issues (0 silenced).
November 23, 2023 – 10:30:00
Django version 4.2.7, using settings ‘myproject.settings’
Starting development server at http://127.0.0.1:8000/
Quit the server with CTRL-BREAK (Windows) or CONTROL-C (macOS/Linux).
“`

这表明开发服务器已经在本地的 8000 端口启动。打开你的 Web 浏览器，访问 http://127.0.0.1:8000/ 或 http://localhost:8000/。如果一切正常，你会看到一个 Django 的欢迎页面，告诉你“The install worked successfully! Congratulations!”。

要停止开发服务器，按 Ctrl + C。

六、 创建你的第一个 Django 应用

在 Django 中，一个 应用 (App) 是一个实现特定功能的 Web 应用程序模块，例如博客系统、用户认证系统或投票系统。一个项目可以包含多个应用。良好的实践是将不同的功能模块拆分成独立的应用，以提高代码的可重用性和可维护性。

假设我们要创建一个简单的博客应用。在项目根目录下运行：

“`bash
python manage.py startapp blog

“blog” 是你的应用名称，可以自定义

“`

这会在项目根目录下创建一个名为 blog 的新目录，包含以下文件：

blog/
├── __init__.py
├── admin.py # 配置应用在 Django Admin 界面的显示
├── apps.py # 应用自身的配置
├── migrations/ # 存放数据库迁移文件
│ └── __init__.py
├── models.py # 定义数据模型 (数据库表结构)
├── tests.py # 编写应用测试用例
└── views.py # 定义视图函数或类 (处理请求和响应)

注册应用: 创建应用后，你需要告诉 Django 项目它的存在。打开项目配置文件 myproject/settings.py，找到 INSTALLED_APPS 列表，将你的应用配置类添加进去（通常是 app名.apps.App名Config）：

“`python

myproject/settings.py

INSTALLED_APPS = [
‘django.contrib.admin’,
‘django.contrib.auth’,
‘django.contrib.contenttypes’,
‘django.contrib.sessions’,
‘django.contrib.messages’,
‘django.contrib.staticfiles’,
‘blog.apps.BlogConfig’, # 添加这一行，或者直接写 ‘blog’ 也可以，Django能找到
]
“`

七、 理解 MVT 架构模式

Django 遵循 MVT (Model-View-Template) 架构模式，这是 MVC (Model-View-Controller) 的一种变体。

• Model (模型): 负责与数据库交互，定义数据的结构和行为。每个模型通常映射到数据库中的一张表。Django 的 ORM 层使得操作模型就像操作普通的 Python 对象一样简单。模型定义在应用的 models.py 文件中。
• View (视图): 负责处理用户请求，执行业务逻辑，从模型获取数据，并选择合适的模板进行渲染，最终返回 HTTP 响应给用户。视图可以是函数（Function-Based Views, FBV）或类（Class-Based Views, CBV）。视图定义在应用的 views.py 文件中。
• Template (模板): 负责定义用户界面的结构（通常是 HTML）。它包含静态的 HTML 代码和一些特殊的模板标签、变量，用于动态地插入由视图传递过来的数据。模板通常存放在项目或应用下的 templates 目录中。
• URL Dispatcher (URL 分发器): 虽然不是 MVT 的一部分，但它是连接用户请求和视图的关键。它根据用户访问的 URL，查找 urls.py 中定义的路由规则，并将请求分发给对应的视图进行处理。

请求处理流程:
1. 用户在浏览器输入 URL 发起请求。
2. Django 通过项目根 urls.py 和应用 urls.py 查找匹配该 URL 的路由规则。
3. 如果找到匹配规则，URL 分发器调用对应的视图函数或类方法。
4. 视图函数执行业务逻辑，可能会通过模型与数据库交互（查询或修改数据）。
5. 视图函数选择一个模板，并将处理好的数据（称为上下文 context）传递给模板。
6. 模板引擎使用上下文数据渲染模板，生成最终的 HTML 页面。
7. 视图将渲染好的 HTML 页面包装成一个 HTTP 响应返回给浏览器。
8. 浏览器解析并显示 HTML 页面。

八、 定义模型 (Models)

让我们为博客应用定义一个简单的 Post 模型，用来表示一篇博客文章。打开 blog/models.py 文件，添加以下代码：

“`python

blog/models.py

from django.db import models
from django.utils import timezone # 用于处理时间

class Post(models.Model):
title = models.CharField(max_length=200) # 文章标题，CharField 用于短文本
content = models.TextField() # 文章内容，TextField 用于长文本
created_date = models.DateTimeField(default=timezone.now) # 创建时间，DateTimeField 用于日期和时间
published_date = models.DateTimeField(blank=True, null=True) # 发布时间，允许为空

def publish(self):
    self.published_date = timezone.now()
    self.save()

def __str__(self):
    # 定义对象的字符串表示，方便在 Admin 或 Shell 中查看
    return self.title

“`

这里，我们定义了一个 Post 类，继承自 models.Model。类中的每个属性（title, content, created_date, published_date）都代表数据库表中的一个字段，通过 models.CharField, models.TextField, models.DateTimeField 等字段类型来定义其数据类型和约束。__str__ 方法定义了当打印 Post 对象时应显示的字符串。

九、 数据库迁移 (Migrations)

定义或修改模型后，需要告诉 Django 如何将这些更改应用到数据库中。这就是迁移 (Migrations) 的作用。

1. 创建迁移文件: Django 会检测 models.py 的变动，并生成相应的迁移文件，这些文件描述了如何更改数据库结构。
   bash
python manage.py makemigrations blog
# "blog" 是指定为哪个应用创建迁移文件，如果省略，则会检查所有应用
   执行后，Django 会在 blog/migrations/ 目录下创建一个类似 0001_initial.py 的文件，其中包含了创建 Post 表的 Python 代码。

2. 应用迁移: 将迁移文件中的更改应用到实际的数据库。
   bash
python manage.py migrate
   Django 会读取所有应用的迁移文件，并执行尚未应用的迁移操作。默认情况下，Django 使用项目根目录下的 db.sqlite3 文件作为 SQLite 数据库。migrate 命令会自动创建这个数据库文件（如果不存在）以及 Post 表（以及 Django 自带应用所需的其他表）。

十、 创建视图 (Views)

视图是处理请求并返回响应的地方。让我们创建一个简单的视图来显示所有博客文章的列表。打开 blog/views.py 文件，添加以下代码：

“`python

blog/views.py

from django.shortcuts import render
from .models import Post # 导入我们定义的 Post 模型
from django.utils import timezone

def post_list(request):
# 查询所有已发布且发布时间不晚于当前时间的文章，并按发布时间降序排列
posts = Post.objects.filter(published_date__lte=timezone.now()).order_by(‘-published_date’)
# posts 是一个 QuerySet 对象，包含了查询结果

# render 函数会加载模板，并用 context 数据渲染它，返回一个 HttpResponse
# 'blog/post_list.html' 是模板文件的路径
# {'posts': posts} 是要传递给模板的上下文数据，模板中可以通过 'posts' 访问这个 QuerySet
return render(request, 'blog/post_list.html', {'posts': posts})

“`

这个 post_list 函数接收一个 request 对象（包含了请求信息），通过 Django ORM (Post.objects.filter(...)) 查询数据库，然后调用 render 函数加载指定的模板 (blog/post_list.html)，并将查询到的 posts 数据传递给模板。

十一、 配置 URL (URLs)

现在我们需要将 URL 映射到刚刚创建的 post_list 视图。Django 的 URL 配置分为项目级和应用级。

1. 创建应用级 URL 配置 (blog/urls.py):
   在 blog 目录下创建一个新文件 urls.py，并添加以下内容：

   “`python

   blog/urls.py

   from django.urls import path
   from . import views # 导入当前目录下的 views.py

   urlpatterns = [
   # 当访问 ” (即应用的基础 URL) 时，调用 views.post_list 函数
   # name=’post_list’ 为这个 URL 模式命名，方便在模板或其他地方引用
   path(”, views.post_list, name=’post_list’),
   ]
   “`

2. 包含应用级 URL 配置到项目级 (myproject/urls.py):
   打开项目的主 urls.py 文件 (myproject/urls.py)，使用 include 函数将 blog 应用的 URL 配置包含进来。

   “`python

   myproject/urls.py

   from django.contrib import admin
   from django.urls import path, include # 确保导入 include

   urlpatterns = [
   path(‘admin/’, admin.site.urls),
   # 当 URL 以 ‘blog/’ 开头时，将请求转发给 blog 应用的 urls.py 处理
   path(‘blog/’, include(‘blog.urls’)),
   # 你可以添加其他项目级的 URL 规则
   # path(”, include(‘some_other_app.urls’)), # 例如首页或其他应用
   ]
   ``
现在，当用户访问http://localhost:8000/blog/时，请求将被转发到blog.urls，并由path(”, views.post_list, name=’post_list’)规则匹配，最终调用blog/views.py中的post_list` 视图函数。

十二、 编写模板 (Templates)

视图需要一个模板来渲染数据。按照 render(request, 'blog/post_list.html', ...) 中的指定，我们需要创建一个 blog/post_list.html 模板文件。

1. 创建模板目录: 在 blog 应用目录下创建一个 templates 目录，再在其中创建一个与应用同名的子目录 blog（这是 Django 查找模板的最佳实践，避免不同应用间的模板文件名冲突）：
   blog/
├── templates/
│ └── blog/
│ └── post_list.html
... (其他文件)

2. 编写模板文件 (blog/templates/blog/post_list.html):

   “`html
   <!DOCTYPE html>
   
   
   
   
   
   

   My Simple Blog

   <main>
       {% for post in posts %}
           <article>
               <h2><a href="#">{{ post.title }}</a></h2> {# 暂时不加链接 #}
               <p>Published: {{ post.published_date|date:"Y-m-d H:i" }}</p>
               <p>{{ post.content|linebreaksbr|truncatewords:30 }}</p> {# 显示部分内容，linebreaksbr转换换行，truncatewords限制字数 #}
           </article>
       {% empty %}
           <p>No posts published yet.</p>
       {% endfor %}
   </main>
   
   <footer>
       <p>&copy; 2023 My Blog</p>
   </footer>
   

   
   
   ``
这个模板使用了 Django 模板语言 (DTL - Django Template Language)：
*{% for post in posts %}...{% endfor %}: 遍历视图传递过来的posts列表（QuerySet）。
*{{ post.title }}: 显示post对象的title属性值。双花括号{{ }}用于输出变量。
*{{ post.published_date|date:”Y-m-d H:i” }}: 显示published_date，并使用date过滤器格式化日期时间。管道符|用于应用过滤器。
*{{ post.content|linebreaksbr|truncatewords:30 }}: 显示content，linebreaksbr将文本中的换行符转换为
标签，truncatewords将文本截断为前 30 个单词。
*{% empty %}: 如果posts列表为空，则显示{% empty %}和{% endfor %}` 之间的内容。

十三、 使用 Django Admin

Django Admin 是一个强大的内置功能，可以让你方便地管理应用的数据。

1. 创建超级用户: 要登录 Admin 界面，你需要一个管理员账号。在命令行运行：
   bash
python manage.py createsuperuser
   按照提示输入用户名、邮箱（可选）和密码。

2. 注册模型到 Admin: 为了在 Admin 界面中管理 Post 模型，需要将其注册。打开 blog/admin.py 文件，添加以下代码：
   “`python
   # blog/admin.py
   from django.contrib import admin
   from .models import Post # 导入 Post 模型

   admin.site.register(Post) # 将 Post 模型注册到 Admin 站点
   “`

3. 访问 Admin 界面: 确保开发服务器正在运行 (python manage.py runserver)。在浏览器中访问 http://localhost:8000/admin/。你会看到 Django Admin 的登录页面。使用你刚才创建的超级用户账号登录。

登录后，你会看到一个管理界面，其中应该包含一个 “Blog” 部分（或者你应用的名字），里面有 “Posts” 模型。你可以点击 “Posts” 进入管理页面，进行添加、修改、删除博客文章的操作。

十四、 处理静态文件 (Static Files)

Web 应用通常需要 CSS、JavaScript 和图片等静态文件。

1. 配置静态文件: Django 通过 settings.py 中的 STATIC_URL 来指定访问静态文件的 URL 前缀（通常是 /static/）。开发环境中，Django 能自动处理静态文件。

   • 在 myproject/settings.py 中，确保有类似以下的设置：
     python
STATIC_URL = 'static/'
# 可选：如果你想把项目范围的静态文件放在一个地方
# STATICFILES_DIRS = [BASE_DIR / 'static']

2. 创建静态文件目录: 在 blog 应用目录下创建一个 static 目录，再在其中创建一个与应用同名的子目录 blog（同样是为了避免命名冲突）：
   blog/
├── static/
│ └── blog/
│ └── style.css
... (其他文件)

3. 创建 CSS 文件 (blog/static/blog/style.css):
   “`css
   / blog/static/blog/style.css /
   body {
   font-family: sans-serif;
   margin: 2em;
   background-color: #f8f8f8;
   }

   h1, h2 {
   color: #333;
   }

   article {
   background-color: #fff;
   padding: 1em;
   margin-bottom: 1em;
   border: 1px solid #ddd;
   border-radius: 4px;
   }
   “`

4. 在模板中加载静态文件: 修改 blog/templates/blog/post_list.html，在 <head> 中加载 CSS 文件。需要先使用 {% load static %} 标签，然后使用 {% static 'path/to/file' %} 标签生成静态文件的 URL。

   html
{% load static %} {# 在模板顶部加载 static 标签库 #}
<!DOCTYPE html>
<html>
<head>
<title>My Simple Blog</title>
{# 使用 static 标签生成 CSS 文件的 URL #}
<link rel="stylesheet" href="{% static 'blog/style.css' %}">
</head>
<body>
{# ... 其他内容保持不变 ... #}
</body>
</html>

刷新 http://localhost:8000/blog/ 页面，你应该能看到应用了 CSS 样式的效果。

十五、 总结与后续学习

恭喜你！你已经完成了 Django Web 开发的基础入门，学习了：
* Django 的基本概念和 MVT 架构。
* 如何设置开发环境、安装 Django。
* 如何创建 Django 项目和应用。
* 如何定义模型 (Model) 并进行数据库迁移。
* 如何编写视图 (View) 处理请求和逻辑。
* 如何配置 URL 路由。
* 如何使用模板 (Template) 渲染页面和展示数据。
* 如何使用强大的 Django Admin 后台。
* 如何处理静态文件 (CSS, JS, Images)。

这只是 Django 世界的冰山一角。要成为熟练的 Django 开发者，你还需要继续学习更多内容，例如：

• Django 表单 (Forms): 处理用户输入、数据验证。
• 类视图 (Class-Based Views, CBVs): 更结构化、可重用的视图编写方式。
• 用户认证与权限: Django 内置的强大用户管理系统。
• 更复杂的模型关系: 一对多、多对多关系。
• 模板继承: 构建可重用的 HTML 布局。
• 测试: 编写单元测试和集成测试保证代码质量。
• 部署: 将你的 Django 应用部署到生产服务器 (如 Nginx + Gunicorn/uWSGI)。
• Django REST framework: 构建 Web API。
• 缓存、信号、中间件等高级主题。

最佳学习资源:

• Django 官方文档: (https://docs.djangoproject.com/) 这是最权威、最全面的资源，包含教程、主题指南和 API 参考。强烈推荐阅读官方的投票应用教程。
• MDN Web Docs – Django 教程: (https://developer.mozilla.org/en-US/docs/Learn/Server-side/Django) 另一个优秀的入门教程系列。
• 在线课程和书籍: Coursera, Udemy, Real Python 等平台以及众多优秀的 Django 书籍。

持续实践是掌握 Django 的关键。尝试构建你自己的项目，从小功能开始，逐步增加复杂度。遇到问题时，积极查阅文档、搜索社区（如 Stack Overflow）或参与 Django 社区讨论。祝你在 Django Web 开发的旅程中一帆风顺！

---