Python代码写好了，怎么连接数据库并保存数据？

在数据驱动的时代，将程序运行过程中产生的有价值的数据持久化存储是至关重要的环节，数据库作为最主流的持久化方案，为数据提供了结构化、高效、安全且可并发访问的存储与管理能力，Python 凭借其简洁的语法和强大的生态系统，使得与各类数据库的交互变得异常便捷，本文将系统性地介绍如何使用 Python 将数据保存到不同类型的数据库中，从基础流程到高级实践，旨在为开发者提供一份清晰、实用的指南。

核心流程：与数据库交互的通用步骤

无论您选择哪种数据库，使用 Python 进行数据保存通常都遵循一套相似的核心流程,理解这一通用模式是掌握数据库操作的关键。

1. 选择数据库与驱动：根据项目需求（如数据结构、并发量、一致性要求等）选择合适的数据库（如 SQLite, MySQL, PostgreSQL, MongoDB 等），为该数据库安装对应的 Python 驱动或库。
2. 建立连接：使用数据库连接信息（如地址、端口、用户名、密码、数据库名）创建一个连接对象，这个对象是 Python 与数据库沟通的桥梁。
3. 创建游标（Cursor）：在关系型数据库操作中，通常需要基于连接对象创建一个游标，游标用于执行 SQL 命令并遍历查询结果。
4. 编写并执行命令：构造 SQL（对于关系型数据库）或特定的数据库命令（对于 NoSQL），然后通过游标或连接对象执行该命令，对于插入数据，这通常是 INSERT 语句。
5. 提交事务：对于支持事务的数据库，执行修改数据的命令（如 INSERT, UPDATE, DELETE）后，必须显式地调用 commit() 方法,才能将更改永久保存到数据库中。
6. 关闭连接：操作完成后，务必关闭游标和数据库连接，以释放资源,避免连接泄漏。

常见数据库实践与代码示例

为了更直观地理解上述流程，下面我们将通过具体的代码示例,展示如何向几种主流数据库中保存数据。

轻量级关系型数据库：SQLite

SQLite 是一个内置在 Python 标准库中的、基于文件的轻量级数据库，无需安装服务器，非常适合小型应用、原型开发和本地数据存储。

import sqlite3
# 1. 建立连接（如果文件不存在会自动创建）
conn = sqlite3.connect('example.db')
# 2. 创建游标
cursor = conn.cursor()
# 3. 创建表（如果不存在）
cursor.execute('''
    CREATE TABLE IF NOT EXISTS users (
        id INTEGER PRIMARY KEY AUTOINCREMENT,
        name TEXT NOT NULL,
        email TEXT UNIQUE NOT NULL
    )
''')
# 4. 准备数据并执行插入命令
new_user = ('Alice', 'alice@example.com')
cursor.execute("INSERT INTO users (name, email) VALUES (?, ?)", new_user)
# 5. 提交事务
conn.commit()
# 6. 关闭连接
cursor.close()
conn.close()
print("数据已成功保存到 SQLite 数据库。")

注意：使用 作为占位符是防止 SQL 注入的最佳实践。

流行关系型数据库：MySQL

MySQL 是广泛应用的开源关系型数据库管理系统，适用于中大型 Web 应用，操作它需要安装额外的驱动库，如 mysql-connector-python。

# 首先安装库: pip install mysql-connector-python
import mysql.connector
from mysql.connector import Error
try:
    # 1. 建立连接
    conn = mysql.connector.connect(
        host='localhost',
        database='your_database',
        user='your_username',
        password='your_password'
    )
    if conn.is_connected():
        # 2. 创建游标
        cursor = conn.cursor()
        # 3. 执行插入命令
        insert_query = "INSERT INTO products (name, price) VALUES (%s, %s)"
        product_data = ('Laptop', 1200.50)
        cursor.execute(insert_query, product_data)
        # 4. 提交事务
        conn.commit()
        print(f"{cursor.rowcount} 条记录已插入到 products 表。")
except Error as e:
    print(f"数据库错误: {e}")
finally:
    # 5. 确保连接被关闭
    if 'conn' in locals() and conn.is_connected():
        cursor.close()
        conn.close()
        print("MySQL 连接已关闭。")

这里使用了 try...except...finally 结构，这是处理数据库连接健壮性的标准方式，能确保即使发生错误,连接资源也能被正确释放。

主流 NoSQL 数据库：MongoDB

MongoDB 是一个基于文档的 NoSQL 数据库，以其灵活的模式和水平扩展能力而闻名，与关系型数据库不同，它存储的是类似 JSON 的 BSON 文档。

# 首先安装库: pip install pymongo
from pymongo import MongoClient
# 1. 建立连接
client = MongoClient('mongodb://localhost:27017/')
# 2. 选择数据库和集合（相当于关系型数据库的表）
db = client['user_database']
collection = db['profiles']
# 3. 准备数据（Python 字典）
new_profile = {
    "username": "bob_the_builder",
    "age": 35,
    "skills": ["carpentry", "plumbing", "masonry"],
    "contact": {
        "email": "bob@example.com",
        "phone": "123-456-7890"
    }
}
# 4. 执行插入命令
result = collection.insert_one(new_profile)
# 5. 无需显式提交，insert_one 会立即执行
print(f"数据已插入，文档 ID: {result.inserted_id}")
# 6. 关闭连接
client.close()

