关于Python：7. Python数据库操作

一、sqlite3（轻量级本地数据库）

sqlite3 是 Python 内置的模块，用于操作 SQLite 数据库。

• SQLite 是一个轻量级、零配置的关系型数据库系统，整个数据库保存在一个文件中，适合小型项目和本地存储。

• SQLite 不需要安装服务器，打开即可用，跨平台。

Python 内置了 sqlite3 模块，无需安装。

1. 主要特点

特点	描述
零配置	不需要安装数据库服务器
跨平台	Windows、Linux、Mac 通用
单文件存储	数据库是一个 .db 文件
SQL 兼容性强	支持大部分 SQL 语法
嵌入式	可嵌入任何应用，无需联网
适合本地小项目	如桌面应用、原型系统、小型管理系统

2. 基本使用流程

2.1. 导入模块 & 连接数据库

import sqlite3

# 自动创建/连接数据库文件
conn = sqlite3.connect('example.db')  # 文件名可自定义

2.2. 创建游标对象（操作数据库）

cursor = conn.cursor()

2.3. 创建表（如果不存在）

cursor.execute('''
CREATE TABLE IF NOT EXISTS users (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    name TEXT NOT NULL,
    age INTEGER
)
''')

2.4. 插入数据

cursor.execute("INSERT INTO users (name, age) VALUES (?, ?)", ("Alice", 25))

使用 ? 占位符是为了防止 SQL 注入攻击。

2.5. 查询数据

cursor.execute("SELECT * FROM users")
rows = cursor.fetchall()
for row in rows:
    print(row)

2.6. 更新与删除数据

cursor.execute("UPDATE users SET age = ? WHERE name = ?", (30, "Alice"))
cursor.execute("DELETE FROM users WHERE name = ?", ("Alice",))

2.7. 提交事务 & 关闭连接

conn.commit()  # 一定要 commit 否则数据不会保存
conn.close()

3. 事务机制

SQLite 支持事务，默认处于自动提交模式，但你也可以手动控制：

conn = sqlite3.connect('example.db')
cursor = conn.cursor()

try:
    cursor.execute("BEGIN")
    cursor.execute("UPDATE users SET age = age + 1")
    conn.commit()  # 成功就提交
except Exception as e:
    conn.rollback()  # 出错就回滚
    print("错误：", e)

conn.close()

4. fetch 方法详解

fetchone()     # 获取一行结果
fetchall()     # 获取所有结果
fetchmany(n)   # 获取 n 行

5. 数据库文件位置

默认会在当前 Python 脚本目录下生成 .db 文件。你可以自定义路径：

conn = sqlite3.connect(r"C:\Users\你的目录\mydata.db")

6.  一些注意事项

问题	原因/解决办法
忘记 conn.commit()	改动不会保存！
多线程写冲突	SQLite 本质是单线程写，慎用多线程并发写入
类型不严格	SQLite 是动态类型系统，不会报类型错（如 age 可以写成 'abc'）
SQL 注入风险	尽量使用 ? 占位符，不拼接 SQL 字符串
同时打开多个连接	会出现锁，建议用单连接或 with 语句管理资源

7. 用 with 自动关闭连接和提交事务（推荐）

with sqlite3.connect('example.db') as conn:
    cursor = conn.cursor()
    cursor.execute("INSERT INTO users (name, age) VALUES (?, ?)", ("Tom", 22))
    conn.commit()

8. 高级功能

使用 row_factory 获取字典而不是元组

conn = sqlite3.connect('example.db')
conn.row_factory = sqlite3.Row
cursor = conn.cursor()

cursor.execute("SELECT * FROM users")
row = cursor.fetchone()
print(dict(row))  # {'id': 1, 'name': 'Tom', 'age': 22}

导入 CSV 文件、使用索引、JOIN 多表等高级 SQL 特性，SQLite 全部支持。

---

二、MySQL（主流数据库）

MySQL 是目前最流行的开源关系型数据库，适用于各类 Web 项目，支持高并发、高性能访问。

Python 操作 MySQL 通常有两种主流库：

库名	优点
pymysql	纯 Python 实现，使用最广，轻量好用
mysql-connector-python	官方提供，稳定性高

