【Python百宝箱】数据舞台：Python数据库实战手册_【python百宝箱】数据舞台:python数据库实战手册-CSDN博客

本文链接：https://blog.csdn.net/qq_42531954/article/details/134680937

前言

在现代软件开发中，数据的存储和管理是至关重要的一环。Python作为一门广泛应用于各种领域的编程语言，拥有丰富而强大的数据库相关库，能够满足不同项目的需求。本文将深入研究几个重要的Python数据库库，涵盖了关系型数据库、文档数据库、键值存储等多个领域。通过学习这些库，读者将能够更灵活地处理各种数据库需求，提高项目的稳定性和可维护性。

数据存储和数据库：Python库全面解析

欢迎订阅专栏：Python库百宝箱：解锁编程的神奇世界

1. `sqlite3`

1.1 基本介绍

SQLite3是一种轻量级关系型数据库，以其简单的部署和管理而受到欢迎。它是一个零配置的数据库引擎，适用于小型项目和嵌入式系统。SQLite3的数据库是一个单一的普通文件，这使得它在各种场景下都具备灵活性和便携性。

1.2 使用示例

1.2.1 数据库连接与创建

import sqlite3

# 连接数据库（如果不存在则创建）
conn = sqlite3.connect('example.db')

# 创建一个游标对象
cursor = conn.cursor()

# 执行SQL语句，创建一个表
cursor.execute('''
    CREATE TABLE IF NOT EXISTS users (
        id INTEGER PRIMARY KEY,
        username TEXT NOT NULL,
        email TEXT NOT NULL
    )
''')

# 提交更改并关闭连接
conn.commit()
conn.close()

1.2.2 表的创建与数据操作

# 连接数据库
conn = sqlite3.connect('example.db')
cursor = conn.cursor()

# 插入数据
cursor.execute("INSERT INTO users (username, email) VALUES (?, ?)", ('john_doe', 'john@example.com'))

# 查询数据
cursor.execute("SELECT * FROM users")
rows = cursor.fetchall()
for row in rows:
    print(row)

# 关闭连接
conn.close()

1.3 注意事项

1.3.1 并发性与性能考虑

SQLite3在高并发写入场景下性能可能有限，适用于小规模项目或者读操作较多的场景。

1.3.2 数据类型与约束

SQLite3支持的数据类型有限，需要谨慎选择。同时，约束的使用能够保证数据的完整性，例如PRIMARY KEY、NOT NULL等。

1.4 数据查询与条件过滤

SQLite3提供了灵活的查询语句，允许你从表中检索特定的数据或根据条件过滤数据。

查询所有数据

# 连接数据库
conn = sqlite3.connect('example.db')
cursor = conn.cursor()

# 查询所有数据
cursor.execute("SELECT * FROM users")
rows = cursor.fetchall()
for row in rows:
    print(row)

# 关闭连接
conn.close()

查询特定条件的数据

# 连接数据库
conn = sqlite3.connect('example.db')
cursor = conn.cursor()

# 查询年龄大于等于 25 的用户
cursor.execute("SELECT * FROM users WHERE age >= ?", (25,))
rows = cursor.fetchall()
for row in rows:
    print(row)

# 关闭连接
conn.close()

在这个例子中，我们通过在查询中使用WHERE子句，以及使用占位符和参数的方式，过滤了年龄大于等于25的用户数据。

1.5 数据更新与删除

SQLite3允许通过UPDATE语句更新现有数据，以及通过DELETE语句删除数据。

更新数据

# 连接数据库
conn = sqlite3.connect('example.db')
cursor = conn.cursor()

# 更新用户名为'john_doe'的用户邮箱
cursor.execute("UPDATE users SET email = ? WHERE username = ?", ('new_email@example.com', 'john_doe'))

# 提交更改
conn.commit()

# 关闭连接
conn.close()

删除数据

# 连接数据库
conn = sqlite3.connect('example.db')
cursor = conn.cursor()

# 删除用户名为'john_doe'的用户
cursor.execute("DELETE FROM users WHERE username = ?", ('john_doe',))

# 提交更改
conn.commit()

# 关闭连接
conn.close()

这两个示例展示了如何更新和删除数据库中的数据，通过使用UPDATE和DELETE语句，以及适当的条件进行过滤。

1.6 事务处理

SQLite3支持事务处理，允许将一系列的数据库操作作为一个原子操作执行，要么全部执行成功，要么全部失败，从而保持数据的一致性。

# 连接数据库
conn = sqlite3.connect('example.db')
cursor = conn.cursor()

# 开始事务
cursor.execute("BEGIN")

