创建虚拟环境

在部署 Django 应用时，使用虚拟环境是一个最佳实践，尤其是在 Python 中。虚拟环境可以帮助你创建一个独立的工作空间，避免不同项目之间的依赖冲突。以下是使用虚拟环境的优点以及一些其他的部署建议。

使用虚拟环境的优点

1. 依赖管理：每个虚拟环境可以有独立的依赖库，不会与系统级 Python 库或其他项目的库冲突。
2. 可移植性：可以轻松地将项目与其依赖一起迁移到不同的机器上（只需复制虚拟环境及其配置）。
3. 简化版本控制：可以为每个项目指定和安装特定版本的库，方便管理和测试。
4. 避免权限问题：可以在用户目录下安装依赖库，避免了使用 sudo 进行全局安装时可能遇到的权限问题。

创建和使用虚拟环境

Python 提供了多种工具来创建虚拟环境，最常用的是 venv 和 virtualenv。

方式一：venv 模块构造虚拟环境（Python 3.x 中的内置模块）

1. 创建虚拟环境

在你的 Django 项目根目录下运行以下命令（使用 Python 3）：

python -m venv venv

目的

• 创建一个隔离的环境：这个命令使用 Python 的内置模块 venv 来创建一个新的虚拟环境（名为 venv）。此环境是独立的，不会影响系统全局的 Python 安装及已安装的库。
• 隔离库依赖：在该虚拟环境中，您可以安装库和插件，它们不会与全局 Python 环境中的库冲突。这样可以避免版本冲突和不兼容的问题。

执行结果

• 在当前目录下，将会创建一个新的文件夹（如 venv），其中包含 Python 的可执行文件及 pip 工具，同时也会创建一个子文件夹用于存储该环境的依赖库。

2. 激活虚拟环境

Windows 激活命令

venv\Scripts\activate

macOS/Linux 激活命令

source venv/bin/activate

目的

• 激活虚拟环境：执行这个命令后，您就进入了 venv 虚拟环境，命令行提示符通常会发生变化（例如，前面会显示 (venv)），这表明您当前正处于该虚拟环境中。
• 使用独立的 Python 运行环境：激活虚拟环境后，您所有的 Python 命令（如 python 和 pip）都会指向当前虚拟环境中的可执行文件，而不是全局安装的版本。这意味着该环境中的库和设置将被应用。

3. 安装 Django

命令

pip install django

目的

• 安装库到虚拟环境：当虚拟环境处于激活状态时，所有通过 pip 安装的库都将安装到此虚拟环境中。这些库不会影响系统的 Python 环境。
• 隔离开发：通过这种方式，您可以为项目安装特定版本的 Django 和其他依赖，确保项目在不同环境中始终运行稳定。

执行结果

• Django 库将被下载并安装在 venv/lib/site-packages（Linux/macOS）或 venv/Lib/site-packages（Windows）目录中。此处存放的库仅在虚拟环境内可用。

4. 运行 Django 项目

命令

python manage.py runserver

目的

• 启动开发服务器：该命令会启动 Django 自带的轻量级开发服务器。开发服务器使您能够在本地计算机上测试和开发您的应用。
• 确保环境一致性：在激活状态下运行，确保使用的是在虚拟环境中安装的 Django 和其他依赖。

执行结果

• 您将在控制台看到服务器启动的输出信息，并且可以通过浏览器访问 http://127.0.0.1:8000 来查看您的 Django 应用。

5. 停用虚拟环境

命令

deactivate

目的

• 退出虚拟环境：当您完成项目或工作后，运行 deactivate 命令将使您退出当前虚拟环境，恢复到系统的全局 Python 环境状态。
• 避免混淆：停用虚拟环境可以防止在错误的环境中运行命令，这是个好的习惯。

执行结果

• 命令提示符将恢复到之前的状态（不再显示 (venv) 前缀）。此时，您可以运行全局安装的 Python 命令和库，但此时在虚拟环境中安装的库将不可用。

