Django Web 框架入门与核心使用

在项目目录中使用命令启动项目：

python manage.py runserver 0.0.0.0:8000

启动成功后浏览器输入 127.0.0.1:8000 会跳转到默认界面。

项目中的文件详情

1. settings.py（核心配置）

# 安全警告：生产环境必须关闭 DEBUG！
DEBUG = True
# 允许访问的域名（DEBUG=False 时需配置）
ALLOWED_HOSTS = []
# 注册的 Django 应用
INSTALLED_APPS = [
    'django.contrib.admin',  # 管理员后台
    'django.contrib.auth',   # 认证系统
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',  # 静态文件处理
]
# 数据库配置（默认 SQLite）
DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.sqlite3',
        'NAME': BASE_DIR / 'db.sqlite3',  # 数据库文件路径
    }
}
# 静态文件 URL（CSS/JS/图片）
STATIC_URL = 'static/'

2. urls.py（路由配置）

# HelloWorld/urls.py 示例
from django.contrib import admin
from django.urls import path

urlpatterns = [
    path('admin/', admin.site.urls), # 后台管理路由
    # 可在此添加自定义路由，如：
    # path('blog/', include('blog.urls')),
]

通过路由可跳转到后台管理界面。

3. manage.py（项目管理脚本）

#!/usr/bin/env python
"""
Django's command-line utility for administrative tasks.
Django 的命令行工具，用于执行各类管理任务（如启动服务、数据库迁移等）
"""
import os
import sys

def main():
    """
    核心函数：执行 Django 的各类管理任务
    Run administrative tasks.
    """
    # 设置 Django 核心环境变量：指定项目的配置文件路径
    # 'projectName.settings' 需替换为实际项目名，指向项目根目录下的 settings.py 文件
    os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'projectName.settings')
    try:
        # 尝试从 Django 核心管理模块导入命令行执行函数
        # 该函数用于解析并执行终端输入的 Django 命令（如 runserver/migrate）
        from django.core.management import execute_from_command_line
    except ImportError as exc:
        # 捕获导入失败异常：说明 Django 未安装/环境变量配置错误/虚拟环境未激活
        raise ImportError(
            "Couldn't import Django. Are you sure it's installed and "
            "available on your PYTHONPATH environment variable? Did you "
            "forget to activate a virtual environment?"
        ) from exc
    # 将终端传入的命令行参数（sys.argv）传递给执行函数，执行对应 Django 命令
    execute_from_command_line(sys.argv)

# Python 程序入口判断：仅当该脚本被直接运行时（而非被导入），才执行 main 函数
# 例如：终端执行 python manage.py runserver 时触发
if __name__ == '__main__':
    main()

视图和 URL 配置

在先前创建的 projectName 目录新建一个 views.py 文件。

from django.http import HttpResponse

def hello(request):
    return HttpResponse("First My Django Project! ")

将 URL 与视图函数进行绑定。

通过 127.0.0.1:8000/hello 访问成功（Django 会自动进行热加载，不需要重启）。

path() 函数

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

语法格式：

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

• **route：**字符串，定义 URL 的路径部分。可以包含变量，例如 <int:my_variable>，以从 URL 中捕获参数并将其传递给视图函数。
• **view：**视图函数，处理与给定路由匹配的请求。可以是一个函数或一个基于类的视图。
• **kwargs（可选）：**一个字典，包含传递给视图函数的额外关键字参数。
• **name（可选）：**为 URL 路由指定一个唯一的名称，以便在代码的其他地方引用它。这对于在模板中生成 URL 或在代码中进行重定向等操作非常有用。

3. Django django-admin

django-admin 是 Django 框架提供的一个命令行工具，它是管理 Django 项目的核心工具。

无论是创建新项目、运行开发服务器，还是执行数据库迁移，django-admin 都是不可或缺的工具。

要查看 django-admin 提供的所有命令，可以运行：

django-admin help

常用命令：

django-admin startproject 项目名称
# 这个命令会在当前目录下创建一个新的 Django 项目，包含基本的项目结构：
# manage.py：项目管理脚本
# 项目名称/：项目主目录
# __init__.py
# settings.py：项目设置文件
# urls.py：URL 路由配置
# wsgi.py：WSGI 应用入口

