Python怎么写数据库 - Python 学库 | 全面掌握Python数据库开发指南

为什么Python怎么写数据库如此重要？

数据是现代应用的基石

从电商订单系统到社交平台消息，从金融交易记录到物联网设备监控——所有这些应用都依赖数据库来持久化存储数据。而Python怎么写数据库，正是你通往数据世界的钥匙。

支持多种主流数据库驱动
语法简洁，学习曲线平缓
生态完善，社区活跃
无缝集成Web框架（Django/Flask）

从“写SQL”到“写Python”

早期Python怎么写数据库需要手写大量SQL语句，而今天——通过ORM（对象关系映射），你几乎可以完全用Python代码操作数据库，极大提升开发效率与代码可维护性。

SQL语句自动生成，减少出错
跨数据库兼容性自动处理
类型安全，IDE支持完善
支持复杂查询的链式调用

实战导向，拒绝纸上谈兵

本页面所有示例均来自真实项目场景，涵盖学生信息管理、电商商品库存、博客评论系统等高频业务模型，帮你真正掌握Python怎么写数据库的核心能力。

从建表到CRUD全流程演示
关系设计避坑指南
性能瓶颈识别与优化
数据库迁移与版本管理

主流数据库方案：Python怎么写数据库的底层支撑

SQLite：最适合Python初学者的数据库

SQLite是Python内置的轻量级数据库，无需安装服务器，数据以单文件形式存储（.db/.sqlite），非常适合本地开发、小型应用或原型验证。

适用场景：个人项目、移动App本地数据存储、嵌入式设备数据管理、测试环境模拟。

# 1. 创建数据库并连接
import sqlite3
conn = sqlite3.connect('students.db')
# 2. 创建游标对象
cursor = conn.cursor()
# 3. 创建数据表
cursor.execute('''
CREATE TABLE IF NOT EXISTS students (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    name TEXT NOT NULL,
    age INTEGER,
    major TEXT
)
''')
# 4. 插入数据
cursor.execute("INSERT INTO students (name, age, major) VALUES (?, ?, ?)",
               ('张三', 20, '计算机科学'))
cursor.execute("INSERT INTO students (name, age, major) VALUES (?, ?, ?)",
               ('李四', 21, '软件工程'))
# 5. 提交事务
conn.commit()
# 6. 查询数据
cursor.execute("SELECT  FROM students WHERE age > ?", (19,))
rows = cursor.fetchall()
for row in rows:
    print(f"ID: {row[0]}, 姓名: {row[1]}, 年龄: {row[2]}, 专业: {row[3]}")
# 7. 关闭连接
cursor.close()
conn.close()
        

✅ 核心优势：零配置、单文件存储、跨平台、内置支持；
⚠️ 局限性：不支持高并发写入、无用户权限管理、不适合大型应用。

MySQL：Web应用最广泛的关系型数据库

MySQL是LAMP/LNMP技术栈的核心组件，以其高性能、稳定性和成熟生态成为企业首选。Python可通过`mysql-connector-python`或`pymysql`驱动连接。

适用场景：电商网站、内容管理系统、企业内部系统、大数据分析后端。

# 安装驱动：pip install mysql-connector-python
import mysql.connector
conn = mysql.connector.connect(
  host='localhost',
  user='root',
  password='your_password',
  database='school_db'
)
cursor = conn.cursor()
# 创建表
cursor.execute('''
CREATE TABLE IF NOT EXISTS courses (
    course_id INT PRIMARY KEY AUTO_INCREMENT,
    title VARCHAR(100) NOT NULL,
    credits INT DEFAULT 3,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
)
''')
# 批量插入
courses = [
  ('Python编程基础', 4),
  ('数据库原理与应用', 3),
  ('数据结构与算法', 5)
]
cursor.executemany(
  "INSERT INTO courses (title, credits) VALUES (%s, %s)",
  courses
)
conn.commit()
print(f"✅ 插入了 {cursor.rowcount} 门课程")
# 关联查询示例
cursor.execute('''
SELECT s.name, c.title, sc.score
FROM students s
JOIN scores sc ON s.id = sc.student_id
JOIN courses c ON sc.course_id = c.course_id
WHERE sc.score >= 90
''')
for row in cursor.fetchall():
    print(row)
cursor.close()
conn.close()
        

✅ 核心优势：高并发读写性能强、主从复制支持、丰富的存储引擎（InnoDB/MyISAM）；
⚠️ 注意：需单独安装MySQL服务，生产环境需配置连接池（如`mysql-connector-pool`）。

PostgreSQL：开源数据库的“瑞士军刀”

PostgreSQL被誉为“世界上最先进的开源数据库”，支持JSON、地理空间数据、全文搜索、窗口函数等高级特性，是数据科学与复杂业务系统的理想选择。

