Django ORM 1. 创建模型（Model）

1. ORM介绍

什么是ORM？

ORM，全称 Object-Relational Mapping（对象关系映射），一种通过对象操作数据库的技术。

它的核心思想是：我们不直接写 SQL，而是用 Python 对象（类/实例）来操作数据库表和记录。

ORM 就像一个“翻译官”，帮我们把 Python 代码翻译成数据库能听懂的 SQL 命令。

 为什么使用ORM?

Django 中的 ORM 提供了一个高层次、抽象化的接口来操作数据库，它的优势主要包括：

Django中的ORM 

在 Django 中，ORM 是与数据库打交道的核心组件，所有数据库操作的起点都是“模型（Model）”

• 每一个模型（Python类）对应数据库中的一张表

• 每一个模型的字段（类属性）对应表中的一列

• 每一个模型的实例对象代表表中的一条记录（row）

 ORM 与传统 SQL 的对比：

不用关心连接、游标、关闭这些底层细节，ORM 都帮我们处理好了 。

2. 创建Django项目

使用PyCharm Professional版本能非常便捷的创建django项目：

• 打开 PyCharm，点击 File > New Project

• 左侧选择 Django

• 选择项目路径，例如：~/Documents/DjangoDemo

• 创建新虚拟环境，选择Python version

• 点击Advanced settings > 填写Application name如web

Django项目目录结构 

DjangoDemo/
├── DjangoDemo/        ← 项目配置目录（同名目录）
│   ├── __init__.py         ← Python 包初始化文件
│   ├── settings.py         ← 项目的全局配置文件
│   ├── urls.py             ← 全局 URL 路由配置
│   ├── asgi.py             ← 异步部署入口（ASGI 服务器用）
│   └── wsgi.py             ← 同步部署入口（WSGI 服务器用）
├── web/              ← 你创建的 Django 应用（业务模块）
│   ├── __init__.py         ← Python 包初始化文件
│   ├── admin.py            ← 注册模型到后台管理站点
│   ├── apps.py             ← 应用配置类，系统自动识别用
│   ├── migrations/         ← 数据迁移文件夹（记录模型变更）
│   │   └── __init__.py         ← 迁移包初始化
│   ├── models.py           ← 数据模型定义（ORM 相关内容）
│   ├── tests.py            ← 单元测试写在这里
│   └── views.py            ← 视图函数写在这里（处理请求与返回响应）
├── manage.py          ← 项目管理脚本，统一入口
└── db.sqlite3         ← 默认数据库文件（开发环境使用）
 

3. 创建 Django 模型（Model）

什么是模型（Model）？

在 Django 中，模型（Model）就是一个 Python 类，用于定义要存储在数据库中的数据结构。

每一个模型类会被 Django 自动映射为数据库中的一张表，而模型的字段（类属性）就是表中的列（字段）。

写一个模型类 = 定义一张数据库表
添加一个模型字段 = 增加一列字段

项目配置为使用 MySQL 数据库

Django 默认使用 SQLite —— 适合开发，不适合上线。为了保证本地开发环境与线上生产环境一致，避免迁移踩坑，建议学习 ORM 的同时，从一开始就配置 MySQL。

安装 MySQL 驱动

MySql驱动推荐使用 PyMySQL，纯 Python 写的，跨平台更好安装，适合初学者

打开Pycharm下方的Terminal（会自动进入python虚拟环境），输入以下命令：

pip install pymysql

在项目启动时替代 MySQLdb 

在你的项目主配置模块下（例如 DjangoDemo/DjangoDemo/__init__.py），添加以下代码：

import pymysql

pymysql.install_as_MySQLdb()

修改 settings.py 中数据库配置 

在项目的settings文件，如DjangoDemo/DjangoDemo/settings.py中修改DATABASES配置：

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.mysql', # 数据库引擎
        'NAME': 'django_demo',          # 数据库
        'USER': 'root',                 # 用户名
        'PASSWORD': 'yourpassword',     # 密码
        'HOST': '127.0.0.1',            # 数据库主机地址
        'PORT': '3306',                 # 数据库端口
        'OPTIONS': {
            'charset': 'utf8mb4',       # 使用支持 Emoji 的字符集
        }
    }
}