django-admin startapp 应用名称
# 这会创建一个新的 Django 应用，包含：
# migrations/：数据库迁移文件目录
# __init__.py
# admin.py：管理后台配置
# apps.py：应用配置
# models.py：数据模型定义
# tests.py：测试代码
# views.py：视图函数

django-admin check
# 这个命令会检查你的 Django 项目是否有配置错误，包括：
# 模型定义是否正确
# URL 配置是否有效
# 模板设置是否正确
# 静态文件配置等

Django 使用迁移系统来管理数据库模式变更：

django-admin makemigrations # 创建迁移文件
django-admin migrate # 应用迁移到数据库

创建超级用户：

django-admin createsuperuser

django-admin 常用命令

django-admin startproject（创建项目）

基本语法：

django-admin startproject <项目名称> [目标目录]

参数说明：

实例：

django-admin startproject mysite  # 创建默认项目
django-admin startproject mysite /opt/code  # 指定目录
django-admin startproject --template=https://example.com/my_template.zip mysite  # 使用远程模板

django-admin startapp（创建应用）

基本语法：

django-admin startapp <应用名称> [目标目录]

参数说明：

实例：

django-admin startapp blog  # 创建默认应用
django-admin startapp blog /opt/myapp  # 指定目录
django-admin startapp --template=my_template.zip blog  # 使用模板

django-admin runserver（启动开发服务器）

基本语法：

python manage.py runserver [IP:端口]

参数说明：

实例：

python manage.py runserver  # 默认启动（127.0.0.1:8000）
python manage.py runserver 0.0.0.0:8000  # 允许外部访问
python manage.py runserver 8080  # 仅修改端口

django-admin migrate（数据库迁移）

基本语法：

python manage.py migrate [应用名] [迁移版本]

参数说明：

实例：

python manage.py migrate  # 执行所有未应用的迁移
python manage.py migrate blog  # 仅迁移 blog 应用
python manage.py migrate blog 0002  # 迁移到特定版本

其他常用命令

4. Django 详细项目结构

使用 django-admin startproject 命令创建一个新项目时，Django 会自动生成以下基础结构：

myproject/
├── manage.py
└── myproject/
    ├── __init__.py
    ├── settings.py
    ├── urls.py
    └── wsgi.py

manage.py

manage.py 是 Django 项目的命令行工具入口，它提供了许多有用的命令：
#!/usr/bin/env python
import os
import sys
if __name__ == "__main__":
    os.environ.setdefault("DJANGO_SETTINGS_MODULE", "myproject.settings")
    try:
        from django.core.management import execute_from_command_line
    except ImportError:
        # 处理导入错误
        pass
    execute_from_command_line(sys.argv)

常用命令示例：

• python manage.py runserver - 启动开发服务器
• python manage.py migrate - 应用数据库迁移
• python manage.py createsuperuser - 创建管理员账户

settings.py

settings.py 是 Django 项目的配置文件，包含所有重要的设置：
# 关键配置项详解：
DEBUG = True  # 开发时设为 True，显示详细错误；生产环境必须改为 False
ALLOWED_HOSTS = []  # DEBUG=False 时需指定允许访问的域名（如 ['example.com']）
INSTALLED_APPS = [
    'django.contrib.admin',   # 后台管理
    'django.contrib.auth',    # 认证系统
    'django.contrib.contenttypes',  # 内容类型框架
    'django.contrib.sessions',  # 会话管理
    'django.contrib.messages',  # 消息框架
    'django.contrib.staticfiles',  # 静态文件管理
    # 可添加自定义应用：'myapp.apps.MyAppConfig'
]
DATABASES = {  # 数据库配置
    'default': {
        'ENGINE': 'django.db.backends.sqlite3',
        'NAME': BASE_DIR / 'db.sqlite3',  # 使用 pathlib 语法
        # MySQL 示例：
        # 'ENGINE': 'django.db.backends.mysql',
        # 'NAME': 'mydb',
        # 'USER': 'root',
        # 'PASSWORD': 'password',
    }
}
STATIC_URL = '/static/'  # 静态文件 URL 前缀
STATICFILES_DIRS = [BASE_DIR / 'static']  # 开发时静态文件搜索目录
MEDIA_URL = '/media/'   # 用户上传文件 URL 前缀
MEDIA_ROOT = BASE_DIR / 'media'  # 上传文件存储路径