以下使用 pymysql 为主讲解。

1. 环境准备

pip install pymysql

安装 MySQL 数据库

• Windows 可以安装 MySQL Community Edition

• macOS 可用 brew install mysql

• Linux 可以使用 apt 或 yum

下载地址：https://downloads.mysql.com/archives/workbench/

确保运行后，可以通过以下方式登录：

mysql -u root -p

2. 连接数据库

import pymysql

conn = pymysql.connect(
    host='localhost',
    user='root',
    password='你的密码',
    database='testdb',
    port=3306,  # 默认端口
    charset='utf8mb4'
)

cursor = conn.cursor()

3. 建表和插入数据

创建表：

cursor.execute('''
CREATE TABLE IF NOT EXISTS users (
    id INT AUTO_INCREMENT PRIMARY KEY,
    name VARCHAR(50) NOT NULL,
    age INT
)
''')

插入数据：

cursor.execute("INSERT INTO users (name, age) VALUES (%s, %s)", ("Alice", 25))
conn.commit()

4. 查询数据

查询所有：

cursor.execute("SELECT * FROM users")
rows = cursor.fetchall()

for row in rows:
    print(row)

查询一条：

cursor.execute("SELECT * FROM users WHERE name = %s", ("Alice",))
row = cursor.fetchone()
print(row)

5. 更新与删除

# 更新
cursor.execute("UPDATE users SET age = %s WHERE name = %s", (30, "Alice"))

# 删除
cursor.execute("DELETE FROM users WHERE name = %s", ("Alice",))

conn.commit()

6. 事务处理

try:
    cursor.execute("BEGIN")
    cursor.execute("UPDATE users SET age = age + 1")
    conn.commit()
except Exception as e:
    conn.rollback()
    print("事务回滚：", e)

7. 批量操作

data = [("Tom", 20), ("Jack", 22), ("Lily", 18)]
cursor.executemany("INSERT INTO users (name, age) VALUES (%s, %s)", data)
conn.commit()

8. 关闭资源

cursor.close()
conn.close()

或者使用 with 管理：

with pymysql.connect(...) as conn:
    with conn.cursor() as cursor:
        cursor.execute("SELECT * FROM users")

9. 常见问题

问题	解决方案
报错：Access denied	检查用户名、密码是否正确；用户是否有访问权限
中文乱码	使用 charset='utf8mb4'；建表时列加 CHARACTER SET utf8mb4
插入 SQL 注入问题	使用 %s 占位符，不拼接 SQL
MySQL server has gone away	长连接断了，建议短连接或设置 wait_timeout

10. 进阶功能

使用 DictCursor 获取字典而不是元组

cursor = conn.cursor(pymysql.cursors.DictCursor)
cursor.execute("SELECT * FROM users")
row = cursor.fetchone()
print(row['name'])  # 字典形式

使用连接池（推荐中大型项目）

使用 DBUtils 实现连接池：

pip install DBUtils

from DBUtils.PooledDB import PooledDB

pool = PooledDB(
    creator=pymysql,
    maxconnections=5,
    host='localhost',
    user='root',
    password='123456',
    database='testdb',
    charset='utf8mb4'
)

conn = pool.connection()
cursor = conn.cursor()

11. 项目目标：用户注册与登录系统

功能包括：

• 用户注册（用户名+密码）
• 用户登录（验证用户名和密码）
• 数据存入 MySQL 数据库
• 密码加密存储（用 hashlib）

准备工作

安装 pymysql：

pip install pymysql

创建数据库和表（进入 MySQL）：

CREATE DATABASE IF NOT EXISTS userdb CHARACTER SET utf8mb4;

USE userdb;

CREATE TABLE IF NOT EXISTS users (
    id INT AUTO_INCREMENT PRIMARY KEY,
    username VARCHAR(50) UNIQUE NOT NULL,
    password_hash VARCHAR(128) NOT NULL
);

完整示例代码（含注册和登录功能）

import pymysql
import hashlib

# 数据库连接参数
conn = pymysql.connect(
    host='localhost',
    user='root',
    password='你的MySQL密码',
    database='userdb',
    charset='utf8mb4'
)