注：有些开发工具（如 PyCharm 或 VS Code）会在您创建一个新的 Python 项目时，自动创建一个 .venv 目录作为虚拟环境。这种虚拟环境设置是完全可以直接使用的，您不需要手动再创建一个新的 venv 目录。直接激活虚拟环境：source .venv/bin/activate，然后在激活的虚拟环境中，您可以使用 pip 安装库pip install django即可。激活后的命令提示符通常会在环境名称前加上括号 (.venv)。使用 .venv 作为虚拟环境能够更方便地组织项目，特别是当同一个目录下有多个项目时，这可以避免混淆。

方式二（可选）：virtualenvwrapper 工具构造虚拟环境

1、安装 virtualenv 和 virtualenvwrapper

pip install virtualenv virtualenvwrapper

2、设置工作环境（Linux/macOS）

将以下内容添加到你的 .bashrc 或 .bash_profile 文件中（如果你使用的是 zsh，应添加到 .zshrc）

export WORKON_HOME=~/.virtualenvs
mkdir -p $WORKON_HOME
source /usr/local/bin/virtualenvwrapper.sh # 确保路径正确

保存文件后，运行以下命令以应用更改：

source ~/.bashrc # 或者 ~/.bash_profile

3、创建虚拟环境

使用 mkvirtualenv 命令创建新的虚拟环境：

mkvirtualenv myenv

4、使用 workon 命令激活虚拟环境

你可以使用 workon 命令方便地切换到任何创建的虚拟环境：

workon myenv

5、停用当前虚拟环境

deactivate

6、删除虚拟环境（需先停用虚拟环境）

rmvirtualenv myenv

创建 Django 工程

首先进入虚拟环境：

source venv/bin/activate

创建新的 Django 项目

使用 Django 的命令行工具创建一个新的 Django 项目。假设项目名称为 mysite，运行以下命令：

django-admin startproject mysite

这将创建一个名为 mysite 的目录，包含以下文件结构：

mysite/
    manage.py
    mysite/
        __init__.py
        settings.py
        urls.py
        asgi.py
        wsgi.py

启动 Django 开发服务器

进入新创建的项目目录：

cd mysite

然后可以运行 Django 内置的开发服务器：

python manage.py runserver [IP（默认127.0.0.1）:PORT(默认 8000)]

服务器启动后，可以通过浏览器访问 http://127.0.0.1:8000/ 来查看 Django 的欢迎页面。

当不再需要使用虚拟环境时,停用虚拟环境

deactivate

Django 项目结构剖析

假设您用 django-admin startproject mysite 创建了一个名为 mysite 的 Django 项目。项目的基本目录结构如下：

mysite/
    manage.py 
    mysite/
        __init__.py
        settings.py
        urls.py
        asgi.py
        wsgi.py

 manage.py

• 作用：manage.py 是一个命令行工具，帮助您与 Django 项目进行交互。它是 Python 脚本，提供了多种命令功能。
• 常用命令：
  • runserver：启动开发服务器：python manage.py runserver
  • migrate：应用数据库迁移。python manage.py migrate
  • makemigrations：创建数据库迁移文件。python manage.py makemigrations
  • createsuperuser：创建超级用户以访问 Django 管理后台。python manage.py createsuperuser
    

mysite/__init__.py

作用：这是一个空文件，表示该目录是一个 Python 包。即使这个文件是空的，Python 解释器依然能够将该目录视作一个包，从中可以导入模块。

mysite/settings.py

• 作用：settings.py 是 Django 项目的配置文件，包含了与应用程序相关的各种设置。
• 主要配置：
  • 数据库设置：定义数据库引擎、名称、用户、密码等信息。
  • 已安装的应用：通过 INSTALLED_APPS 设置当前项目将要使用的 Django 应用和第三方库。
  • 中间件：指定项目中使用的中间件列表。
  • 静态文件：配置静态文件的目录和路径。
  • 调试模式：可以在开发阶段将 DEBUG 设置为 True，在生产环境中则应设置为 False。

