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

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

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

SQLite 是一个轻量级、零配置的关系型数据库系统，整个数据库保存在一个文件中，适合小型项目和本地存储。
SQLite 不需要安装服务器，打开即可用，跨平台。

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

1. 主要特点

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

2. 基本使用流程

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

python 复制代码

import sqlite3

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

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

python 复制代码

cursor = conn.cursor()

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

python 复制代码

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

2.4. 插入数据

python 复制代码

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

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

2.5. 查询数据

python 复制代码

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

2.6. 更新与删除数据

python 复制代码

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

2.7. 提交事务 & 关闭连接

python 复制代码

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

3. 事务机制

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

python 复制代码

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 方法详解

python 复制代码

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

5. 数据库文件位置

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

python 复制代码

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

6. 一些注意事项

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

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

python 复制代码

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 获取字典而不是元组

python 复制代码

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. 环境准备

python 复制代码

pip install pymysql

安装 MySQL 数据库

Windows 可以安装 MySQL Community Edition
macOS 可用 brew install mysql
Linux 可以使用 apt 或 yum

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

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

bash 复制代码

mysql -u root -p

2. 连接数据库

python 复制代码

import pymysql

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

cursor = conn.cursor()

3. 建表和插入数据

创建表：

python 复制代码

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

插入数据：

python 复制代码

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

4. 查询数据

查询所有：

python 复制代码

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

for row in rows:
    print(row)

查询一条：

python 复制代码

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

5. 更新与删除

python 复制代码

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

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

conn.commit()

6. 事务处理

python 复制代码

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

7. 批量操作

python 复制代码

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

8. 关闭资源

python 复制代码

cursor.close()
conn.close()

或者使用 with 管理：

python 复制代码

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 获取字典而不是元组

python 复制代码

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

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

使用 DBUtils 实现连接池：

python 复制代码

pip install DBUtils

python 复制代码

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：

bash 复制代码

pip install pymysql

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

bash 复制代码

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
);

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

python 复制代码

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()

运行效果：

bash 复制代码

== 用户系统 ==
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：

bash 复制代码

sudo apt update
sudo apt install postgresql postgresql-contrib

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

bash 复制代码

sudo -u postgres psql

3. Python 操作 PostgreSQL ------ 使用 `psycopg2`

安装：

python 复制代码

pip install psycopg2

如果安装失败，可尝试：

bash 复制代码

pip install psycopg2-binary

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

连接数据库

python 复制代码

import psycopg2

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

cursor = conn.cursor()

创建表

python 复制代码

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

插入数据

python 复制代码

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

查询数据

python 复制代码

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

更新 & 删除

python 复制代码

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

关闭连接

python 复制代码

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 和数据库驱动

bash 复制代码

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

2）定义模型

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

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 来进行数据的增删改查。

python 复制代码

# 创建 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 等。

例如，当我们执行：

python 复制代码

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

SQLAlchemy 会将其转化为：

sql 复制代码

SELECT * FROM users WHERE name = 'Alice';

3. 复杂查询示例

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

1）排序

python 复制代码

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

2）聚合

python 复制代码

from sqlalchemy import func

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

3）关联查询

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

python 复制代码

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 轻松进行关联查询：

python 复制代码

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

4. SQLAlchemy 高级特性

1）多表查询与联接

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

sql 复制代码

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

2）事务管理

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

python 复制代码

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 用户：

bash 复制代码

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

也可以使用 Docker 安装：

bash 复制代码

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

客户端连接：

bash 复制代码

redis-cli  # 进入命令行

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

1）安装 Python 客户端：

python 复制代码

pip install redis

2）连接 Redis

python 复制代码

import redis

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

3.）字符串操作（String）

python 复制代码

# 设置键值
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）

python 复制代码

# 设置字段
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）

python 复制代码

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

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

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

6）集合操作（Set）

python 复制代码

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

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

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

7）有序集合操作（ZSet）

python 复制代码

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

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

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

8）键的通用操作

python 复制代码

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

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

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

9）事务操作（可选）

python 复制代码

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 中

python 复制代码

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 数据模型

bash 复制代码

{
    "_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。

bash 复制代码

sudo apt update
sudo apt install mongodb

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

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

macOS： 使用 brew 安装 MongoDB。

bash 复制代码

brew tap mongodb/brew
brew install [email protected]

启动 MongoDB

启动 MongoDB 服务：

bash 复制代码

mongod  # 启动数据库服务器

启动 MongoDB 客户端：

bash 复制代码

mongo   # 进入 MongoDB shell

3. 使用 Python 操作 MongoDB

安装 Python MongoDB 客户端库 pymongo：

bash 复制代码

pip install pymongo

1）连接 MongoDB

python 复制代码

from pymongo import MongoClient

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

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

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

2）插入数据

python 复制代码

# 插入单个文档
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）查询数据

查找单个文档

python 复制代码

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

查找多个文档

python 复制代码

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

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

python 复制代码

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

for user in users:
    print(user)

4）更新数据

更新单个文档

python 复制代码

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

更新多个文档

python 复制代码

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

5）删除数据

删除单个文档

python 复制代码

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

删除多个文档

python 复制代码

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

6）索引操作

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

python 复制代码

# 为字段 `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 开发者进行关系型数据库操作的抽象封装。

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

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

1. 主要特点

2. 基本使用流程

3. 事务机制

4. fetch 方法详解

5. 数据库文件位置

6. 一些注意事项

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

8. 高级功能

二、MySQL（主流数据库）

1. 环境准备

2. 连接数据库

3. 建表和插入数据

4. 查询数据

5. 更新与删除

6. 事务处理

7. 批量操作

8. 关闭资源

9. 常见问题

10. 进阶功能

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

三、PostgreSQL

1. PostgreSQL 的核心特点

2. PostgreSQL 安装

3. Python 操作 PostgreSQL ------ 使用 psycopg2

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

5. 与mysql技术对比

四、SQLAlchemy（ORM框架）

1. 核心概念

2. 基础示例

3. 复杂查询示例

4. SQLAlchemy 高级特性

5. 总结

五、Redis（缓存数据库）

1. Redis 支持的数据类型

2. Redis 安装与启动

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

4. Redis 与数据库的区别

5. 举例

六、MongoDB

1. MongoDB 数据模型

2. MongoDB 安装与启动

3. 使用 Python 操作 MongoDB

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

5. 总结

总结对比表

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

3. Python 操作 PostgreSQL ------ 使用 `psycopg2`

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

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