1. 介绍
Django 是高效的 Python Web 框架,核心优势包括:自带丰富内置功能(认证、管理后台等)提效开发;ORM 机制免写 SQL 即可操作数据库;具备灵活路由、模板引擎、国际化能力;内置安全防护;还有丰富社区和扩展生态。
2. 流程
如果未安装 Python 环境需要先下载 Python 安装包。
- Python 下载地址:https://www.python.org/downloads/
本文介绍了 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