mysite/urls.py

• 作用：urls.py 定义了项目的 URL 路由。它将请求的 URL 映射到特定的视图函数。
• 基本内容：
  • URL 模式的列表，使用 path() 和其他相关函数来定义 URL 和视图之间的关系。
  • 通常，您可以在此文件中导入应用的 URL 配置，以实现模块化和更清晰的结构。

示例：

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

urlpatterns = [
    path('admin/', admin.site.urls),
    path('', include('blog.urls')),  # 包含 blog 应用的 URLs
]

mysite/asgi.py

• 作用：asgi.py 是异步服务器网关接口（ASGI）配置文件，主要是用来支持异步 Web 应用程序和 HTTP2 等现代应用。
• 说明：如果您打算使用 Django 的异步功能，可以在此文件中定义 ASGI 应用的设置。ASGI 使得 Django 能够支持异步的请求处理，适合处理长连接等场景。

mysite/wsgi.py

• 作用：wsgi.py 是 Web 服务器网关接口（WSGI）配置文件，适用于传统的同步风格应用。
• 说明：大多数生产环境下，Django 应用是通过 WSGI 服务器（如 Gunicorn、uWSGI）运行的。该文件用于暴露 WSGI 应用供服务器调用，以实现 HTTP 请求的处理。

创建子应用

1. 进入项目目录

在终端或命令行中，确保您在 Django 项目的根目录下，即与 manage.py 文件同级的目录。

cd path/to/mysite

2. 创建子应用

使用 startapp 命令创建新的应用。在终端中运行以下命令：

python manage.py startapp blog

这里 blog 是您要创建的应用名称。根据您的需要，您可以自行替换为其他名称

3. 查看创建的文件结构

blog/
    migrations/
        __init__.py
    __init__.py
    admin.py
    apps.py
    models.py
    tests.py
    views.py

这些文件的作用如下：

• migrations/：此目录用于存放与数据库迁移相关的文件。
• __init__.py：表示该目录是一个 Python 包。
• admin.py：在这里可以注册并配置应用的模型，以便在 Django 的管理后台中使用。
• apps.py：包含应用的配置类，通常 Django 会自动生成该文件，您也可以自定义配置。
• models.py：在这里定义数据模型（ORM），用于与数据库交互。
• tests.py：单元测试文件，用于编写与应用相关的测试。
• views.py：在这里编写视图逻辑，处理请求和返回响应。

4. 配置应用在项目中的使用

在创建完子应用后，您需要在项目的 settings.py 文件中注册该应用。打开 mysite/settings.py 文件，找到 INSTALLED_APPS，在其中添加 'blog'。

INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'blog',  # 添加你的子应用
]

5. 创建模型

在 blog/models.py 中，您可以定义数据模型。例如：

from django.db import models

class Post(models.Model):
    title = models.CharField(max_length=200)
    content = models.TextField()
    created_at = models.DateTimeField(auto_now_add=True)

    def __str__(self):
        return self.title

在 Django 中，模型（Model）是与数据库进行交互的核心部分。它定义了数据的结构、行为以及与数据库之间的关系。通过定义模型，您可以轻松地创建、读取、更新和删除（CRUD）数据库中的数据。我们详细解释一下模型的作用和构建模型的步骤。

什么是模型？

1. 数据结构定义：
   • 模型是用来定义应用程序数据结构的。它通常包含应用程序将存储在数据库中的字段（数据列）和对应的属性（数据类型）。
2. 数据库交互：
   • Django 使用模型来与数据库进行交互。当您在模型中定义了数据结构后，Django 可以自动生成相应的数据库表，并执行数据的存取操作。
3. ORM（对象关系映射）：
   • Django 使用 ORM 来将模型与数据库表进行映射。您不需要直接编写 SQL 语句，而是通过 Python 类进行对象操作，Django 会在后台转换为适当的 SQL 语句。