cursor = conn.cursor()


# 密码加密函数（MD5 示例）
def hash_password(password):
    return hashlib.md5(password.encode()).hexdigest()


# 注册功能
def register(username, password):
    cursor.execute("SELECT * FROM users WHERE username = %s", (username,))
    if cursor.fetchone():
        print("用户名已存在")
        return

    hashed_pwd = hash_password(password)
    cursor.execute("INSERT INTO users (username, password_hash) VALUES (%s, %s)", (username, hashed_pwd))
    conn.commit()
    print("注册成功")


# 登录功能
def login(username, password):
    hashed_pwd = hash_password(password)
    cursor.execute("SELECT * FROM users WHERE username = %s AND password_hash = %s", (username, hashed_pwd))
    if cursor.fetchone():
        print("登录成功")
    else:
        print("登录失败，用户名或密码错误")


# 测试运行
while True:
    print("\n== 用户系统 ==")
    print("1. 注册")
    print("2. 登录")
    print("0. 退出")
    choice = input("请输入选项：")

    if choice == "1":
        u = input("用户名：")
        p = input("密码：")
        register(u, p)
    elif choice == "2":
        u = input("用户名：")
        p = input("密码：")
        login(u, p)
    elif choice == "0":
        break
    else:
        print("无效的选项")

# 关闭连接
cursor.close()
conn.close()

运行效果：

== 用户系统 ==
1. 注册
2. 登录
0. 退出
请输入选项：1
用户名：alice
密码：123456
注册成功

== 用户系统 ==
1. 注册
2. 登录
0. 退出
请输入选项：2
用户名：alice
密码：123456
登录成功

---

三、PostgreSQL

PostgreSQL（简称 Postgres）是一个功能强大、开源的 关系型数据库管理系统（RDBMS），以 稳定性强、功能丰富 著称，被广泛用于金融、科研、大数据等领域。

1. PostgreSQL 的核心特点

特性	描述
开源免费	完全开源，企业级能力，全球社区活跃维护
SQL 标准支持好	支持大量 SQL 标准语法、窗口函数、CTE 等复杂查询
数据完整性强	支持外键、唯一性、检查约束、触发器等
支持 JSON / XML / GIS	可当半结构化数据库（文档型/地理型数据库）使用
扩展性强	支持插件、扩展（如 postgis、pgvector）
支持事务和并发	完整的 ACID 特性，MVCC（多版本并发控制）确保并发性能

2. PostgreSQL 安装

Windows / macOS：
官网下载安装包：PostgreSQL: Downloads

Ubuntu：

sudo apt update
sudo apt install postgresql postgresql-contrib

默认会创建一个系统用户：postgres，初始登录：

sudo -u postgres psql

3. Python 操作 PostgreSQL —— 使用 psycopg2

安装：

pip install psycopg2

如果安装失败，可尝试：

pip install psycopg2-binary

4. 基本使用示例（增删查改）

连接数据库

import psycopg2

conn = psycopg2.connect(
    dbname='yourdb',
    user='youruser',
    password='yourpass',
    host='localhost',
    port=5432
)

cursor = conn.cursor()

创建表

cursor.execute('''
CREATE TABLE IF NOT EXISTS users (
    id SERIAL PRIMARY KEY,
    username VARCHAR(50) UNIQUE NOT NULL,
    age INT
)
''')
conn.commit()

插入数据

cursor.execute("INSERT INTO users (username, age) VALUES (%s, %s)", ("Alice", 23))
conn.commit()

查询数据

cursor.execute("SELECT * FROM users")
rows = cursor.fetchall()
for row in rows:
    print(row)

更新 & 删除

cursor.execute("UPDATE users SET age = %s WHERE username = %s", (30, "Alice"))
cursor.execute("DELETE FROM users WHERE username = %s", ("Alice",))
conn.commit()

关闭连接

cursor.close()
conn.close()

5. 与mysql技术对比