urls.py（URL 调度中心）

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

urlpatterns = [
    path('admin/', admin.site.urls),  # 后台路由
    path('blog/', include('blog.urls')),  # 子应用路由分发
    # path('api/', include('api.urls', namespace='api')),
]

include()：实现路由模块化，将不同应用的路由分离到各自的 urls.py。 namespace：用于反向解析 URL 时避免命名冲突。

wsgi.py & asgi.py

扩展目录（非自动生成，但常用）：

HelloWorld/
├── apps/ # 推荐：存放所有自定义应用
│   └── blog/ # 示例应用
├── static/ # 静态文件（CSS/JS/图片）
├── media/ # 用户上传文件
├── templates/ # 全局模板目录
└── requirements.txt # 项目依赖列表

1. apps/ 目录（推荐结构）

将应用集中管理，避免散落在项目根目录。 需在 settings.py 中配置 Python 路径：

import sys
sys.path.insert(0, os.path.join(BASE_DIR, 'apps'))

2. 静态文件与媒体文件

• static/：存放 CSS、JavaScript、图片等，通过 STATIC_URL 访问。
• media/：用户上传的文件（如头像），通过 MEDIA_URL 访问。需配置服务器在开发时提供访问：

# urls.py（仅开发环境）
from django.conf import settings
from django.conf.urls.static import static
urlpatterns += static(settings.MEDIA_URL, document_root=settings.MEDIA_ROOT)

Django 应用结构

在 Django 中，一个项目可以包含多个应用。使用 python manage.py startapp myapp 创建一个新应用后，会生成以下结构：

myapp/
├── migrations/
└── __init__.py
├── __init__.py
├── admin.py
├── apps.py
├── models.py
├── tests.py
└── views.py

主要应用文件

models.py

# 定义数据模型，与数据库表对应：
from django.db import models

class Product(models.Model):
    name = models.CharField(max_length=100)
    price = models.DecimalField(max_digits=10, decimal_places=2)
    description = models.TextField()

    def __str__(self):
        return self.name

views.py

# 处理业务逻辑，返回响应：
from django.shortcuts import render
from .models import Product

def product_list(request):
    products = Product.objects.all()
    return render(request, 'myapp/product_list.html', {'products': products})

admin.py

# 配置 Django 管理后台：
from django.contrib import admin
from .models import Product

@admin.register(Product)
class ProductAdmin(admin.ModelAdmin):
    list_display = ('name', 'price')

完整项目结构示例

一个典型的 Django 项目完整结构如下：

myproject/
├── manage.py
├── requirements.txt
├── static/
│   ├── css/
│   ├── js/
│   └── images/
├── media/
├── templates/
│   └── base.html
└── myproject/
    ├── __init__.py
    ├── settings.py
    ├── urls.py
    ├── wsgi.py
    └── asgi.py
    └── myapp1/
        ├── migrations/
        ├── templates/
        │   └── myapp1/
        ├── __init__.py
        ├── admin.py
        ├── apps.py
        ├── models.py
        ├── tests.py
        ├── urls.py
        └── views.py
    └── myapp2/
        └── ... (类似结构)

重要目录说明

migrations 目录

存储数据库迁移文件，Django 使用这些文件来跟踪模型变更并同步到数据库。

static 目录

存放静态文件（CSS, JavaScript, 图片等），在部署时会收集到指定位置。

templates 目录

存放 HTML 模板文件，Django 使用模板语言动态生成页面。

media 目录

存储用户上传的文件，需要在 settings.py 中配置：

MEDIA_URL = '/media/'
MEDIA_ROOT = os.path.join(BASE_DIR, 'media')

实践建议

1. 项目与应用分离：保持每个应用的独立性，便于复用
2. 环境配置：使用不同的 settings 文件区分开发和生产环境
3. 静态文件管理：开发时使用 STATICFILES_DIRS，生产时使用 collectstatic
4. URL 设计：在应用级别定义 URL，然后在项目级别包含
5. 模板组织：为每个应用创建子目录存放模板