示例模型解释

来看下我们提供的模型：

# 通过导入 Django 的 models 模块，我们可以利用其中定义的各种字段类型来创建模型。
from django.db import models

# Post 是模型的名称，继承自 models.Model，使其成为 Django 模型。这个类将代表数据库中的一张表。
class Post(models.Model):
    '''
    字段定义：
    title: 使用 models.CharField() 定义一个字符字段，最大字符数为 200。这将成为数据库表中的一个列，用于存储文章标题。
content: 使用 models.TextField() 定义一个文本字段，适合存储长文本内容（如文章正文）。
created_at: 使用 models.DateTimeField(auto_now_add=True) 定义一个日期时间字段，该字段将在创建记录时自动设置为当前日期和时间。
    '''
    title = models.CharField(max_length=200)  # 字段：标题，最大字符数为200
    content = models.TextField()                # 字段：内容，用于长文本
    created_at = models.DateTimeField(auto_now_add=True)  # 字段：创建时间，自动设置为当前时间
    # 该方法自定义了当打印 Post 类的实例时显示的内容。在这个例子中，当您打印一个 Post 对象时，将显示它的标题。
    def __str__(self):
        return self.title  # 当打印模型实例时显示标题

6. 迁移数据库

定义模型后，通过命令创建和应用数据库迁移：

python manage.py makemigrations blog # 在终端中运行以下命令，Django 会为您生成一个迁移文件，描述如何创建或更改数据库表
python manage.py migrate # 使用以下命令应用迁移，将模型中的结构反映到数据库中：

这将根据您在 models.py 中定义的模型，创建相应的数据库表。

模型的作用

通过定义模型，能够：

• 创建数据存储结构：模型定义了数据在数据库中的组织方式。
• 简化数据库操作：享受 Django 提供的强大 ORM 功能，方便进行数据操作，而无需直接使用 SQL。
• 与其他模型建立关系：可以创建 ForeignKey、ManyToManyField 等字段来定义模型之间的关系，从而构建复杂的数据结构和查询。

7. 配置 URL 路由

Django URL 匹配流程：

在 blog 应用内创建一个 urls.py 文件，并设置路由。例如：

# blog/urls.py
from django.urls import path
from . import views

urlpatterns = [
    path('', views.index, name='index'),  # 配置主页视图
]

解释：

• from django.urls import path：
  • 导入 Django 提供的 path 函数，用于定义 URL 模式。
• from . import views：
  • 从当前应用中导入视图函数，这将允许您在 URL 路由中引用这些视图。
• urlpatterns：
  • 这是一个 URL 模式列表，包含对 URL 的定义。在这里，您定义了根 URL（''）对应的视图函数 views.index。
• path('', views.index, name='index')：
  • 这个命令的意思是，当用户访问 http://your-domain.com/blog/ 时，Django 将调用 blog/views.py 中的 index 视图函数来处理请求，并返回响应。

然后在项目的 mysite/urls.py 中包含该 urls.py：

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

urlpatterns = [
    path('admin/', admin.site.urls),
    path('blog/', include('blog.urls')),  # 包含 blog 应用的 URL 路由
]

解释：

• from django.urls import path, include：
  • 导入 include 函数，它允许您在主 URL 路由中包含其他应用的路由。
• urlpatterns：
  • 您在这里定义了项目的主 URL 路由。
• path('admin/', admin.site.urls)：
  • 这是 Django 默认的管理后台 URL 路由，当用户访问 http://your-domain.com/admin/ 时，将显示 Django 管理后台。
• path('blog/', include('blog.urls'))：
  • 此行的作用是将 /blog/ 的请求路由到 blog.urls 中的 URL 配置。这意味着任何以 /blog/ 开头的请求都会由 blog 应用的 URL 路由进行处理。例如，访问 http://your-domain.com/blog/ 会路由到 blog/urls.py 的 path('', views.index, name='index')，同时，访问 http://your-domain.com/blog/some-other-url/ 会根据 blog/urls.py 指定的其他 URL 模式进行处理。