确保数据库已创建 

在 MySQL 中创建数据库：

CREATE DATABASE IF NOT EXISTS django_demo CHARSET utf8mb4;

创建一个模型类 

假设我们要开发一个电商网站，需要保存商品信息。在web/models.py文件中添加一个Product类：

from django.db import models

# Create your models here.
class Product(models.Model):
    name = models.CharField(max_length=100, verbose_name="商品名称") # 字符串字段，限制最大长度为 100
    price = models.DecimalField(max_digits=10, decimal_places=2, verbose_name="价格") # 精确的金额字段，最大 10 位数，小数点后保留 2 位
    stock = models.IntegerField(default=0, verbose_name="库存数量") # 库存数量，整型，默认值为 0
    is_active = models.BooleanField(default=True, verbose_name="是否上架") # 是否上架，布尔类型
    created_at = models.DateTimeField(auto_now_add=True, verbose_name="创建时间") # 创建时间，auto_now_add=True 表示创建时自动填充
    updated_at = models.DateTimeField(auto_now=True, verbose_name="更新时间") # 更新时间，auto_now=True 表示每次保存都会自动更新

    # 在 Django 模型中,如果不写 __str__ 方法,显示出来的是一堆没有意义的“对象地址”
    # 加了 __str__ 方法后,增加了信息量,变成更友好的人类可读格式
    def __str__(self):
        return self.name

    class Meta:
        db_table = 'product'                      # 自定义表名,默认表名是 web_product,现在指定为 product
        ordering = ['-created_at']                # 默认按创建时间降序排列,['-created_at'] 表示按 created_at 字段降序排列（最新的在前）
        verbose_name = "商品"                      # 后台显示的单数名称,在 Django admin 中显示为“商品”
        verbose_name_plural = "商品列表"           # 后台显示的复数名称,在 Django admin 列表页显示为“商品列表”

应用模型到数据库

模型写完了，还需要两个步骤：

第一步：创建迁移文件（Django 记录你定义的表结构）

打开Pycharm下方的Terminal，确保当前工作目录在项目根目录，输入以下命令：

python manage.py makemigrations

第二步：执行迁移，真正创建表结构

python manage.py migrate

成功后，Django 会在数据库中创建一张叫 product 的表。如何验证模型是否生效？可以进入 Django shell 测试：

python manage.py shell

from web.models import Product

# 创建一个商品
p = Product(name='苹果手机', price=5999.99, stock=100)
p.save()

# 查询商品
Product.objects.all()

 4. 模型（Model）字段解析

字段类型 

字符串类型字段（文本类）

数值类型字段 

布尔类型字段 

时间/日期类型字段 

关系字段（模型之间的关系） 

文件和图片上传字段 

特殊类型字段 

字段参数

通用字段参数

适用于大多数字段类型（如 CharField、IntegerField、BooleanField、DateTimeField 等），可用于控制数据库行为、表单验证、管理后台展示等。

字符串字段专用

数值字段专用

时间日期字段专用 

关系字段专用

附：on_delete 常用选项 

文件上传字段专用 

适用于FileField, ImageField字段

模型字段小技巧与注意事项 

notes = models.TextField(null=True, blank=True)

created_at = models.DateTimeField(auto_now_add=True)
updated_at = models.DateTimeField(auto_now=True)

phone = models.CharField(max_length=20, db_index=True)

from django.db import models

class Status(models.TextChoices):
    PENDING = 'P', '待处理'
    PAID = 'D', '已支付'

status = models.CharField(max_length=1, choices=Status.choices, default=Status.PENDING)

is_active = models.BooleanField(default=True)

def user_directory_path(instance, filename):
    return f'user_{instance.user.id}/{filename}'

avatar = models.ImageField(upload_to=user_directory_path)

def default_settings():
    return {}

settings = models.JSONField(default=default_settings)

class Meta:
    unique_together = [('user', 'date')]

email = models.EmailField(verbose_name='电子邮箱', help_text='请输入有效邮箱地址')