try:
    # 执行多个操作
    cursor.execute("INSERT INTO users (username, email) VALUES (?, ?)", ('new_user', 'new_user@example.com'))
    cursor.execute("UPDATE users SET age = 30 WHERE username = 'john_doe'")
    
    # 提交事务
    cursor.execute("COMMIT")
except Exception as e:
    # 回滚事务
    cursor.execute("ROLLBACK")
    print(f"Transaction failed: {e}")

# 关闭连接
conn.close()

在这个例子中，如果所有操作都成功执行，那么提交事务；如果任何一个操作失败，那么回滚事务，保持数据库的一致性。

1.7 数据库备份与恢复

SQLite3允许通过复制数据库文件的方式进行备份，从而实现简单的数据库备份和恢复。

备份数据库

import shutil

# 复制数据库文件到备份文件
shutil.copyfile('example.db', 'example_backup.db')

恢复数据库

# 复制备份文件到数据库文件
shutil.copyfile('example_backup.db', 'example.db')

这个简单的示例通过shutil模块实现了数据库的备份和恢复。在实际应用中，备份和恢复的过程可能需要更复杂的策略，特别是在生产环境中。

1.8 数据库连接池

在高并发的应用中，频繁地打开和关闭数据库连接可能会影响性能。使用连接池可以有效地管理数据库连接，提高性能并减少资源开销。

from sqlite3 import connect

# 使用连接池方式连接数据库
with connect('example.db', check_same_thread=False) as conn:
    cursor = conn.cursor()
    cursor.execute("SELECT * FROM users")
    rows = cursor.fetchall()
    for row in rows:
        print(row)

这个示例使用了SQLite3的内建连接池，通过connect函数创建连接对象，上下文管理器会在退出时自动关闭连接，从而更有效地管理数据库连接。

2. `sqlalchemy`

2.1 简介与特点

SQLAlchemy是一个SQL工具包和对象关系映射器（ORM），旨在简化数据库操作并提供更高级的抽象。它支持多种数据库后端，并且提供了强大的查询构建和ORM功能。

2.2 核心组件

2.2.1 `Engine`引擎

from sqlalchemy import create_engine

# 创建一个SQLite数据库引擎
engine = create_engine('sqlite:///example.db')

# 连接数据库
conn = engine.connect()

# 执行SQL查询
result = conn.execute("SELECT * FROM users")
for row in result:
    print(row)

# 关闭连接
conn.close()

2.2.2 `Session`会话

from sqlalchemy import create_engine, Column, Integer, String, Sequence
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker

# 创建一个SQLite数据库引擎
engine = create_engine('sqlite:///example.db')

# 创建一个基类
Base = declarative_base()

# 定义一个数据模型
class User(Base):
    __tablename__ = 'users'
    id = Column(Integer, Sequence('user_id_seq'), primary_key=True)
    username = Column(String(50), unique=True)
    email = Column(String(120), unique=True)

# 创建表
Base.metadata.create_all(engine)

# 创建一个Session类
Session = sessionmaker(bind=engine)

# 创建一个会话
session = Session()

# 插入数据
new_user = User(username='john_doe', email='john@example.com')
session.add(new_user)
session.commit()

# 查询数据
users = session.query(User).all()
for user in users:
    print(user.username, user.email)

# 关闭会话
session.close()

2.3 高级特性

2.3.1 查询构建与过滤

# 查询用户名为'john_doe'的用户
john = session.query(User).filter_by(username='john_doe').first()

# 使用LIKE进行模糊查询
users_like_john = session.query(User).filter(User.username.like('%john%')).all()

2.3.2 关系映射与外键

from sqlalchemy import ForeignKey
from sqlalchemy.orm import relationship

# 定义另一个数据模型
class Address(Base):
    __tablename__ = 'addresses'
    id = Column(Integer, primary_key=True)
    email = Column(String(120))
    user_id = Column(Integer, ForeignKey('users.id'))
    user = relationship('User', back_populates='addresses')

# 在User模型中添加关系
User.addresses = relationship('Address', order_by=Address.id, back_populates='user')

2.4 数据库迁移

数据库迁移是在应用的数据模型发生变化时，保持数据库结构与代码模型同步的过程。Flask-Migrate是一种常用的数据库迁移工具，它与SQLAlchemy很好地集成，使得数据库的版本控制和升级变得简单。

首先，安装Flask-Migrate：

pip install Flask-Migrate

接着，在Flask应用中进行初始化和配置：

from flask import Flask
from flask_sqlalchemy import SQLAlchemy
from flask_migrate import Migrate

app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///example.db'
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
db = SQLAlchemy(app)

# 初始化Migrate
migrate = Migrate(app, db)