适用场景：地理信息系统（GIS）、金融风控系统、大数据分析平台、需要复杂查询的业务系统。

# 安装驱动：pip install psycopg2-binary
import psycopg2
conn = psycopg2.connect(
  host='localhost',
  database='geo_db',
  user='postgres',
  password='your_password'
)
cursor = conn.cursor()
# 创建地理空间表（需PostGIS扩展）
cursor.execute('''
CREATE TABLE IF NOT EXISTS cities (
    id SERIAL PRIMARY KEY,
    name VARCHAR(50),
    location GEOGRAPHY(POINT, 4326)
)
''')
# 插入坐标点数据（北京、上海）
cursor.execute("INSERT INTO cities (name, location) VALUES (%s, ST_PointFromText('POINT(116.4074 39.9042)', 4326))", ('北京',))
cursor.execute("INSERT INTO cities (name, location) VALUES (%s, ST_PointFromText('POINT(121.4737 31.2304)', 4326))", ('上海',))
# 查询距离指定点500公里内的城市
cursor.execute('''
SELECT name, ST_Distance(location, ST_PointFromText('POINT(113.2644 23.1291)', 4326)) as distance_km
FROM cities
WHERE ST_DWithin(location, ST_PointFromText('POINT(113.2644 23.1291)', 4326), 500000)
ORDER BY distance_km
''')
for row in cursor.fetchall():
    print(f"城市: {row[0]}, 距离广州约 {row[1]:.1f} 公里")
cursor.close()
conn.close()
        

✅ 核心优势：强事务支持、ACID合规、丰富数据类型（JSON/Array/Geometry）、扩展生态完善；
⚠️ 学习成本：配置相对复杂，但Docker已大幅简化部署流程。

MongoDB：面向文档的NoSQL数据库

当数据结构灵活多变（如用户行为日志、IoT传感器数据）时，MongoDB用JSON-like的BSON文档替代传统表结构，通过Python的`pymongo`库可实现高效操作。

适用场景：实时分析系统、内容推荐引擎、聊天应用消息存储、日志聚合平台。

# 安装驱动：pip install pymongo
from pymongo import MongoClient
import datetime
client = MongoClient('mongodb://localhost:27017/')
db = client['news_app']
collection = db['articles']
# 插入嵌套文档（含数组）
article = {
  'title': 'Python数据库进阶指南',
  'author': {
    'name': '王老师',
    'email': 'teacher@python.com'
  },
  'tags': ['Python', 'Database', 'ORM'],
  'content': '本文深入探讨Python操作数据库的多种方式...',
  'created_at': datetime.datetime.utcnow()
}
result = collection.insert_one(article)
print(f"✅ 插入文档ID: {result.inserted_id}")
# 复合查询：查找特定标签的最近文章
recent_articles = collection.find({
  'tags': 'ORM',
  'created_at': {'$gte': datetime.datetime(2023, 1, 1)}
}).sort('created_at', -1).limit(5)
for doc in recent_articles:
    print(doc['title'])
        

✅ 核心优势：模式自由、水平扩展能力强、内置聚合管道；
⚠️ 注意：不支持强事务（4.0后支持多文档事务）、需注意数据一致性设计。

ORM框架实战：Python怎么写数据库的现代化方案

ORM（Object-Relational Mapping）将数据库表映射为Python类对象，让开发者用面向对象方式操作数据，大幅降低SQL出错率并提升开发效率。以下以Django ORM为核心展开。

年 • Django 4.2 LTS

Django ORM：企业级开发首选

Django ORM是Python生态中最成熟的ORM框架，提供完整的模型定义、查询、迁移、信号机制，支持SQLite/MySQL/PostgreSQL等主流数据库。

# models.py - 定义数据模型
from django.db import models
class Student(models.Model):
    name = models.CharField('姓名', max_length=50)
    age = models.IntegerField('年龄')
    major = models.CharField('专业', max_length='100', blank=True)
    enrolled_at = models.DateTimeField('入学时间', auto_now_add=True)
    class Meta:
        verbose_name = '学生'
        verbose_name_plural = '学生列表'
class Course(models.Model):
    title = models.CharField('课程名称', max_length=100)
    credits = models.IntegerField('学分', default=3)
    students = models.ManyToManyField('Student', related_name='courses')
# views.py - 操作数据
from .models import Student, Course
# 创建学生
zhangsan = Student.objects.create(name='张三', age=20, major='计算机')
# 创建课程并关联学生
python_db = Course.objects.create(title='Python数据库开发', credits=4)
python_db.students.add(zhangsan)
# 查询关联数据
for student in python_db.students.all():
    print(f"{student.name} 选修了 {python_db.title}")
            

? 关键特性：自动创建/更新数据库表结构（迁移）、查询集惰性求值、链式过滤、聚合函数、原生SQL嵌入。