from django.core.validators import RegexValidator

phone_validator = RegexValidator(r'^\d{10}$', '手机号格式错误')

phone = models.CharField(validators=[phone_validator], max_length=10)

5. 模型（Model）创建示例

下面是一个完整的博客系统模型创建示例，包含各种常用字段类型和关系字段：

from django.db import models
from django.contrib.auth.models import User
from django.utils import timezone
from django.urls import reverse

class Category(models.Model):
    """
    博客分类模型
    """
    name = models.CharField('分类名称', max_length=100)
    created = models.DateTimeField('创建时间', auto_now_add=True)
    
    class Meta:
        db_table = 'category'
        verbose_name = '分类'
        verbose_name_plural = verbose_name
        ordering = ['-created']
    
    def __str__(self):
        return self.name

class Tag(models.Model):
    """
    博客标签模型
    """
    name = models.CharField('标签名称', max_length=100)
    created = models.DateTimeField('创建时间', auto_now_add=True)
    
    class Meta:
        db_table = 'tag'
        verbose_name = '标签'
        verbose_name_plural = verbose_name
    
    def __str__(self):
        return self.name

class Post(models.Model):
    """
    博客文章模型
    """
    # 文章状态选项
    STATUS_CHOICES = (
        ('draft', '草稿'),
        ('published', '已发布'),
    )
    
    # 基础字段
    title = models.CharField('标题', max_length=200)
    slug = models.SlugField('URL别名', max_length=200, unique_for_date='publish')
    author = models.ForeignKey(
        User, 
        on_delete=models.CASCADE, 
        related_name='blog_posts',
        verbose_name='作者'
    )
    body = models.TextField('正文内容')
    publish = models.DateTimeField('发布时间', default=timezone.now)
    created = models.DateTimeField('创建时间', auto_now_add=True)
    updated = models.DateTimeField('更新时间', auto_now=True)
    status = models.CharField(
        '文章状态', 
        max_length=10, 
        choices=STATUS_CHOICES, 
        default='draft'
    )
    
    # 关系字段
    category = models.ForeignKey(
        Category, 
        on_delete=models.CASCADE, 
        related_name='posts',
        verbose_name='分类'
    )
    tags = models.ManyToManyField(
        Tag, 
        related_name='posts',
        blank=True,
        verbose_name='标签'
    )
    
    # 数字字段
    views = models.PositiveIntegerField('浏览量', default=0)
    likes = models.PositiveIntegerField('点赞数', default=0)
    
    # 布尔字段
    is_top = models.BooleanField('置顶文章', default=False)
    is_recommend = models.BooleanField('推荐文章', default=False)
    
    # 文件字段
    cover_image = models.ImageField(
        '封面图片', 
        upload_to='posts/%Y/%m/%d/', 
        blank=True
    )
    attachment = models.FileField(
        '附件', 
        upload_to='attachments/%Y/%m/%d/', 
        blank=True
    )
    
    class Meta:
        db_table = 'post'
        verbose_name = '文章'
        verbose_name_plural = verbose_name
        ordering = ('-publish',)
        indexes = [
            models.Index(fields=['-publish']),
        ]
    
    def __str__(self):
        return self.title
    
    def get_absolute_url(self):
        return reverse('blog:post_detail', args=[
            self.publish.year,
            self.publish.month,
            self.publish.day,
            self.slug
        ])
    
    def increase_views(self):
        self.views += 1
        self.save(update_fields=['views'])

class Comment(models.Model):
    """
    文章评论模型
    """
    post = models.ForeignKey(
        Post,
        on_delete=models.CASCADE,
        related_name='comments',
        verbose_name='所属文章'
    )
    name = models.CharField('评论者', max_length=80)
    email = models.EmailField('邮箱')
    body = models.TextField('评论内容')
    created = models.DateTimeField('创建时间', auto_now_add=True)
    updated = models.DateTimeField('更新时间', auto_now=True)
    active = models.BooleanField('是否显示', default=True)
    
    # 自引用多对多关系，用于实现评论回复
    parent = models.ForeignKey(
        'self',
        null=True,
        blank=True,
        on_delete=models.CASCADE,
        related_name='replies',
        verbose_name='父评论'
    )
    
    class Meta:
        db_table = 'comment'
        verbose_name = '评论'
        verbose_name_plural = verbose_name
        ordering = ('created',)
    
    def __str__(self):
        return f'由 {self.name} 对 {self.post} 的评论'