生产环境 vs 开发环境差异

5. Django 模板

使用流程

模板系统（Template System）是用于将业务逻辑（Python）与展示层（HTML）分离的核心组件，它允许开发者通过简单的标签和变量动态生成 HTML 页面。

模板是一个文本，用于分离文档的表现形式和内容。

项目目录：

projectName/
|-- projectName
|   |-- __init__.py
|   |-- __init__.pyc
|   |-- settings.py
|   |-- settings.pyc
|   |-- urls.py
|   |-- urls.pyc
|   |-- views.py
|   |-- views.pyc
|   |-- wsgi.py
|   `-- wsgi.pyc
|-- manage.py
`-- templates
    `-- runoob.html

<!-- projectName/templates/runoob.html 文件代码 -->
<h1>{{ hello }}</h1>

从模板中我们知道变量使用了双括号 {{ }}。

接下来我们需要向 Django 说明模板文件的路径，打开 settings.py 文件，修改 TEMPLATES 中的 DIRS 为 [BASE_DIR / "templates"]，如下所示：

# HelloWorld/HelloWorld/settings.py 文件代码
...
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，增加一个新的对象，用于向模板提交数据：

使用 render 来替代之前使用的 HttpResponse，render 还使用了一个字典 context 作为参数。

context 字典中元素的键值 hello 对应了模板中的变量 {{ hello }}。

# HelloWorld/HelloWorld/views.py 文件代码
from django.shortcuts import render

def runoob(request):
    context = {}
    context['hello'] = 'Hello World!'
    return render(request, 'runoob.html', context)

# HelloWorld/HelloWorld/urls.py 文件代码
from django.contrib import admin
from django.urls import path
from . import views

urlpatterns = [
    path('admin/', admin.site.urls),
    path('runoob/', views.runoob),
]

启动服务器：

python manage.py runserver 0.0.0.0:8000

查看结果成功的使用模板来输出数据，从而实现数据与视图分离。

Django 模板标签

{% tag %}

控制模板逻辑，常用标签：

变量

模板语法：

view：{"HTML 变量名" : "views 变量名"}
HTML：{{变量名}}

views.py 文件代码：

from django.shortcuts import render

def runoob(request):
    views_name = "测试"
    return render(request, "runoob.html", {"name": views_name})

templates 中的 runoob.html：

<p>{{ name }}</p>

再次访问 http://127.0.0.1:8000/runoob，可以看到页面。

列表

templates 中的 runoob.html 中，可以用 . 索引下标取出对应的元素。

views.py 文件代码：

from django.shortcuts import render

def runoob(request):
    views_list = ["测试 1", "测试 2", "测试 3"]
    return render(request, "runoob.html", {"views_list": views_list})

/runoob.html 文件代码：

<p>{{ views_list }}</p> <!-- 取出整个列表 -->
<p>{{ views_list.0 }}</p> <!-- 取出列表的第一个元素 -->

再次访问 http://127.0.0.1:8000/runoob，可以看到页面。

字典

templates 中的 runoob.html 中，可以用 .键 取出对应的值。

/views.py 文件代码：

from django.shortcuts import render

def runoob(request):
    views_dict = {"name": "测试"}
    return render(request, "runoob.html", {"views_dict": views_dict})

/templates/runoob.html 文件代码：

<p>{{ views_dict }}</p>
<p>{{ views_dict.name }}</p>

再次访问 http://127.0.0.1:8000/runoob，可以看到页面。

过滤器

模板语法：

{{ 变量名 | 过滤器：可选参数 }}

模板过滤器可以在变量被显示前修改它，过滤器使用管道字符，如下所示：

{{ name|lower }}

{{ name }} 变量被过滤器 lower 处理后，文档大写转换文本为小写。

过滤管道可以被套接，既是说，一个过滤器管道的输出又可以作为下一个管道的输入：

{{ my_list|first|upper }}

以上实例将第一个元素并将其转化为大写。

有些过滤器有参数。过滤器的参数跟随冒号之后并且总是以双引号包含。例如：

{{ bio|truncatewords:"30" }}

这个将显示变量 bio 的前 30 个词。

其他过滤器：

• addslashes : 添加反斜杠到任何反斜杠、单引号或者双引号前面。
• date : 按指定的格式字符串参数格式化 date 或者 datetime 对象，实例：{{ pub_date|date:"F j, Y" }}
• length : 返回变量的长度。

default

default 为变量提供一个默认值。

如果 views 传的变量的布尔值是 false，则使用指定的默认值。

以下值为 false：

0, 0.0, False, 0j, "", [], (), set(), {}, None

views.py 文件代码：

from django.shortcuts import render

def runoob(request):
    name = 0
    return render(request, "runoob.html", {"name": name})

templates/runoob.html 文件代码：

{{ name|default:"测试" }}

再次访问 http://127.0.0.1:8000/runoob，可以看到页面。

length

返回对象的长度，适用于字符串和列表。

字典返回的是键值对的数量，集合返回的是去重后的长度。

views.py 文件代码：

from django.shortcuts import render

def runoob(request):
    name = "测试"
    return render(request, "runoob.html", {"name": name})

templates/runoob.html 文件代码：

{{ name|length}}

再次访问 http://127.0.0.1:8000/runoob，可以看到页面。

filesizeformat

以更易读的方式显示文件的大小（即'13 KB', '4.1 MB', '102 bytes'等）。

views.py 文件代码：

from django.shortcuts import render

def runoob(request):
    num = 1024
    return render(request, "runoob.html", {"num": num})

runoob.html 文件代码：

{{ num|filesizeformat}}

再次访问 http://127.0.0.1:8000/runoob，可以看到页面。

date

根据给定格式对一个日期变量进行格式化。

格式 Y-m-d H:i:s 返回 年 - 月 - 日 小时：分钟：秒 的格式时间。

views.py 文件代码：

from django.shortcuts import render
import datetime

def runoob(request):
    now = datetime.datetime.now()
    return render(request, "runoob.html", {"time": now})

runoob.html 文件代码：

{{ time|date:"Y-m-d" }}

再次访问 http://127.0.0.1:8000/runoob，可以看到页面。

truncatechars

如果字符串包含的字符总个数多于指定的字符数量，那么会被截断掉后面的部分。

截断的字符串将以 ... 结尾。

views.py 文件代码：

from django.shortcuts import render

def runoob(request):
    views_str = "测试"
    return render(request, "runoob.html", {"views_str": views_str})

runoob.html 文件代码：

{{ views_str|truncatechars:2}}

再访问访问 http://127.0.0.1:8000/runoob，可以看到页面。

......

6. Django 模型

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 配置项，将其信息修改为：

settings.py: 文件代码：

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

接下来，告诉 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 文件，代码如下：

/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 这一项，如下：

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

在命令行中运行（项目根目录中执行）：

# 创建表结构
python manage.py migrate
# 让 Django 知道模型变更
python manage.py makemigrations TestModel
# 创建 TestModel 的表结构
python manage.py migrate TestModel

看到几行 "Creating table…" 的字样，你的数据表就创建好了。

Creating tables ... …… Creating table TestModel_test #我们自定义的表 ……

表名组成结构为：应用名_类名（如：TestModel_test）。

**注意：**尽管我们没有在 models 给表设置主键，但是 Django 会自动添加一个 id 作为主键。

数据库操作

接下来我们在 HelloWorld 目录中添加 testdb.py 文件（下面介绍），并修改 urls.py：

urls.py: 文件代码：

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>")

访问 http://127.0.0.1:8000/testdb 就可以看到数据添加成功的提示。

输出结果如下：

获取数据

Django 提供了多种方式来获取数据库的内容，如下代码所示：

testdb.py: 文件代码：

# -*- coding: utf-8 -*-
from django.http import HttpResponse
from TestModel.models import Test

# 数据库操作
def testdb(request):
    # 初始化
    # 通过 objects 这个模型管理器的 all() 获得所有数据行，相当于 SQL 中的 SELECT * FROM
    listTest = 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")
    # 输出所有数据
    response1 = ""
    for var in listTest:
        response1 += var.name + " "
    response = response1
    return HttpResponse("<p>" + response + "</p>")

更新数据

修改数据可以使用 save() 或 update():

testdb.py: 文件代码：

# -*- 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() 方法即可：

testdb.py: 文件代码：

# -*- 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>")