年 • Peewee ORM：轻量级选择

Peewee ORM：微服务与脚本开发利器

Peewee比Django ORM更轻量，无需Django环境即可独立使用，适合小型项目或脚本工具开发。

# pip install peewee
from peewee import
db = SqliteDatabase('inventory.db')
class Product(Model):
    name = CharField()
    stock = IntegerField(default=0)
    price = DecimalField(max_digits=10, decimal_places=2)
    class Meta:
        database = db
# 初始化数据库表
db.create_tables([Product])
# 批量创建
products = [
  {'name': '无线鼠标', 'stock': 150, 'price': 59.90},
  {'name': '机械键盘', 'stock': 80, 'price': 399.00}
]
Product.insert_many(products).execute()
# 查询低库存商品
low_stock = Product.select().where(Product.stock < 100).order_by(Product.stock)
for p in low_stock:
    print(f"{p.name} 库存仅剩 {p.stock} 件，需补货！")
            

? 适用场景：小型Web应用、数据处理脚本、CLI工具开发。

年 • SQLAlchemy：灵活度天花板

SQLAlchemy：从简单到复杂的全场景支持

SQLAlchemy提供两层API：Core（原生SQL封装）和ORM（高级抽象），是需要精细控制SQL执行的高级开发者的首选。

# pip install sqlalchemy
from sqlalchemy import create_engine, Column, Integer, String
from sqlalchemy.orm import sessionmaker, declarative_base
Base = declarative_base()
class User(Base):
    __tablename__ = 'users'
    id = Column(Integer, primary_key=True)
    username = Column(String(50), unique=True)
    email = Column(String(100))
engine = create_engine('sqlite:///users.db')
Base.metadata.create_all(engine)
Session = sessionmaker(bind=engine)
session = Session()
# 添加用户
new_user = User(username='li_si', email='li.si@example.com')
session.add(new_user)
session.commit()
# 查询并更新
user = session.query(User).filter_by(username='li_si').first()
user.email = 'updated@example.com'
session.commit()
            

? 核心价值：支持复杂SQL构建、自定义类型、连接池管理、事件钩子，是构建高性能系统的底层基石。

对多关系：最常见业务模型

典型场景：“一个老师教多个学生”。在数据库中，通过在“多”方表添加外键指向“一”方主键实现。

# Django ORM模型定义
class Teacher(models.Model):
    name = models.CharField('姓名', max_length=50)
class Student(models.Model):
    name = models.CharField('姓名', max_length=50)
    teacher = models.ForeignKey(
        Teacher,
        on_delete=models.CASCADE,  # 删除老师时级联删除学生
        related_name='students'  # 反向查询：teacher.students.all()
    )
# 使用示例
teacher_wang = Teacher.objects.create(name='王老师')
Student.objects.create(name='张三', teacher=teacher_wang)
Student.objects.create(name='李四', teacher=teacher_wang)
# 查询王老师的学生
for student in teacher_wang.students.all():
    print(student.name)  # 输出：张三，李四
        

? 关键细节：
• on_delete行为选择：
  `CASCADE`（级联删除）：适合强依赖关系
  `PROTECT`（保护）：防止误删关联数据
  `SET_NULL`（置空）：保留历史记录，需`null=True`
• 建议对`ForeignKey`字段添加索引（Django自动创建）

对一关系：扩展信息分离存储

典型场景：“用户”与“用户档案”。将高频访问字段（用户名、密码）与低频字段（生日、地址）分离，优化查询性能。

# Django模型定义
class UserProfile(models.Model):
    user = models.OneToOneField(
        User,
        on_delete=models.CASCADE,
        related_name='profile'
    )
    bio = models.TextField('个人简介', blank=True)
    avatar = models.URLField('头像URL', blank=True)
    location = models.CharField('所在地', max_length=100, blank=True)
# 创建用户及档案
user = User.objects.create_user(username='zhangsan', password=...)
UserProfile.objects.create(
    user=user,
    bio='Python开发者，专注数据库优化',
    location='北京'
)
# 访问反向关系
print(user.profile.location)  # 自动JOIN查询
        

⚠️ 易错点：Django的`OneToOneField`本质上是`ForeignKey(unique=True)`，但语义更明确。若误用`ForeignKey`未加`unique=True`，将导致重复数据风险。

多对多关系：灵活关联的核心

典型场景：“学生选修多门课程”。Django自动创建中间表，支持自定义中间表以添加额外字段（如选课时间、成绩）。

# 方案1：自动中间表（简单场景）
class Course(models.Model):
    title = models.CharField(max_length=100)
    students = models.ManyToManyField('Student')
