關于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 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開發中數據庫操作封裝