一、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 pymysqlconn = 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 PooledDBpool = 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("用户名已存在")returnhashed_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":breakelse: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 psycopg2conn = 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 主要有两个核心部分：
-
SQLAlchemy Core：提供低级别的数据库交互 API，适合需要完全控制 SQL 生成和执行的高级用户。
-
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 sessionmakerBase = 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 funcavg_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').textauthor = quote.find('small', class_='author').textdata.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 开发者进行关系型数据库操作的抽象封装。
》阅读笔记：p4-p5)