一对多关系 (ForeignKey) 

Post 与 Category 的关系

category = models.ForeignKey(
    Category, 
    on_delete=models.CASCADE, 
    related_name='posts',
    verbose_name='分类'
)

关系解析：

• 一个分类(Category)可以对应多篇文章(Post)

• 一篇文章(Post)只能属于一个分类(Category)

• on_delete=models.CASCADE 表示当分类被删除时，属于该分类的所有文章也会被删除

• related_name='posts' 允许通过分类实例访问其所有文章：category.posts.all()

SQL表现：

• 在Post表中会有一个category_id字段存储关联的Category主键

Post 与 User 的关系 

author = models.ForeignKey(
    User, 
    on_delete=models.CASCADE, 
    related_name='blog_posts',
    verbose_name='作者'
)

关系解析：

• 一个用户(User)可以写多篇文章(Post)

• 一篇文章(Post)只能有一个作者(User)

• related_name='blog_posts' 允许通过用户实例访问其所有文章：user.blog_posts.all()

多对多关系 (ManyToManyField) 

Post 与 Tag 的关系 

tags = models.ManyToManyField(
    Tag, 
    related_name='posts',
    blank=True,
    verbose_name='标签'
)

关系解析：

• 一篇文章(Post)可以有多个标签(Tag)

• 一个标签(Tag)可以标记多篇文章(Post)

• blank=True 表示文章可以不关联任何标签

• related_name='posts' 允许通过标签实例访问关联的所有文章：tag.posts.all()

SQL表现：

• Django会自动创建一个中间表来维护这种多对多关系，格式为：模型名称_字段名称，此处生成的中间表名为：post_tags

自引用关系 (自关联) 

 Comment 的自引用关系

parent = models.ForeignKey(
    'self',
    null=True,
    blank=True,
    on_delete=models.CASCADE,
    related_name='replies',
    verbose_name='父评论'
)

关系解析：

• 一条评论(Comment)可以回复另一条评论(形成评论树)

• null=True, blank=True 表示评论可以不回复任何其他评论(顶级评论)

• related_name='replies' 允许通过评论实例访问其所有回复：comment.replies.all()

• on_delete=models.CASCADE 表示当父评论被删除时，其所有回复也会被删除

反向关系查询示例 

Django 的反向查询让你可以从被关联的对象出发，反查所有引用它的对象，实现数据关系的双向访问，提高开发效率和代码可读性，是 ORM 系统中非常关键的一部分。

正向关系和反向关系

• 正向关系：从"多"的一方找"一"的一方（如：文章找作者）

• 反向关系：从"一"的一方找"多"的一方（如：作者找所有文章）

• Django自动创建的反向查询名默认是 模型名小写_set，但可以用 related_name 改名

就像快递站里：

• 正向关系是"通过快递找主人"→ 快递.主人就能找到你（这是直观的）

• 反向关系是"通过主人找所有快递" → 主人知道他618买的几十个快递在哪，主人.快递就能找到所有快递（这就是反向关系）

示例 

用户(Author)与文章(Post) - 一对多

正向查询：从文章找作者

post = Post.objects.get(id=1)
author = post.author  # 获取这篇文章的作者

反向查询：从用户找他写的所有文章

user = User.objects.get(username='张三')
user_posts = user.blog_posts.all()  # 获取张三写的所有文章
# 如果没有定义related_name，则是 user.post_set.all()

 标签(Tag)与文章(Post) - 多对多

正向查询：从文章找所有标签

post = Post.objects.get(id=1)
tags = post.tags.all()  # 获取这篇文章的所有标签

反向查询：从标签找所有关联的文章

tag = Tag.objects.get(name='Django')
django_posts = tag.posts.all()  # 获取所有标记为Django的文章