特性	MySQL	PostgreSQL
性能	写入快，轻量级，适合读多写少	更适合复杂查询和写多读少的情况
事务 & ACID	支持（InnoDB 引擎）	更严格、全面的 ACID 支持
扩展性	较差，定制性低	非常强，支持自定义函数、类型等
JSON 支持	有但较弱	原生 JSONB 支持，功能强大
GIS 支持	有	更强，PostGIS 非常强大

---

四、SQLAlchemy（ORM框架）

SQLAlchemy 介绍

SQLAlchemy 是 Python 中最流行的 ORM（对象关系映射）框架，它将数据库中的数据表映射到 Python 类，并使得我们可以通过 Python 代码对数据库进行增删改查（CRUD）操作，而不必直接编写 SQL 语句。SQLAlchemy 提供了高度抽象化的 API，使得开发者在处理数据库操作时更加简洁、直观。

SQLAlchemy 主要有两个核心部分：

1. SQLAlchemy Core：提供低级别的数据库交互 API，适合需要完全控制 SQL 生成和执行的高级用户。

2. SQLAlchemy ORM：建立在 SQLAlchemy Core 之上，是高层的对象关系映射工具，帮助我们更轻松地通过 Python 类与数据库交互。

SQLAlchemy ORM 是大多数开发者使用的部分。

1. 核心概念

模型（Model） 和 表（Table）：在 SQLAlchemy 中，表格（Table）是数据库中的实际表，而模型（Model）是 Python 类，它通过映射将数据库表的列映射为类的属性。

Session：Session 是数据库连接的管理者，负责管理对象的生命周期和数据的持久化。通过 Session 对象，我们可以添加、删除、更新数据库中的记录，并提交（commit）这些操作。

Query：Query 对象用于执行数据库查询。通过 Query 对象，你可以过滤数据、选择字段、排序、聚合等操作。

2. 基础示例

通过一个简单的 用户管理系统 来演示如何使用 SQLAlchemy 进行操作。

1）安装 SQLAlchemy 和数据库驱动

pip install sqlalchemy
pip install psycopg2  # PostgreSQL 驱动，若使用 MySQL，换成 pymysql

2）定义模型

首先，我们定义数据库表和映射的 Python 类。

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

Base = declarative_base()  # 声明基础类

# 定义一个 User 表对应的 Python 类
class User(Base):
    __tablename__ = 'users'  # 数据库中的表名
    
    id = Column(Integer, primary_key=True)
    name = Column(String)
    age = Column(Integer)
    
# 创建数据库引擎，SQLite 本地数据库
engine = create_engine('sqlite:///example.db')  # PostgreSQL/MySQL 需要替换数据库URL

# 创建数据库表
Base.metadata.create_all(engine)

• Base 是一个基类，所有的模型都应该继承它。

• User 类表示了数据库中的一个 users 表，并定义了表的结构（字段）。

• engine 是数据库的引擎，负责连接数据库。我们使用 sqlite:///example.db 创建了一个本地 SQLite 数据库，你可以根据需要替换为其他数据库连接字符串。

3）创建 Session 和 数据库操作

然后，我们使用 Session 来进行数据的增删改查。

# 创建 Session 类
Session = sessionmaker(bind=engine)
session = Session()

# 插入数据
new_user = User(name="Alice", age=25)
session.add(new_user)
session.commit()  # 提交到数据库

# 查询数据
users = session.query(User).filter_by(name="Alice").all()
print(users)

# 更新数据
user_to_update = session.query(User).filter_by(name="Alice").first()
user_to_update.age = 26
session.commit()

# 删除数据
user_to_delete = session.query(User).filter_by(name="Alice").first()
session.delete(user_to_delete)
session.commit()

# 关闭 Session
session.close()

• 插入数据：通过 session.add() 方法添加新用户，然后使用 session.commit() 提交到数据库。

• 查询数据：通过 session.query() 方法查询数据，并使用 .filter_by() 过滤条件。

• 更新数据：查询到用户后直接修改其属性，再调用 session.commit() 提交。

• 删除数据：通过 session.delete() 删除查询到的对象。

4.）通过 SQLAlchemy 操作数据库

以上的操作都是基于 Python 类的操作，但 SQLAlchemy 会自动生成对应的 SQL 语句，如 INSERT, SELECT, UPDATE, DELETE 等。