Django Web 开发框架将 URL 路由视为将用户请求映射到相应视图（views）的一种方式。通过配置 URL 路由，Django 能够处理不同的 HTTP 请求，并根据请求的 URL 返回所需的响应。这使得开发者能够设计清晰的应用程序结构和用户交互流程。

最终相当于：如果在您的 Django 项目中，您配置了如下 URL 路由：

• 当用户访问 http://your-domain.com/blog/ 这个地址时，Django 会调用 blog/views.py 文件中的 index 视图函数，来处理这个请求并返回响应。

通过 URL 路由配置，您可以自由地创建更加复杂的 URL 模式。例如：

urlpatterns = [
    path('', views.index, name='index'),                      # 主页
    path('post/<int:post_id>/', views.detail, name='detail'), # 文章详情页，动态获取文章 ID
    path('about/', views.about, name='about'),                # 关于页面
]

8. 创建视图

在 blog/views.py 中创建视图函数，例如：

from django.http import HttpResponse

def index(request):
    return HttpResponse("Welcome to the blog index!")

在 Django 中，视图（View）是处理用户请求并返回响应的核心部分。它可以理解为 Django 应用中的商业逻辑层，负责接收请求、处理数据、并将结果返回给用户。

视图的概念

• 视图函数：视图通常是一个返回 HttpResponse 对象的 Python 函数。响应可以是 HTML 页面、重定向、404 错误，或者任何其他内容（如 JSON、XML）。
• 请求和响应：当用户发送请求（例如访问 URL 地址）到服务器时，Django 将匹配 URL 路由并找到对应的视图函数，然后调用该视图函数。视图函数对请求进行处理，并返回一个响应。

9.注册模型到 Admin 后台

首先，您需要在 blog/admin.py 文件中注册您创建的模型

from django.contrib import admin
from .models import Post  # 导入您的模型

# 注册模型
admin.site.register(Post)

这段代码的意思是让 Django Admin 知道您希望管理这个 Post 模型。

创建超级用户

要访问 Django 的管理后台，您需要一个超级用户账户。您可以通过以下命令创建一个：

python manage.py createsuperuser

10. 启动服务器

完成上述步骤后，您可以启动开发服务器来查看您的应用是否正常工作：

python manage.py runserver

然后在浏览器中访问 http://127.0.0.1:8000/blog/ 来查看 "Welcome to the blog index!" 的输出。

访问 Django Admin 管理后台: http://127.0.0.1:8000/admin/

登录 Admin 管理后台

管理数据

点击 Post，您将进入该模型的管理页面。在这里，您可以：

• 添加新文章：点击 "Add Post" 按钮创建新文章。
• 查看所有文章：列出所有已经创建的文章，并可以编辑或删除它们。

添加文章，检验数据库数据是否变化

进入到db.sqlite3所在目录，执行相应命令

sqlite3 db.sqlite3
.tables
SELECT * FROM blog_post;

11. 添加模板操作

使用 Django 的模板系统可以让您更灵活地渲染和展示动态内容，而不仅仅是返回静态的 HTTP 响应，下面将当前的视图和 URL 配置修改为使用模板

首先，您需要创建存放 HTML 模板的目录。通常会在每个 Django 根目录下新建一个 templates 目录。

您可以在项目的根目录下创建一个单独的 templates 目录，并将所有应用的模板放在这里。可以使用类似于以下的结构：

mysite/
    mysite/
        settings.py
        urls.py
    blog/
        models.py
        views.py
    templates/
        blog/
            index.html

创建 HTML 模板文件

在 mysite/templates/blog/ 目录下创建 index.html 文件，并添加以下内容：

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Blog Index</title>
</head>
<body>
    <h1>Welcome to the Blog Index!</h1>
    <p>This is where you can find the latest posts.</p>
</body>
</html>