# 方案2：自定义中间表（需额外字段）
class Enrollment(models.Model):
    student = models.ForeignKey(Student, on_delete=models.CASCADE)
    course = models.ForeignKey(Course, on_delete=models.CASCADE)
    enrolled_at = models.DateTimeField(auto_now_add=True)
    grade = models.DecimalField(max_digits=5, decimal_places=2, null=True)
class Course(models.Model):
    title = models.CharField(max_length=100)
    students = models.ManyToManyField(
        Student,
        through='Enrollment',
        related_name='courses'
    )
# 创建选课记录
enrollment = Enrollment.objects.create(
    student=zhangsan,
    course=python_db,
    grade=92.5
)
# 查询学生选课及成绩
for e in zhangsan.enrollment_set.select_related('course'):
    print(f"{e.course.title}: {e.grade}分")
        

⚡ 性能优化：多对多查询易产生N+1问题，务必使用`select_related()`或`prefetch_related()`预加载关联数据。

性能优化实战：Python怎么写数据库的关键技巧

当数据量达到百万级时，再优雅的代码也会被慢查询拖垮。以下是从真实项目中总结的优化经验，助你构建高性能数据库应用。

避免N+1查询问题

问题现象：在循环中访问关联对象，每访问一次触发一次新SQL查询。

# ❌ 错误写法：1 + N次查询
for student in Student.objects.all():
    print(student.teacher.name)  # 每次循环都查一次teacher表
# ✅ 正确写法：仅2次查询
for student in Student.objects.select_related('teacher').all():
    print(student.teacher.name)  # 通过JOIN一次获取所有数据
          

合理使用索引

何时加索引：
• WHERE条件字段（如`WHERE status='active'`）
• JOIN关联字段（外键）
• ORDER BY排序字段
• UNIQUE约束字段

Django建模示例：

class Order(models.Model):
    status = models.CharField(max_length=20, db_index=True)  # 索引
    created_at = models.DateTimeField(db_index=True)  # 排序常用字段
    customer = models.ForeignKey(Customer, db_index=True)  # 外键自动建索引
          

⚠️ 注意：索引会降低写入性能，过多索引占用磁盘空间，需定期用`EXPLAIN`分析执行计划。

批量操作替代循环

问题对比：

# ❌ 每次insert执行一次SQL
for product in products:
    Product.objects.create(name=product['name'], price=product['price'])
# ✅ 一次SQL插入多行
Product.objects.bulk_create([
    Product(name=p['name'], price=p['price']) for p in products
])
          

效果：1000条数据插入，从20秒降至0.5秒。

分页查询防OOM

大表分页陷阱：`LIMIT 1000000, 10`会扫描100万+10行数据，性能极差。

优化方案：使用游标分页（基于ID的连续查询）

# 首次查询
first_page = Product.objects.order_by('id')[:10]
# 下一页查询（last_id为上一页最后一条记录的ID）
next_page = Product.objects.filter(id__gt=last_id).order_by('id')[:10]
          

✅ 优势：不随数据量增长而变慢，适合日志、评论等时间序列数据。

缓存热点数据

缓存策略：
• Redis缓存：高频查询结果（如首页商品列表）
• Django缓存框架：`cache.get()`/`cache.set()`
• 数据库查询缓存：MySQL的`query_cache_type`（注意版本兼容性）

# Django缓存示例
from django.core.cache import cache
def get_hot_products():
    products = cache.get('hot_products')
    if products is None:
        products = Product.objects.filter(rating__gte=4.5)[:20]
        cache.set('hot_products', products, timeout=300)  # 缓存5分钟
    return products
          

常见问题解答

Q1: Python怎么写数据库连接池？

A：生产环境必须使用连接池避免频繁创建/销毁连接。Django中配置：

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.mysql',
        'NAME': 'mydb',
        'USER': 'root',
        'PASSWORD': 'xxx',
        'OPTIONS': {
            'pool': {
                'min_size': 2,
                'max_size': 10,
                'timeout': 30,
            },
        },
    }
}
          

或使用`pymysqlpool`、`SQLAlchemy`内置连接池。

Q2: 如何安全处理用户输入防止SQL注入？

A：永远使用参数化查询，禁止拼接SQL！

# ❌ 危险写法
cursor.execute(f"SELECT  FROM users WHERE name = '{user_input}'")
# ✅ 安全写法
cursor.execute("SELECT  FROM users WHERE name = %s", (user_input,))
          

Django ORM默认使用参数化查询，但自定义SQL时务必注意！

Q3: 数据库迁移如何管理？

A：Django迁移系统（`makemigrations` + `migrate`）是行业标杆。核心原则：

每次模型变更必须生成新迁移文件
迁移文件应可回滚（避免`RunPython`无逆操作）
生产环境先测试迁移脚本，再执行
使用`--fake`谨慎处理历史数据不一致

Python怎么写数据库？Python 学库手把手教你从零构建数据世界