例如，当我们执行：

users = session.query(User).filter_by(name="Alice").all()

SQLAlchemy 会将其转化为：

SELECT * FROM users WHERE name = 'Alice';

3. 复杂查询示例

SQLAlchemy 也支持复杂的查询操作，比如排序、聚合、关联查询等。

1）排序

users = session.query(User).order_by(User.age.desc()).all()  # 按照年龄降序排序

2）聚合

from sqlalchemy import func

avg_age = session.query(func.avg(User.age)).scalar()  # 获取所有用户的平均年龄
print(f"Average age: {avg_age}")

3）关联查询

假设我们有一个 Post 类和 User 类，用户可以拥有多个文章：

class Post(Base):
    __tablename__ = 'posts'
    
    id = Column(Integer, primary_key=True)
    title = Column(String)
    user_id = Column(Integer, ForeignKey('users.id'))
    
    user = relationship("User", back_populates="posts")

User.posts = relationship("Post", order_by=Post.id, back_populates="user")

现在可以通过 SQLAlchemy 轻松进行关联查询：

# 查询某个用户的所有文章
user = session.query(User).filter_by(name="Alice").first()
for post in user.posts:
    print(post.title)

4. SQLAlchemy 高级特性

1）多表查询与联接

SQLAlchemy 支持内连接（JOIN）、外连接（OUTER JOIN）等操作，可以方便地处理复杂的多表查询。

session.query(User, Post).join(Post).filter(User.id == Post.user_id).all()

2）事务管理

SQLAlchemy 允许手动控制事务，使用 session.begin() 和 session.rollback() 可以进行显式的事务控制。

try:
    session.begin()
    # 一些数据库操作
    session.commit()
except:
    session.rollback()

3）数据库迁移工具：Alembic

SQLAlchemy 本身不提供数据库迁移功能，但 Alembic 是其官方支持的迁移工具，它可以帮助我们在数据库模型发生变化时同步数据库结构。

5. 总结

• 简化数据库操作：SQLAlchemy ORM 提供了高层次的接口来简化数据库的操作，我们可以通过 Python 类来表示数据库表，进行增删改查，避免了手写 SQL 语句。

• 支持复杂查询：SQLAlchemy 支持排序、聚合、联接查询等复杂数据库操作，同时可以自动生成对应的 SQL 语句。

• 跨数据库兼容性：通过 SQLAlchemy，你可以很容易地将项目从一个数据库迁移到另一个数据库（比如从 SQLite 到 MySQL、PostgreSQL）。

如果希望进行数据库操作时不想编写太多 SQL，SQLAlchemy 是一个非常合适的选择，尤其是在项目需要频繁与数据库交互时。

---

五、Redis（缓存数据库）

Redis（Remote Dictionary Server） 是一个开源的、基于内存的高性能 键值对（key-value） 数据库，常用于缓存、消息队列、实时统计等场景。

它具有如下特点：

• 极快的访问速度：基于内存，读取速度可达 10 万 QPS（每秒查询数）。

• 多种数据结构：支持字符串、列表、集合、哈希、位图、有序集合等。

• 丰富的应用场景：分布式锁、登录状态缓存、排行榜、限流器等。

• 支持持久化：内存数据可以保存到磁盘。

• 主从复制、集群模式：可以实现高可用、高并发的集群部署。

1. Redis 支持的数据类型

类型	示例用途	特点介绍
String	缓存页面内容、token、验证码	最基础的类型，支持字符串、数字
List	消息队列、任务队列	有序列表，可从头/尾插入/弹出
Set	标签系统、去重集合	无序不重复元素集合
Hash	存储用户信息、商品信息	类似字典：key -> field -> value
ZSet	排行榜、推荐系统	有序集合：元素+分数（score）
Bitmap	用户签到、状态记录	位操作，适合大量布尔数据
HyperLogLog	统计 UV/去重用户数	近似去重，内存占用极低

2. Redis 安装与启动

如果是 Linux 用户：

sudo apt install redis
redis-server  # 启动服务

也可以使用 Docker 安装：

docker run -d --name redis -p 6379:6379 redis