现在，可以使用以下命令进行数据库迁移：

# 创建迁移文件
flask db init

# 生成迁移文件
flask db migrate

# 执行迁移
flask db upgrade

这些命令将创建迁移脚本、将模型更改应用到数据库，并升级数据库。这样，你可以轻松地保持数据库结构与代码模型的一致性。

2.5 Flask-Script管理数据库命令

除了Flask-Migrate，还可以使用Flask-Script进行更多的数据库管理操作。这包括创建数据库表、生成模型文件等任务。

首先，安装Flask-Script：

pip install Flask-Script

然后，在Flask应用中配置并使用Manager：

from flask import Flask
from flask_sqlalchemy import SQLAlchemy
from flask_script import Manager

app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///example.db'
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
db = SQLAlchemy(app)

# 初始化Manager
manager = Manager(app)
manager.add_command('db', MigrateCommand)

现在，可以通过以下命令执行各种数据库管理任务：

# 创建数据库表
python manage.py db init

# 生成迁移文件
python manage.py db migrate

# 执行迁移
python manage.py db upgrade

Flask-Script为开发者提供了更多灵活性，可以根据需要执行不同的数据库任务，使得数据库管理变得更加方便。

这些工具和命令使得使用SQLAlchemy进行数据库操作的过程更加顺畅和可维护。从简单的查询到复杂的关联，再到数据库迁移和管理，SQLAlchemy为开发者提供了全面的解决方案。

3. `pymongo`

3.1 MongoDB简介

MongoDB是一种NoSQL数据库，以其灵活的文档存储格式而著称。pymongo是MongoDB的官方Python驱动，使得Python开发者可以方便地与MongoDB进行交互。

3.2 `pymongo`基础操作

3.2.1 连接与数据库选择

from pymongo import MongoClient

# 连接MongoDB数据库
client = MongoClient('mongodb://localhost:27017/')

# 选择/创建数据库
db = client['exampledb']

3.2.2 集合操作与文档插入

# 获取集合（类似关系型数据库的表）
collection = db['users']

# 插入一条文档
user_data = {'username': 'john_doe', 'email': 'john@example.com'}
result = collection.insert_one(user_data)

# 查询所有文档
all_users = collection.find()
for user in all_users:
    print(user)

3.3 高级应用

3.3.1 查询与索引优化

# 创建索引
collection.create_index([('username', pymongo.ASCENDING)])

# 查询特定条件的文档
john = collection.find_one({'username': 'john_doe'})

3.3.2 聚合管道与地理空间查询

# 使用聚合管道进行复杂查询
pipeline = [
    {'$group': {'_id': '$username', 'count': {'$sum': 1}}},
    {'$sort': {'count': -1}},
    {'$limit': 10}
]

result = collection.aggregate(pipeline)

# 打印结果
for entry in result:
    print(entry)

# 地理空间查询示例
# 创建地理空间索引
collection.create_index([("location", pymongo.GEO2D)])

# 查询距离坐标(1, 1)不超过1000的文档
nearby_users = collection.find({
    "location": {
        "$near": {
            "$geometry": {
                "type": "Point",
                "coordinates": [1, 1]
            },
            "$maxDistance": 1000
        }
    }
})

# 打印结果
for user in nearby_users:
    print(user)

3.4 数据库迁移与管理

与关系型数据库不同，MongoDB通常不需要像迁移工具那样处理模式变更。MongoDB是一个文档存储数据库，更容易适应模式的变化。但在某些情况下，可能需要迁移数据或进行管理操作。

3.4.1 数据迁移

在MongoDB中，数据迁移通常是通过编写脚本或使用ETL（提取、转换、加载）工具完成的。例如，可以使用pymongo编写脚本来将数据从一个集合复制到另一个集合，同时进行任何必要的转换。

from pymongo import MongoClient

# 连接源和目标数据库
source_client = MongoClient('mongodb://localhost:27017/')
target_client = MongoClient('mongodb://localhost:27017/')

# 选择源和目标集合
source_collection = source_client['source_db']['source_collection']
target_collection = target_client['target_db']['target_collection']

# 复制数据
target_collection.insert_many(source_collection.find())

3.4.2 数据库管理

MongoDB提供了丰富的管理功能，可以通过MongoDB的官方工具或pymongo来执行。例如，可以使用pymongo来执行用户管理操作：

from pymongo import MongoClient

# 连接MongoDB数据库
client = MongoClient('mongodb://localhost:27017/')

# 选择admin数据库
admin_db = client.admin

# 创建新用户
admin_db.command("createUser", "new_user", pwd="password123", roles=["readWrite"])