修改视图以渲染模板

需要修改 blog/views.py 文件中的视图函数，以便使用 render 函数返回模板。

from django.shortcuts import render

def index(request):
    return render(request, 'blog/index.html')  # 渲染 templates/blog/index.html 模板

这段代码使用 Django 的 render 函数渲染 index.html 模板，并返回生成的 HTML 响应。

 更新 settings.py 配置

这种结构，您需要在 settings.py 中更新模板设置，以便 Django 知道去哪里查找模板。您可以添加 TEMPLATES 中的 DIRS 配置：

# mysite/settings.py
TEMPLATES = [
    {
        'BACKEND': 'django.template.backends.django.DjangoTemplates',
        'DIRS': [os.path.join(BASE_DIR, 'templates')],  # 修改这里，设置模板目录
        'APP_DIRS': True,  # 允许查找各个应用的 templates 目录
        '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',
            ],
        },
    },
]

BASE_DIR 的定义

在 settings.py 文件的开头，您通常会看到以下定义：

BASE_DIR = Path(__file__).resolve().parent.parent

• Path(__file__)：这个调用返回当前文件（即 settings.py）的路径。
• .resolve()：这个方法将返回绝对路径，并解析任何符号链接。
• .parent.parent：这个操作表示从当前路径向上两级目录。即从 settings.py 的目录（通常是 mysite/ 或您自己命名的项目目录）返回到项目根目录。

假设您的 Django 项目结构如下：

BASE_DIR 的值将被解析为 项目的顶级目录：第一层 myproject/。

浏览器中访问 http://127.0.0.1:8000/blog/。可以看到渲染的 HTML 页面

12. 前端返回动态数据

可以在模板中显示数据库中的内容：如 Post 模型中定义的文章，需要更新视图以获取数据库中的数据，并在模板中显示这些数据。下面是完整的步骤，将数据从数据库返回给前端，显示在您的页面中。

更新视图以获取数据库中的数据

修改 blog/views.py 文件中的 index 视图，获取所有的 Post 对象并将其传递给模板：

from django.shortcuts import render
from .models import Post  # 导入 Post 模型

def index(request):
    posts = Post.objects.all()  # 获取所有 Post 数据
    return render(request, 'blog/index.html', {'posts': posts})  # 将 posts 传递给模板

更新模板以显示数据库内容

修改 blog/templates/blog/index.html 模板，以便在网页上展示这些文章的标题和内容。

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Blog Index</title>
</head>
<body>
    <h1>Welcome to the Blog Index!</h1>
    <p>This is where you can find the latest posts.</p>

    <h2>Posts:</h2>
    <ul>
        {% for post in posts %}
            <li>
                <strong>{{ post.title }}</strong><br>
                {{ post.content }}<br>
                <em>Published on: {{ post.created_at }}</em>
            </li>
        {% empty %}
            <li>No posts available.</li>
        {% endfor %}
    </ul>
</body>
</html>

解释模板中的内容

在 index.html 模板中，主要的变化如下：

• 模板语言的使用：使用 {% for post in posts %} 语句来遍历传递到模板的 posts 列表，并为每个 Post 对象生成一个列表项。
• 显示内容：
  • 元素 {{ post.title }} 将渲染文章的标题。
  • 元素 {{ post.content }} 将渲染文章的内容。
  • 元素 {{ post.created_at }} 将渲染文章的发布时间。
• 处理空数据的情况：如果 posts 列表为空，模板会显示 "No posts available." 字样。

确保数据库中有数据

确保数据库中 Post 模型已插入数据。可以通过 Django Admin 管理后台来添加 Post 数据，或者通过 Django shell 来插入数据。

在终端中运行以下命令启动 Django shell：

python manage.py shell

然后输入以下命令插入一条示例数据：

from blog.models import Post

# 创建一个新文章
post = Post(title='My First Post', content='This is the content of my first post.')
post.save()

输入 exit() 退出 Django shell。