客户端连接：

redis-cli  # 进入命令行

3. 使用 Python 操作 Redis（redis-py）

1）安装 Python 客户端：

pip install redis

2）连接 Redis

import redis

# 创建 Redis 连接对象
r = redis.StrictRedis(
    host='localhost',      # Redis 服务器地址（本地）
    port=6379,             # Redis 端口（默认）
    db=0,                  # 使用的数据库编号（0 ~ 15）
    decode_responses=True # 自动将 bytes 解码为 str
)

3.）字符串操作（String）

# 设置键值
r.set("username", "alice")

# 获取值
print(r.get("username"))  # 输出: alice

# 设置键值并指定过期时间（单位：秒）
r.setex("code", 60, "123456")  # 设置验证码，有效期60秒

# 自增、自减
r.set("count", 10)
r.incr("count")  # +1
r.decr("count")  # -1

4）哈希操作（Hash）

# 设置字段
r.hset("user:1", "name", "Bob")
r.hset("user:1", "age", 25)

# 获取字段
print(r.hget("user:1", "name"))  # 输出: Bob

# 获取所有字段
print(r.hgetall("user:1"))       # {'name': 'Bob', 'age': '25'}

5）列表操作（List）

# 从左侧插入元素（类似栈）
r.lpush("queue", "task1", "task2")

# 从右侧弹出元素
task = r.rpop("queue")
print(task)  # 输出: task1 或 task2

# 获取所有元素
print(r.lrange("queue", 0, -1))

6）集合操作（Set）

# 添加元素
r.sadd("tags", "python", "redis", "flask")

# 获取所有元素（无序）
print(r.smembers("tags"))

# 判断是否存在某个元素
print(r.sismember("tags", "redis"))  # True or False

7）有序集合操作（ZSet）

# 添加元素和分数
r.zadd("rank", {"Alice": 90, "Bob": 95})

# 获取排行榜（按分数从高到低）
print(r.zrevrange("rank", 0, -1, withscores=True))

# 增加某个成员的分数
r.zincrby("rank", 5, "Alice")

8）键的通用操作

# 设置过期时间
r.expire("username", 30)  # 30秒后自动过期

# 查看剩余时间
print(r.ttl("username"))

# 删除键
r.delete("username")

9）事务操作（可选）

pipe = r.pipeline()
pipe.set("a", 1)
pipe.set("b", 2)
pipe.execute()  # 一起提交

类型	方法	说明
String	set, get, incr, setex	普通键值对、计数器
Hash	hset, hget, hgetall	结构化字段存储
List	lpush, rpop, lrange	队列 / 栈结构
Set	sadd, smembers, sismember	去重集合、标签系统
ZSet	zadd, zrevrange, zincrby	排行榜、有序存储

4. Redis 与数据库的区别

项目	Redis（缓存数据库）	MySQL/PostgreSQL（关系数据库）
主要用途	高速缓存、统计、消息、锁、排行榜	数据存储、结构化查询、事务
存储位置	内存（可持久化）	磁盘
查询方式	按键访问，速度极快	支持复杂 SQL 查询
一致性	弱（默认无事务）	强一致性（支持事务、ACID）
数据结构	丰富（String、List、ZSet等）	固定结构（表结构）

Redis 是内存级数据库，适合高性能读写 + 临时数据处理，不适合永久性存储；数据库负责业务核心数据，Redis 更像是“加速器”。

5. 举例

爬取一个网站的数据，并将这些数据缓存到 Redis 中

import redis
import requests
from bs4 import BeautifulSoup

# 连接 Redis
r = redis.StrictRedis(host='localhost', port=6379, db=0, decode_responses=True)

# 爬取网页
url = "https://quotes.toscrape.com"
response = requests.get(url)
soup = BeautifulSoup(response.text, 'html.parser')

# 获取所有名言和作者
quotes = soup.find_all('div', class_='quote')
data = []

for quote in quotes:
    text = quote.find('span', class_='text').text
    author = quote.find('small', class_='author').text
    data.append({'text': text, 'author': author})

# 将数据存入 Redis
for idx, quote in enumerate(data):
    key = f"quote:{idx+1}"
    r.hset(key, mapping=quote)