这里创建了一个名为new_user的用户，并给予了读写权限。实际应用中，需要根据实际需求进行用户管理和权限控制。

3.5 MongoDB与关系型数据库的对比

MongoDB是一种NoSQL数据库，与传统的关系型数据库有一些重要的区别。下面是一些对比：

模式设计： MongoDB是模式自由的，文档可以包含不同的字段，而关系型数据库需要定义表结构和字段类型。
事务支持： 关系型数据库通常具备事务支持，而MongoDB在某些情况下（如复制集）支持事务，但不同于关系型数据库的全面事务。
性能： MongoDB在某些读写密集型场景下表现得更好，而关系型数据库在复杂查询和事务处理方面通常更强大。

4. `peewee`

4.1 概述与设计理念

Peewee是一个轻量级、简洁的Python ORM库，设计理念是提供简单、明确的API以及对常见数据库操作的优雅支持。它的语法类似于SQLAlchemy，但更注重简便和直观。

4.2 基本用法

4.2.1 模型定义与字段类型

from peewee import Model, SqliteDatabase, CharField, IntegerField

# 连接SQLite数据库
db = SqliteDatabase('example.db')

# 定义一个基础模型类
class BaseModel(Model):
    class Meta:
        database = db

# 定义User模型
class User(BaseModel):
    username = CharField(unique=True)
    email = CharField(unique=True)
    age = IntegerField()

4.2.2 数据库操作与查询

# 连接数据库并创建表
db.connect()
db.create_tables([User])

# 插入数据
new_user = User.create(username='john_doe', email='john@example.com', age=25)

# 查询数据
users = User.select()
for user in users:
    print(user.username, user.email, user.age)

4.3 进阶特性

4.3.1 事务处理与连接池

# 使用事务处理
with db.atomic():
    user1 = User.create(username='user1', email='user1@example.com', age=30)
    user2 = User.create(username='user2', email='user2@example.com', age=35)
    
# 使用连接池
db.close()  # 关闭连接
db.connect()  # 重新连接

4.3.2 数据库迁移与反向工程

Peewee提供了pwiz命令来进行数据库反向工程，生成模型类。

# 在命令行中执行
pwiz.py example.db > models.py

这将基于现有数据库生成对应的模型类文件 models.py。

4.4 模型关系与复杂查询

Peewee支持定义模型之间的关系，如一对一、一对多和多对多。以下是一个简单的示例：

from peewee import ForeignKeyField, TextField

# 定义另一个模型
class Post(BaseModel):
    user = ForeignKeyField(User, backref='posts')
    content = TextField()

# 插入数据
new_post = Post.create(user=new_user, content='This is a sample post.')

# 查询用户的所有帖子
user_posts = new_user.posts
for post in user_posts:
    print(post.content)

Peewee还提供了强大的查询构建器，支持复杂的查询操作：

# 查询年龄大于等于 30 岁的用户
users_over_30 = User.select().where(User.age >= 30)

# 查询用户以 'john' 开头且邮箱以 'example' 结尾的用户
specific_users = User.select().where(
    (User.username.startswith('john')) & (User.email.endswith('example.com'))
)

4.5 注意事项

4.5.1 性能考虑

尽管Peewee是一个轻量级的ORM库，但在处理大规模数据和复杂查询时，仍需要注意性能。合理使用索引、避免过多的查询以及优化数据模型都是提高性能的关键。

4.5.2 数据迁移

Peewee提供了迁移工具 pw_migrate，可以方便地管理数据库模型的变更。在修改模型后，可以使用迁移工具来同步数据库。

# 创建迁移
python migrate.py -c 'sqlite:///example.db' create

# 应用迁移
python migrate.py -c 'sqlite:///example.db' migrate

这里假设迁移工具的配置文件是 migrate.py，并且数据库使用SQLite。根据实际情况修改配置文件和数据库连接信息。

5. `redis-py`

5.1 简介与特点

redis-py是Redis数据库的官方Python客户端，提供了与Redis服务器进行交互的功能。Redis是一种基于内存的键值存储数据库，常用于缓存和消息队列等场景。

5.2 基本用法

5.2.1 连接与数据操作

import redis

# 连接到本地Redis服务器
r = redis.StrictRedis(host='localhost', port=6379, db=0)

# 设置键值对
r.set('key', 'value')

# 获取值
value = r.get('key')
print(value.decode('utf-8'))

5.2.2 列表操作

# 在列表左侧插入元素
r.lpush('mylist', 'a')
r.lpush('mylist', 'b', 'c')

# 获取列表元素
elements = r.lrange('mylist', 0, -1)
print(elements)

