本文介绍了 Django Web 框架的基础知识，涵盖安装配置、项目结构、视图路由、模板系统以及 ORM 数据库操作。内容包括 Python 环境搭建、Django 命令行工具使用、settings 与 urls 配置详解、模型定义及增删改查示例，适合初学者快速上手 Django 开发。
Django 是高效的 Python Web 框架，核心优势包括：自带丰富内置功能（认证、管理后台等）提效开发；ORM 机制免写 SQL 即可操作数据库；具备灵活路由、模板引擎、国际化能力；内置安全防护；还有丰富社区和扩展生态。
如果未安装 Python 环境需要先下载 Python 安装包。
**注意：**目前 Django 主流版本均兼容 Python 3.x。
安装 Python 你只需要下载 python-x.x.x.msi 文件，然后一直点击 "Next" 按钮即可。
安装完成后需要设置 Python 环境变量。右击计算机->属性->高级->环境变量->修改系统变量 path，添加 Python 安装地址。
之后可以在 cmd 中确认一下是否安装成功。
通过命令 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 配置
| 文件 | 说明 |
|---|---|
| manage.py | Django 命令行工具入口，用于运行开发服务器、数据库迁移等操作。 |
| init.py | 空文件，告诉 Python 该目录是一个包。 |
| settings.py | 核心配置文件，包含数据库设置 (DATABASES)、静态文件路径 (STATIC_URL)、应用注册 (INSTALLED_APPS)、调试模式 (DEBUG=True/False) 等。 |
| urls.py | 主路由配置文件，定义 URL 路径与视图的映射关系。 |
| asgi.py | ASGI 服务器配置（用于异步 Web 服务器，如 Daphne）。 |
| wsgi.py | WSGI 服务器配置（用于传统 Web 服务器，如 Gunicorn、uWSGI）。 |
在项目目录中使用命令启动项目：
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()
在先前创建的 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 会自动进行热加载，不需要重启）。
Django path() 可以接收四个参数，分别是两个必选参数：route、view 和两个可选参数：kwargs、name。
语法格式：
path(route, view, kwargs=None, name=None)
<int:my_variable>，以从 URL 中捕获参数并将其传递给视图函数。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
| 命令 | 作用 | 示例 |
|---|---|---|
startproject | 创建一个新 Django 项目 | django-admin startproject myproject |
startapp | 创建一个新 Django 应用 | django-admin startapp myapp |
runserver | 启动开发服务器 | python manage.py runserver |
makemigrations | 生成数据库迁移文件 | python manage.py makemigrations |
migrate | 执行数据库迁移 | python manage.py migrate |
createsuperuser | 创建管理员账号 | python manage.py createsuperuser |
shell | 启动 Django 交互式 Shell | python manage.py shell |
collectstatic | 收集静态文件（用于生产环境） | python manage.py collectstatic |
test | 运行单元测试 | python manage.py test |
基本语法：
django-admin startproject <项目名称> [目标目录]
参数说明：
| 参数 | 作用 | 示例 |
|---|---|---|
<项目名称> | 必填，项目名称（会生成同名目录） | django-admin startproject mysite |
[目标目录] | 可选，指定项目存放目录 | django-admin startproject mysite /opt/myproject |
--template | 使用自定义项目模板 | django-admin startproject --template=my_template.zip mysite |
--extension | 指定文件扩展名（如 .py, .txt） | django-admin startproject --extension=py,txt mysite |
--name | 指定文件名模式（如 Dockerfile, README.md） | django-admin startproject --name=Dockerfile mysite |
实例：
django-admin startproject mysite # 创建默认项目
django-admin startproject mysite /opt/code # 指定目录
django-admin startproject --template=https://example.com/my_template.zip mysite # 使用远程模板
基本语法：
django-admin startapp <应用名称> [目标目录]
参数说明：
| 参数 | 作用 | 示例 |
|---|---|---|
<应用名称> | 必填，应用名称（会生成 models.py, views.py 等） | django-admin startapp blog |
[目标目录] | 可选，指定应用存放目录 | django-admin startapp blog /opt/myapp |
--template | 使用自定义应用模板 | django-admin startapp --template=my_app_template.zip blog |
实例：
django-admin startapp blog # 创建默认应用
django-admin startapp blog /opt/myapp # 指定目录
django-admin startapp --template=my_template.zip blog # 使用模板
基本语法：
python manage.py runserver [IP:端口]
参数说明：
| 参数 | 作用 | 示例 |
|---|---|---|
[IP:端口] | 可选，指定监听的 IP 和端口（默认 127.0.0.1:8000） | python manage.py runserver 0.0.0.0:8080 |
--noreload | 禁用自动重载（调试时使用） | python manage.py runserver --noreload |
--insecure | 强制静态文件服务（非 DEBUG 模式） | python manage.py runserver --insecure |
实例：
python manage.py runserver # 默认启动（127.0.0.1:8000）
python manage.py runserver 0.0.0.0:8000 # 允许外部访问
python manage.py runserver 8080 # 仅修改端口
基本语法：
python manage.py migrate [应用名] [迁移版本]
参数说明：
| 参数 | 作用 | 示例 |
|---|---|---|
[应用名] | 可选，指定要迁移的应用 | python manage.py migrate blog |
[迁移版本] | 可选，指定迁移版本号 | python manage.py migrate blog 0002 |
--fake | 标记迁移为已执行（不实际修改数据库） | python manage.py migrate --fake |
--fake-initial | 仅当表已存在时标记为已执行 | python manage.py migrate --fake-initial |
实例：
python manage.py migrate # 执行所有未应用的迁移
python manage.py migrate blog # 仅迁移 blog 应用
python manage.py migrate blog 0002 # 迁移到特定版本
| 命令 | 作用 | 示例 |
|---|---|---|
createsuperuser | 创建管理员用户 | python manage.py createsuperuser |
shell | 进入 Django Shell（带 ORM 支持） | python manage.py shell |
test | 运行测试用例 | python manage.py test blog |
collectstatic | 收集静态文件（生产环境部署） | python manage.py collectstatic |
使用 django-admin startproject 命令创建一个新项目时，Django 会自动生成以下基础结构：
myproject/
├── manage.py
└── myproject/
├── __init__.py
├── settings.py
├── urls.py
└── wsgi.py
| 文件/目录 | 详细说明 |
|---|---|
manage.py | Django 项目的命令行管理工具，封装了 django-admin 的功能，并自动设置 DJANGO_SETTINGS_MODULE 环境变量指向当前项目的配置。所有项目管理命令都通过它执行，如：runserver（启动开发服务器）、makemigrations（生成数据库迁移文件）、shell（启动带 ORM 的 Python shell）。 |
db.sqlite3 | Django 默认使用的 SQLite 数据库文件，在首次执行 migrate 命令后自动生成。开发环境适用，生产环境建议换用 PostgreSQL/MySQL。文件位置由 settings.py 中的 DATABASES['default']['NAME'] 定义。 |
__pycache__/ | Python 解释器生成的字节码缓存目录，包含 .pyc 文件，用于加速模块加载。无需提交到版本控制（应在 .gitignore 中忽略）。 |
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 是 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' # 上传文件存储路径
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 | WSGI（Web Server Gateway Interface）配置，用于传统同步服务器（如 Gunicorn、uWSGI）。生产环境通过此文件启动项目。 |
asgi.py | ASGI（Asynchronous Server Gateway Interface）配置，支持异步服务器（如 Daphne、Uvicorn）。用于 WebSocket 或异步视图。 |
扩展目录（非自动生成，但常用）：
HelloWorld/
├── apps/ # 推荐：存放所有自定义应用
│ └── blog/ # 示例应用
├── static/ # 静态文件（CSS/JS/图片）
├── media/ # 用户上传文件
├── templates/ # 全局模板目录
└── requirements.txt # 项目依赖列表
将应用集中管理，避免散落在项目根目录。 需在 settings.py 中配置 Python 路径：
import sys
sys.path.insert(0, os.path.join(BASE_DIR, 'apps'))
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 中，一个项目可以包含多个应用。使用 python manage.py startapp myapp 创建一个新应用后，会生成以下结构：
myapp/
├── migrations/
└── __init__.py
├── __init__.py
├── admin.py
├── apps.py
├── models.py
├── tests.py
└── views.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
# 处理业务逻辑，返回响应：
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})
# 配置 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/
└── ... (类似结构)
存储数据库迁移文件，Django 使用这些文件来跟踪模型变更并同步到数据库。
存放静态文件（CSS, JavaScript, 图片等），在部署时会收集到指定位置。
存放 HTML 模板文件，Django 使用模板语言动态生成页面。
存储用户上传的文件，需要在 settings.py 中配置：
MEDIA_URL = '/media/'
MEDIA_ROOT = os.path.join(BASE_DIR, 'media')
STATICFILES_DIRS，生产时使用 collectstatic| 文件/配置 | 开发环境 | 生产环境 |
|---|---|---|
DEBUG | True（显示错误详情） | False（隐藏错误，记录到日志） |
| 数据库 | SQLite（默认） | PostgreSQL/MySQL（性能优化） |
| 静态文件 | runserver 自动服务 | 使用 collectstatic 收集到 CDN |
ALLOWED_HOSTS | 空列表或 ['localhost'] | 必须配置域名（如 ['example.com']） |
模板系统（Template System）是用于将业务逻辑（Python）与展示层（HTML）分离的核心组件，它允许开发者通过简单的标签和变量动态生成 HTML 页面。
模板是一个文本，用于分离文档的表现形式和内容。
| 功能 | 语法/示例 | 适用场景 |
|---|---|---|
| 变量渲染 | {{ variable }} | 动态显示数据 |
| 逻辑控制 | {% if %}, {% for %} | 条件/循环渲染 |
| 模板继承 | {% extends %}, {% block %} | 避免重复 HTML 结构 |
| 静态文件 | {% static 'path' %} | 加载 CSS/JS/图片 |
| 自定义过滤器 | @register.filter | 扩展模板功能 |
项目目录：
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
查看结果成功的使用模板来输出数据，从而实现数据与视图分离。
{% tag %}
控制模板逻辑，常用标签：
| 标签 | 用途 |
|---|---|
{% for %} | 循环遍历列表/字典 |
{% if %} | 条件判断 |
{% extends %} | 继承基模板 |
{% block %} | 定义可被子模板覆盖的内容块 |
{% include %} | 嵌入其他模板片段 |
{% url %} | 反向解析 URL（避免硬编码路径） |
{% csrf_token %} | 生成 CSRF 令牌（用于 POST 表单） |
模板语法：
view：{"HTML 变量名" : "views 变量名"}
HTML：{{变量名}}
from django.shortcuts import render
def runoob(request):
views_name = "测试"
return render(request, "runoob.html", {"name": views_name})
<p>{{ name }}</p>
templates 中的 runoob.html 中，可以用 . 索引下标取出对应的元素。
from django.shortcuts import render
def runoob(request):
views_list = ["测试 1", "测试 2", "测试 3"]
return render(request, "runoob.html", {"views_list": views_list})
<p>{{ views_list }}</p> <!-- 取出整个列表 -->
<p>{{ views_list.0 }}</p> <!-- 取出列表的第一个元素 -->
templates 中的 runoob.html 中，可以用 .键 取出对应的值。
from django.shortcuts import render
def runoob(request):
views_dict = {"name": "测试"}
return render(request, "runoob.html", {"views_dict": views_dict})
<p>{{ views_dict }}</p>
<p>{{ views_dict.name }}</p>
模板语法：
{{ 变量名 | 过滤器：可选参数 }}
模板过滤器可以在变量被显示前修改它，过滤器使用管道字符，如下所示：
{{ 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 为变量提供一个默认值。
如果 views 传的变量的布尔值是 false，则使用指定的默认值。
以下值为 false：
0, 0.0, False, 0j, "", [], (), set(), {}, None
from django.shortcuts import render
def runoob(request):
name = 0
return render(request, "runoob.html", {"name": name})
{{ name|default:"测试" }}
返回对象的长度，适用于字符串和列表。
字典返回的是键值对的数量，集合返回的是去重后的长度。
from django.shortcuts import render
def runoob(request):
name = "测试"
return render(request, "runoob.html", {"name": name})
{{ name|length}}
以更易读的方式显示文件的大小（即'13 KB', '4.1 MB', '102 bytes'等）。
from django.shortcuts import render
def runoob(request):
num = 1024
return render(request, "runoob.html", {"num": num})
{{ num|filesizeformat}}
根据给定格式对一个日期变量进行格式化。
格式 Y-m-d H:i:s 返回 年 - 月 - 日 小时：分钟：秒 的格式时间。
from django.shortcuts import render
import datetime
def runoob(request):
now = datetime.datetime.now()
return render(request, "runoob.html", {"time": now})
{{ time|date:"Y-m-d" }}
如果字符串包含的字符总个数多于指定的字符数量，那么会被截断掉后面的部分。
截断的字符串将以 ... 结尾。
from django.shortcuts import render
def runoob(request):
views_str = "测试"
return render(request, "runoob.html", {"views_str": views_str})
{{ views_str|truncatechars:2}}
......
Django 模型使用自带的 ORM。
对象关系映射（Object Relational Mapping，简称 ORM）用于实现面向对象编程语言里不同类型系统的数据之间的转换。
ORM 在业务逻辑层和数据库层之间充当了桥梁的作用。
ORM 是通过使用描述对象和数据库之间的映射的元数据，将程序中的对象自动持久化到数据库中。
使用 ORM 的好处：
使用 ORM 的缺点：
ORM 解析过程：
ORM 对应关系表：
创建 MySQL 数据库 (ORM 无法操作到数据库级别，只能操作到数据表) 语法：
create database 数据库名称 default charset=utf8; # 防止编码问题，指定为 utf8
例如我们创建一个名为 runoob 数据库，编码指定为 utf8：
create database runoob default charset=utf8;
我们在项目的 settings.py 文件中找到 DATABASES 配置项，将其信息修改为：
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 数据库：
import pymysql
pymysql.install_as_MySQLdb()
Django 规定，如果要使用模型，必须要创建一个 app。我们使用以下命令创建一个 TestModel 的 app：
django-admin startapp TestModel
目录结构如下：
我们修改 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：
from django.urls import path
from . import views, testdb
urlpatterns = [
path('runoob/', views.runoob),
path('testdb/', testdb.testdb),
]
# 添加数据需要先创建对象，然后再执行 save 函数，相当于 SQL 中的 INSERT：
# -*- 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 提供了多种方式来获取数据库的内容，如下代码所示：
# -*- 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():
# -*- 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() 方法即可：
# -*- 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>")
微信公众号「极客日志」，在微信中扫描左侧二维码关注。展示文案：极客日志 zeeklog
解析常见 curl 参数并生成 fetch、axios、PHP curl 或 Python requests 示例代码。 在线工具，curl 转代码在线工具，online
将字符串编码和解码为其 Base64 格式表示形式即可。 在线工具，Base64 字符串编码/解码在线工具，online
将字符串、文件或图像转换为其 Base64 表示形式。 在线工具，Base64 文件转换器在线工具，online
将 Markdown（GFM）转为 HTML 片段，浏览器内 marked 解析；与 HTML 转 Markdown 互为补充。 在线工具，Markdown 转 HTML在线工具，online
将 HTML 片段转为 GitHub Flavored Markdown，支持标题、列表、链接、代码块与表格等；浏览器内处理，可链接预填。 在线工具，HTML 转 Markdown在线工具，online
通过删除不必要的空白来缩小和压缩JSON。 在线工具，JSON 压缩在线工具，online