# 查看存入 Redis 的数据
for idx in range(1, len(data)+1):
    key = f"quote:{idx}"
    print(r.hgetall(key))  # 获取整个哈希

说明

• 爬取数据： 我们从 https://quotes.toscrape.com 网站上抓取了所有名言和作者。
• 存储数据： 将每一条名言存储为一个 Redis 哈希对象，键是 quote:{idx}，值是该名言的内容和作者。
• Redis 操作： 使用 hset 存储数据，并通过 hgetall 获取存储的数据。

后续操作

• 如果数据量很大，可以考虑分页抓取，存入多个 Redis 键。
• 如果要处理更复杂的数据，可以考虑用 Redis 的列表、集合或有序集合进行存储。
• 如果是需要缓存，可以使用 Redis 的过期时间设置，例如使用 setex 方法设置过期时间。

---

六、MongoDB

MongoDB 是一个开源的 NoSQL 数据库，使用文档（Document）形式存储数据，而非传统的关系数据库中的表（Table）和行（Row）。它是面向文档的数据库，广泛应用于需要高性能、大数据量的应用程序。

MongoDB 采用了文档存储结构，数据以 BSON（Binary JSON）格式存储。这使得它比关系数据库更具灵活性，可以存储复杂的嵌套数据和不同格式的数据。

特点：

• 文档存储： 数据以 BSON 格式存储，支持嵌套数据结构，灵活性更高。

• 高可扩展性： 支持横向扩展（sharding），可通过分片技术将数据分布在不同的服务器上。

• 高性能： 支持高效的读写操作，适用于高吞吐量和高并发的应用。

• 灵活的 schema： 数据库中的集合不需要固定的 schema，允许不同文档具有不同的字段。

• 原子操作： 支持原子操作，可以对单一文档执行更新、删除等操作。

1. MongoDB 数据模型

MongoDB 使用以下数据结构：

• 数据库（Database）： 存储数据的容器，一个 MongoDB 实例可以包含多个数据库。

• 集合（Collection）： 类似于关系数据库中的表，一个数据库可以有多个集合。

• 文档（Document）： 数据的最小单位，类似于关系数据库中的行。文档是 BSON 格式的数据（类似 JSON），每个文档都有唯一的 _id 字段。

示例：MongoDB 数据模型

{
    "_id": ObjectId("5f45c3a735e56a3b59e4906d"),
    "name": "Alice",
    "age": 25,
    "address": {
        "street": "123 Main St",
        "city": "New York"
    }
}

• _id：每个文档都有一个唯一的 _id 字段（如果没有指定，MongoDB 会自动生成）。

• address：嵌套文档，表示地址信息。

2. MongoDB 安装与启动

安装 MongoDB

• Linux： 可以使用包管理器（如 apt、yum）安装 MongoDB。

sudo apt update
sudo apt install mongodb

• Windows： 使用 MongoDB 官网提供的安装包，按照向导完成安装。

官网：https://www.mongodb.com/try/download/community-edition/releases/archive

• macOS： 使用 brew 安装 MongoDB。

brew tap mongodb/brew
brew install mongodb-community@5.0

启动 MongoDB

启动 MongoDB 服务：

mongod  # 启动数据库服务器

启动 MongoDB 客户端：

mongo   # 进入 MongoDB shell

3. 使用 Python 操作 MongoDB

安装 Python MongoDB 客户端库 pymongo：

pip install pymongo

1）连接 MongoDB

from pymongo import MongoClient

# 连接到本地 MongoDB 服务
client = MongoClient('localhost', 27017)

# 获取数据库
db = client['mydatabase']  # mydatabase 是数据库名称

# 获取集合
collection = db['users']  # users 是集合名称

2）插入数据

# 插入单个文档
user = {
    "name": "Alice",
    "age": 25,
    "address": {
        "street": "123 Main St",
        "city": "New York"
    }
}

# 插入文档到集合
collection.insert_one(user)

# 插入多个文档
users = [
    {"name": "Bob", "age": 30},
    {"name": "Charlie", "age": 35}
]
collection.insert_many(users)

3）查询数据