可以看到，MongoDB 的操作方式更加 Pythonic，直接使用字典进行交互，无需编写 SQL 语句。

高级实践：使用 ORM 简化数据库操作

直接编写 SQL 语句虽然灵活，但也存在代码冗余、易于出错、数据库迁移困难等问题，对象关系映射（ORM）框架应运而生，它允许我们用 Python 对象来操作数据库表，从而将开发者从繁琐的 SQL 中解放出来，SQLAlchemy 是 Python 中最著名的 ORM 框架。

ORM 的核心优势：

• 抽象化：无需编写原生 SQL,用面向对象的方式思考数据模型。
• 安全性：ORM 内部会自动处理 SQL 注入问题。
• 可移植性：更容易在不同数据库后端（如 SQLite, MySQL, PostgreSQL）之间切换。

下表对比了原生 SQL 与 ORM 的主要区别：

特性	原生 SQL (DB-API)	ORM (如 SQLAlchemy)
操作方式	字符串形式的 SQL 语句	Python 类和对象的方法
类型安全	编译时无法检查，运行时易出错	IDE 可以提供代码补全和类型检查
数据库迁移	手动编写和管理 SQL 脚本	通常配合迁移工具（如 Alembic）自动化处理
学习曲线	需要掌握 SQL 语言	需要学习 ORM 框架的特定规则和 API
性能	理论上性能最优，可直接优化 SQL	可能有轻微性能开销，但通常可忽略

使用 SQLAlchemy 保存数据的示例：

# 首先安装库: pip install SQLAlchemy
from sqlalchemy import create_engine, Column, Integer, String
from sqlalchemy.orm import sessionmaker
from sqlalchemy.ext.declarative import declarative_base
# 1. 创建引擎和基类
Base = declarative_base()
engine = create_engine('sqlite:///orm_example.db')
# 2. 定义映射到表的类
class User(Base):
    __tablename__ = 'users'
    id = Column(Integer, primary_key=True)
    name = Column(String)
    email = Column(String, unique=True)
    def __repr__(self):
        return f"<User(name='{self.name}', email='{self.email}')>"
# 3. 创建表（如果不存在）
Base.metadata.create_all(engine)
# 4. 创建会话
Session = sessionmaker(bind=engine)
session = Session()
# 5. 创建对象并保存
new_user = User(name='Charlie', email='charlie@example.com')
session.add(new_user)
session.commit() # 提交事务
print(f"ORM 方式保存成功，用户 ID: {new_user.id}")
# 6. 关闭会话
session.close()

相关问答 FAQs

问题1：我应该选择 SQLite 还是 MySQL？

解答：这取决于您的应用场景。SQLite 是一个无服务器、基于文件的数据库，它的优势在于轻量、零配置、易于部署,非常适合以下情况：

• 桌面或移动应用的本地数据存储。
• 小型网站或原型项目的后端。
• 需要进行本地数据分析和处理的脚本。
• 对并发写入要求不高的应用。

而 MySQL 是一个功能强大的客户端/服务器数据库,适用于：

• 需要高并发、高可用性和高扩展性的 Web 应用。
• 多个应用程序或服务需要同时访问同一个数据库。
• 需要精细的权限管理和用户控制的系统。
• 数据量巨大,需要复杂的查询和优化的场景。

简而言之，SQLite 用于“本地”和“小型”，MySQL 用于“远程”和“大型”。

问题2：什么时候应该使用 ORM 而不是原生 SQL？

解答：这是一个在开发中常见的权衡。在以下情况下，强烈推荐使用 ORM：

• 快速开发：ORM 能显著减少样板代码,让你更专注于业务逻辑。
• 团队协作：ORM 提供了统一的数据访问层，降低了团队成员编写不规范 SQL 的风险。
• 数据库无关性：未来可能需要更换数据库后端的项目，ORM 可以极大地降低迁移成本。
• 安全性：ORM 自动处理参数化查询，能有效防止 SQL 注入攻击。

而在以下情况下，可以考虑使用原生 SQL：

• 性能极致优化：对于非常复杂的查询或性能瓶颈点，手写优化的 SQL 可能比 ORM 生成的更高效。
• 利用数据库特定功能：需要使用某些数据库独有的高级特性或函数，而 ORM 可能不支持。
• 简单的、一次性的脚本：对于一个只执行几次的简单数据导入脚本，引入 ORM 可能显得“杀鸡用牛刀”。

在实践中，很多项目会采用混合模式：主要业务逻辑使用 ORM，而在少数性能关键或需要特殊功能的场景下，通过 ORM 提供的接口执行原生 SQL。