5.3 高级特性

5.3.1 发布与订阅

# 订阅频道
pubsub = r.pubsub()
pubsub.subscribe('my_channel')

# 发布消息
r.publish('my_channel', 'Hello, subscribers!')

# 监听消息
for message in pubsub.listen():
    print(message)

5.3.2 事务与管道

# 使用事务
with r.pipeline() as pipe:
    # 开启事务
    pipe.multi()
    
    # 执行多个命令
    pipe.set('key1', 'value1')
    pipe.set('key2', 'value2')
    
    # 提交事务
    pipe.execute()

6. `django`

6.1 简介与特点

Django是一个高级的Python Web框架，内置了对象关系映射（ORM）系统，允许开发者使用Python代码定义数据模型，并与数据库进行交互。它支持多种数据库后端，包括但不限于SQLite、PostgreSQL、MySQL。

6.2 数据模型定义

from django.db import models

# 定义User模型
class User(models.Model):
    username = models.CharField(max_length=30, unique=True)
    email = models.EmailField(unique=True)
    age = models.IntegerField()

6.3 数据库迁移与查询

# 创建迁移文件
python manage.py makemigrations

# 应用迁移
python manage.py migrate

# 查询数据
users = User.objects.all()
for user in users:
    print(user.username, user.email, user.age)

6.4 管理后台

Django提供了内置的管理后台，可以通过简单配置让开发者轻松管理数据库中的数据。

# admin.py
from django.contrib import admin
from .models import User

admin.site.register(User)

7. `Flask-SQLAlchemy`

7.1 简介与特点

Flask-SQLAlchemy是Flask框架的扩展，为开发者提供了在Flask应用中轻松使用SQLAlchemy进行数据库操作的功能。它结合了Flask的简洁性和SQLAlchemy的强大性，为Web应用提供了强大的数据库支持。

7.2 基本用法

7.2.1 安装与配置

首先，需要安装Flask-SQLAlchemy扩展：

pip install Flask-SQLAlchemy

然后，在Flask应用中进行配置：

from flask import Flask
from flask_sqlalchemy import SQLAlchemy

app = Flask(__name__)

# 配置数据库连接地址
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///example.db'
# 关闭追踪数据库修改的功能，以提升性能
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False

# 创建一个SQLAlchemy实例
db = SQLAlchemy(app)

7.2.2 数据模型定义与使用

# 定义User模型
class User(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    username = db.Column(db.String(30), unique=True, nullable=False)
    email = db.Column(db.String(120), unique=True, nullable=False)

# 创建数据库表
db.create_all()

# 插入数据
new_user = User(username='john_doe', email='john@example.com')
db.session.add(new_user)
db.session.commit()

# 查询数据
users = User.query.all()
for user in users:
    print(user.username, user.email)

7.3 高级特性

7.3.1 数据库迁移

Flask-Migrate扩展可以帮助进行数据库迁移，即在数据模型发生变化时更新数据库。

# 安装Flask-Migrate
pip install Flask-Migrate

from flask import Flask
from flask_sqlalchemy import SQLAlchemy
from flask_migrate import Migrate

app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///example.db'
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
db = SQLAlchemy(app)

# 初始化Migrate
migrate = Migrate(app, db)

然后，可以通过以下命令进行数据库迁移：

flask db init
flask db migrate
flask db upgrade

7.3.2 Flask-Script管理数据库命令

Flask-Script是Flask的一个扩展，提供了一套用于处理命令行任务的工具，可以用于创建和管理数据库。

# 安装Flask-Script
pip install Flask-Script

from flask import Flask
from flask_sqlalchemy import SQLAlchemy
from flask_script import Manager

app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///example.db'
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
db = SQLAlchemy(app)

# 初始化Manager
manager = Manager(app)
manager.add_command('db', MigrateCommand)

然后，可以通过以下命令进行数据库相关操作：

# 创建数据库表
python manage.py db init

# 生成迁移文件
python manage.py db migrate

# 执行迁移
python manage.py db upgrade

Flask-SQLAlchemy为Flask开发者提供了强大的数据库支持，使得数据库操作变得简单而高效。结合了SQLAlchemy的灵活性和Flask的简洁性，使得开发者能够更专注于业务逻辑的实现。

总结

通过深入学习这些库，读者将能够更加灵活地应对不同类型的数据库需求，提高项目的可维护性和稳定性。这些库涵盖了关系型数据库、文档数据库、键值存储等多个领域，无论是初学者还是有一定经验的开发者，都能在这篇文章中找到适合自己项目的解决方案。打破数据库的局限，发挥Python库的威力，为数据存储的世界带来新的可能性。