查找单个文档

# 查找第一个匹配的文档
user = collection.find_one({"name": "Alice"})
print(user)

查找多个文档

# 查找所有年龄大于 30 的用户
users = collection.find({"age": {"$gt": 30}})
for user in users:
    print(user)

使用条件查询（例如，年龄大于 30 且地址为 New York）

# 使用条件查询
users = collection.find({
    "age": {"$gt": 30},
    "address.city": "New York"
})

for user in users:
    print(user)

4）更新数据

更新单个文档

# 更新文档
collection.update_one(
    {"name": "Alice"},  # 查询条件
    {"$set": {"age": 26}}  # 更新内容
)

更新多个文档

# 更新多个文档
collection.update_many(
    {"age": {"$gt": 30}},  # 查询条件
    {"$set": {"status": "senior"}}  # 更新内容
)

5）删除数据

删除单个文档

# 删除一个文档
collection.delete_one({"name": "Alice"})

删除多个文档

# 删除多个文档
collection.delete_many({"age": {"$lt": 30}})

6）索引操作

为了加速查询，MongoDB 提供了索引功能。你可以为集合的字段创建索引。

# 为字段 `name` 创建索引
collection.create_index([("name", 1)])  # 1 表示升序，-1 表示降序

4. MongoDB 与 关系数据库的区别

特性	MongoDB	关系数据库（如 MySQL、PostgreSQL）
数据模型	面向文档（BSON）	面向表（行列）
数据存储	灵活的 schema，可变的字段	固定的 schema，字段必须预定义
扩展性	水平扩展（分片）	垂直扩展（增加硬件资源）
查询语言	MongoDB 查询语言（MongoDB Query Language）	SQL
事务支持	支持事务，但不如关系数据库强（4.x 版本及以上支持多文档事务）	完全支持事务（ACID）

5. 总结

MongoDB 是一个高性能、可扩展的 NoSQL 数据库，非常适合处理大量的非结构化数据。与传统的关系数据库相比，它的数据模型更加灵活，可以更轻松地存储复杂的数据类型。通过 MongoDB，开发者可以更快速地构建、扩展和维护他们的应用程序。

---

总结对比表

特性	SQLite	MySQL	PostgreSQL	MongoDB	Redis	SQLAlchemy
类型	关系型数据库	关系型数据库	关系型数据库	NoSQL（文档数据库）	内存数据结构存储（缓存数据库）	ORM框架（关系型数据库）
数据模型	表结构（轻量级）	表结构	表结构（复杂类型支持）	文档（JSON/BSON）	键值对（支持多种数据结构）	ORM模型，抽象数据库操作
扩展性	单文件，不支持横向扩展	支持垂直扩展（分区支持）	支持横向扩展（分区）	水平扩展（分片）	内存存储，支持水平扩展	依赖数据库的扩展性
并发支持	低并发	高并发	高并发	高并发	高并发	依赖底层数据库并发支持
性能	适合轻量级应用	高性能，适合Web应用	高性能，复杂查询优先	高性能（大数据量，高吞吐量）	极高性能，适合缓存和会话存储	相对较低，适用于开发阶段
事务支持	支持	支持	支持	支持（较弱）	支持（可选）	支持事务管理
适用场景	嵌入式应用，小型桌面应用	Web应用，企业级应用	高并发、大数据场景，地理信息	动态数据，日志数据，实时数据	高速缓存、实时数据分析	Python开发中数据库操作封装

• SQLite 适用于轻量级应用和单机存储，适合移动端、嵌入式设备或简单应用。

• MySQL 是一款功能强大、性能优异的关系型数据库，适用于 Web 应用和传统的数据库应用。

• PostgreSQL 适合复杂数据模型和高并发应用，提供更多的功能和扩展性，适用于大数据量和企业级应用。

• MongoDB 适合需要灵活数据模型、大数据量和高扩展性的应用，常用于实时数据分析和快速开发。

• Redis 是一个高性能的内存数据库，适合用作缓存、会话存储和实时数据分析。

• SQLAlchemy 是一个 Python ORM 框架，适合 Python 开发者进行关系型数据库操作的抽象封装。