Django使用

1.介绍：

Django 是高效的 Python Web 框架，核心优势包括：自带丰富内置功能（认证、管理后台等）提效开发；ORM 机制免写 SQL 即可操作数据库；具备灵活路由、模板引擎、国际化能力；内置安全防护；还有丰富社区和扩展生态。

2.流程：

如果未安装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安装地址。

之后可以在在cmd中确认一下是否安装成功

Django安装

通过命令 pip install Django 进行安装

通过命令判断是否安装成功

python3 -m django --version

创建项目

安装 Django 之后， 通过django-admin进行创建项目。

通过命令进行创建 项目名称为projectName

django-admin startproject projectName 

创建后的项目目录：

projectName/ # 项目根目录 ├── manage.py # 项目管理脚本 └── projectName/ # 项目配置目录（与项目同名） ├── __init__.py # 包标识文件 ├── settings.py # 项目设置 ├── urls.py # 主路由配置 ├── asgi.py # ASGI 配置 └── wsgi.py # WSGI 配置

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

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')), ]

通过路由可跳转到该界面 Log in | Django site admin

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?" # 异常提示翻译&补充： # 无法导入Django！请确认： # 1. Django已成功安装 # 2. Django在PYTHONPATH环境变量中可被识别 # 3. 已激活项目对应的虚拟环境（如有） ) 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 def runoob(request):     import datetime     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") # 输出所有数据 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>")