Python on 南国遗梦的小站

Numpy使用手册

Wed, 05 Nov 2025 12:47:28 +0800

创建数组

从列表创建

# 一维数组
arr1d = np.array([1, 2, 3, 4, 5])
print(arr1d)  # [1 2 3 4 5]

# 二维数组
arr2d = np.array([[1, 2, 3], [4, 5, 6]])
print(arr2d)
# [[1 2 3]
#  [4 5 6]]

# 三维数组
arr3d = np.array([[[1, 2], [3, 4]], [[5, 6], [7, 8]]])
print(arr3d)

特殊数组创建

# 全零数组
zeros = np.zeros((3, 4))
print(zeros)

# 全一数组
ones = np.ones((2, 3))
print(ones)

# 单位矩阵
identity = np.eye(3)
print(identity)

# 等差数列
lin_arr = np.linspace(0, 10, 5)  # 从0到10，5个等间距数
print(lin_arr)  # [ 0.   2.5  5.   7.5 10. ]

# 等差数列（指定步长）
arange_arr = np.arange(0, 10, 2)  # 从0到10，步长为2
print(arange_arr)  # [0 2 4 6 8]

# 随机数组
random_arr = np.random.random((2, 3))  # 0-1之间的随机数
print(random_arr)

数组属性

arr = np.array([[1, 2, 3], [4, 5, 6]])

print("数组:", arr)
print("维度:", arr.ndim)        # 2
print("形状:", arr.shape)       # (2, 3)
print("元素总数:", arr.size)    # 6
print("数据类型:", arr.dtype)   # int64
print("元素大小(字节):", arr.itemsize)  # 8

数组索引与切片

一维数组

arr = np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

print(arr[2])        # 2
print(arr[2:5])      # [2 3 4]
print(arr[:5])       # [0 1 2 3 4]
print(arr[5:])       # [5 6 7 8 9]
print(arr[::2])      # [0 2 4 6 8] 步长为2
print(arr[::-1])     # [9 8 7 6 5 4 3 2 1 0] 反转

多维数组

arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])

print(arr[0, 1])     # 2
print(arr[1, :])     # [4 5 6] 第二行
print(arr[:, 1])     # [2 5 8] 第二列
print(arr[0:2, 1:3]) # [[2 3] [5 6]] 子数组

布尔索引

arr = np.array([1, 2, 3, 4, 5, 6])

# 选择大于3的元素
mask = arr > 3
print(mask)          # [False False False True True True]
print(arr[mask])     # [4 5 6]

# 直接使用条件
print(arr[arr % 2 == 0])  # [2 4 6] 偶数

数组操作

形状操作

arr = np.arange(12)
print("原始数组:", arr)

# 重塑形状
reshaped = arr.reshape(3, 4)
print("重塑后:\n", reshaped)

# 展平
flattened = reshaped.flatten()
print("展平:", flattened)

# 转置
transposed = reshaped.T
print("转置:\n", transposed)

数组拼接

a = np.array([[1, 2], [3, 4]])
b = np.array([[5, 6], [7, 8]])

# 垂直拼接
v_stack = np.vstack((a, b))
print("垂直拼接:\n", v_stack)

# 水平拼接
h_stack = np.hstack((a, b))
print("水平拼接:\n", h_stack)

数组分割

arr = np.arange(12).reshape(3, 4)
print("原始数组:\n", arr)

# 水平分割
h_split = np.hsplit(arr, 2)
print("水平分割:")
for part in h_split:
    print(part)

# 垂直分割
v_split = np.vsplit(arr, 3)
print("垂直分割:")
for part in v_split:
    print(part)

数学运算

基本运算

a = np.array([1, 2, 3, 4])
b = np.array([5, 6, 7, 8])

print("a + b =", a + b)  # [ 6  8 10 12]
print("a - b =", a - b)  # [-4 -4 -4 -4]
print("a * b =", a * b)  # [ 5 12 21 32]
print("a / b =", a / b)  # [0.2 0.333 0.429 0.5]
print("a ** 2 =", a ** 2)  # [ 1  4  9 16]

通用函数

arr = np.array([0, np.pi/2, np.pi])

print("sin:", np.sin(arr))      # [0. 1. 0.]
print("cos:", np.cos(arr))      # [1. 0. -1.]
print("exp:", np.exp(arr))      # 指数函数
print("log:", np.log(arr + 1))  # 自然对数
print("sqrt:", np.sqrt(arr))    # 平方根

统计函数

arr = np.array([[1, 2, 3], [4, 5, 6]])

print("数组:\n", arr)
print("总和:", np.sum(arr))           # 21
print("平均值:", np.mean(arr))        # 3.5
print("标准差:", np.std(arr))         # 1.7078
print("方差:", np.var(arr))           # 2.9167
print("最小值:", np.min(arr))         # 1
print("最大值:", np.max(arr))         # 6
print("沿轴0求和:", np.sum(arr, axis=0))  # [5 7 9]
print("沿轴1求和:", np.sum(arr, axis=1))  # [6 15]

线性代数

# 矩阵乘法
a = np.array([[1, 2], [3, 4]])
b = np.array([[5, 6], [7, 8]])

dot_product = np.dot(a, b)
print("矩阵乘法:\n", dot_product)

# 行列式
det = np.linalg.det(a)
print("行列式:", det)

# 逆矩阵
inv = np.linalg.inv(a)
print("逆矩阵:\n", inv)

# 特征值和特征向量
eigenvalues, eigenvectors = np.linalg.eig(a)
print("特征值:", eigenvalues)
print("特征向量:\n", eigenvectors)

随机数生成

# 设置随机种子（保证结果可重现）
np.random.seed(42)

# 均匀分布
uniform = np.random.rand(3, 3)  # 0-1均匀分布
print("均匀分布:\n", uniform)

# 正态分布
normal = np.random.randn(3, 3)  # 标准正态分布
print("正态分布:\n", normal)

# 整数随机数
integers = np.random.randint(0, 10, (2, 3))  # 0-10的整数
print("整数随机数:\n", integers)

# 随机排列
arr = np.arange(10)
np.random.shuffle(arr)
print("随机排列:", arr)

数组保存与读取

# 创建示例数组
arr = np.arange(12).reshape(3, 4)

# 保存为文本文件
np.savetxt('array.txt', arr)

# 从文本文件读取
loaded = np.loadtxt('array.txt')
print("从文件读取:\n", loaded)

# 保存为二进制文件
np.save('array.npy', arr)

# 从二进制文件读取
loaded_binary = np.load('array.npy')
print("从二进制文件读取:\n", loaded_binary)

# 保存为压缩的二进制文件
np.savez('array_compressed.npz', my_array=arr)

# 从压缩文件读取
loaded_compressed = np.load('array_compressed.npz')
print("从压缩文件读取:\n", loaded_compressed['my_array'])

实用技巧

广播机制

# 数组与标量的运算（广播）
arr = np.array([[1, 2, 3], [4, 5, 6]])
result = arr + 10  # 每个元素加10
print("广播加法:\n", result)

# 不同形状数组的运算
a = np.array([[1], [2], [3]])  # 形状 (3, 1)
b = np.array([4, 5, 6])        # 形状 (3,)
result = a + b  # 广播为 (3, 3)
print("形状广播:\n", result)

条件运算

arr = np.array([1, 2, 3, 4, 5])

# where函数
result = np.where(arr > 3, arr, 0)  # 大于3的保留，其他设为0
print("条件运算:", result)  # [0 0 0 4 5]

# 布尔运算
mask = (arr > 2) & (arr < 5)  # 2 < arr < 5
print("布尔掩码:", mask)      # [False False True True False]

WordCard技术文档

Fri, 17 Oct 2025 14:53:54 +0800

WordCard 技术文档

版本：1.0

简介

WordClock 是基于 customtkinter 的桌面小工具，用于在桌面悬浮窗中循环显示单词及其翻译，并支持从 JSON 导入词表、将词表写入 SQLite 数据库、通过系统托盘控制程序、保存窗口位置及设置等功能。

主要特点：

悬浮、圆角、透明窗口，常驻桌面并支持拖动和隐藏到托盘。
自动按间隔随机切换单词并更新 UI。
支持将 JSON 词表导入到 SQLite 并作为可选词表使用。
支持通过设置窗口管理词表、设置切换间隔、删除词表与制作 JSON 文件。
使用多线程处理长耗时操作（导入、加载词表、托盘）以保证 UI 不阻塞。

快速开始

安装依赖（示例）：

`1`	`pip install customtkinter pystray pillow`

注意：customtkinter 依赖 tkinter（通常随 Python 自带），若缺少请安装对应系统包。

将代码保存为 word_clock.py，并确保同目录下有 单词.db（或指定其他路径）。
运行：

`1`	`python word_clock.py`

第一次运行会生成 settings.json（默认 intervaltime = 5 秒），可在设置窗口调整。

环境依赖

Python 3.8+
tkinter（GUI）
customtkinter
pystray
pillow (PIL)
sqlite3（Python 标准库）

平台注意：代码中使用了 Windows 特定的 Win32 API（通过 ctypes）来隐藏任务栏图标，因此最佳运行环境为 Windows。在非 Windows 系统上应移除或条件兼容该部分。

文件结构

假设单文件项目：

1
2
3

wordcard.py
单词.db          # SQLite 数据库（可选，程序会尝试连接）
settings.json    # 程序运行后生成或更新

导入的 JSON 文件示例（每个元素为对象）：

[
  {"word": "apple", "translate": "苹果"},
  {"word": "book", "translate": "书"}
]

主要类与方法说明

WordClock (继承自 ctk.CTk)

描述：应用的主窗口类，封装 UI、数据库连接、托盘、线程与设置保存。

属性（重要）

SETTINGS_FILE：字符串，默认 settings.json。
db_path：SQLite 数据库路径，默认 单词.db。
db_conn, db_cursor：数据库连接与游标（持久连接，check_same_thread=False）。
wordtables：从 SQLite 读取到的表名列表。
words_list：当前选中词表对应的单词列表，元素为 (word, translate)。
intervaltime：单词切换时间间隔（秒）。
running：布尔，控制自动更新线程运行。
loading：布尔，指示是否处于词表加载中，用于暂停自动刷新。

方法摘要（按功能分组）

初始化与窗口配置
- __init__(self, db_path="单词.db")：创建窗口、加载配置、打开数据库连接、启动托盘线程与自动刷新线程、绑定关闭事件等。
- hide_from_taskbar(self)：使用 ctypes 调用 Win32 API 将窗口从任务栏隐藏（Windows-specific）。
- bind_drag_events(self)、start_drag、on_drag：支持拖动并在拖动时保存位置。
设置存取
- load_settings(self)：读取 settings.json，若不存在返回默认配置。
- save_settings(self)：保存窗口位置、当前选表名、间隔等到 settings.json。
- on_close(self)：窗口关闭回调，保存设置并退出。
数据库与数据加载
- fetch_wordtables(self, db_path)：读取 SQLite 中的表名并存入 self.wordtables。SQL 为 SELECT name FROM sqlite_master WHERE type='table' ORDER BY rowid;。
- load_words_from_db(self, db_path, table_name=None)：读取指定表的 word, translate 列并返回列表；若未传表名，默认取 self.wordtables[0]。
- json2sqldb(self, file_address, file_name)：将 JSON 数据写入新建的 SQLite 表，包含事务优化（调整 PRAGMA、BEGIN TRANSACTION、executemany、commit），最后恢复 PRAGMA 设置。
自动切换与UI更新
- auto_update_words(self)：后台线程循环，根据 self.intervaltime 随机选择单词并通过 after(0, ...) 回到主线程更新 UI。会在 self.loading=True 时短暂等待以避免冲突。
- display_translation(self, text)：当翻译过长时设置 wraplength 以换行显示。
托盘相关
- setup_tray(self)：构造托盘图标与菜单（显示/隐藏、设置、退出），并运行事件循环（pystray）。独立线程运行。
- toggle_window(self, icon=None, item=None)：切换窗口显示/隐藏。
- quit_app(self, icon=None, item=None)：停止线程、关闭数据库并退出。
设置窗口与词表管理
- so_setting(self)：打开设置窗口，构建左侧控制按钮与右侧显示词表的滚动区域，并异步加载表名。
- load_wordtables_async(self)：后台加载表并回调 put_tables_on_right。
- put_tables_on_right(self)：基于 self.wordtables 在滚动区构建按钮并支持高亮当前表。
- on_label_click_with_confirmation(self, name, button)：点击某个词表按钮弹出确认框，确认后显示遮罩并在后台加载数据，加载完成后更新 UI 与当前表。
- del_wordtable(self) / confirm_delete(self, table_name, popup)：删除选中表并刷新 UI。
- open_make_wordtable_window(self) / generate_json_from_text(self, text_box, win)：允许用户粘贴文本快速生成 JSON 文件（每行 单词翻译），并保存 JSON。
加载遮罩与动画
- _create_loading_overlay(self, message="正在加载…")：在 main_frame 上创建覆盖层（遮罩）并返回 overlay。
- _start_loading_animation(self, overlay)：使用 after 循环更新点点动画，直至 self.loading=False。
- _stop_loading_animation(self)：取消动画任务。
辅助弹窗
- show_popup(self, message: str, duration: int = 1800)：自定义 CTkToplevel 弹窗，代替未加载的 CTkMessagebox。

数据库与数据格式

SQLite 表结构（在 json2sqldb 创建）

CREATE TABLE <table_name> (
  id INTEGER PRIMARY KEY AUTOINCREMENT,
  word varchar(255) NULL DEFAULT NULL,
  translate TEXT NULL
);

JSON 导入格式：数组，每项为对象：{"word": "xxx", "translate": "yyy"}。
注意：代码假设表中存在 word 与 translate 字段。若你的原始表结构不同，需修改 load_words_from_db 查询语句。

设置与持久化（settings.json）

settings.json 存储字段：

pos_x、pos_y：上次窗口位置（像素坐标）。
last_table：上次使用的词表名。
intervaltime：单词自动切换间隔（秒）。

默认文件会在程序首次运行时创建（intervaltime=5）。保存由 save_settings() 完成（拖动、修改间隔、关闭时等触发）。

运行与调试建议

数据库无法连接：确认 db_path 路径正确且文件存在。若数据库为空，程序的 fetch_wordtables 可能返回空列表，load_words_from_db 会返回占位 ("No word","无")。
线程安全：使用了 sqlite3.connect(..., check_same_thread=False) 来允许多线程访问。但推荐仅主线程使用游标并在子线程使用新的连接（sqlite3.connect(self.db_path)）以避免潜在竞态。
托盘图标不显示或程序无反应：pystray 在某些平台或环境需要额外配置。测试时可先注释 setup_tray 并直接运行主窗口检查 UI。
隐藏任务栏仅在 Windows 生效：hide_from_taskbar() 使用 Win32 API，仅在 Windows 上有效，跨平台请条件判断或移除。
日志与异常：建议扩展 print 为 logging 模块，并在关键异常中记录堆栈信息以便排查。

常见问题与解决方法

问：窗口没有显示单词或只显示 No word。
- 因为数据库中没有表或表中没有数据。确保通过导入 JSON 创建了至少一个表或手动向 SQLite 中插入数据。
问：点击词表按钮没反应。
- 检查 word_table_buttons 是否正确生成，以及 self.wordtables 是否有数据。
问：应用未隐藏到系统托盘或无法退出。
- 检查 pystray 是否正常安装并且在当前平台支持托盘操作。临时方法：直接关闭窗口或在代码中调用 quit_app()。

扩展与改进建议

使用线程池/Executor：替换原始 threading.Thread 为 concurrent.futures.ThreadPoolExecutor 以更好地管理线程生命周期与异常捕获。
数据库连接策略：将长期持久连接改为“按线程新建连接”的策略（每个线程独立连接），以避免跨线程共享同一游标导致的问题。
UI 优化：为长文本增加动效、增加单词发音（调用 TTS 或在线 API）、支持多语言界面切换。
配置界面改进：在设置窗口直接显示并编辑 intervaltime，支持导入 CSV、 Excel；提供词表导出功能（JSON / CSV）。
跨平台兼容：为 hide_from_taskbar 添加平台判断，并实现 macOS / Linux 下替代实现或跳过该功能。
错误日志：集成日志文件输出以及可选的错误上报（不建议在个人项目中默认开启）。

附：典型 JSON 输入示例

[
  {"word": "apple", "translate": "苹果"},
  {"word": "book", "translate": "书"},
  {"word": "computer", "translate": "电脑 计算机"}
]

SQLite3

Sat, 11 Oct 2025 15:16:24 +0800

打开数据库

使用SQLite3创建数据的连接，当数据库文件存在则连接对象直接打开数据库文件，不存在则自动创建数据库文件。连接对象可以是硬盘上面的数据库文件，也可以是建立在内存（memory）中的，在内存中的数据库执行完任何操作后，都不需要提交事务的(commit)

SQLite3的connect方法返回con对象，即数据库连接对象，提供如下方法：

方法	描述
.cursor()	创建一个游标对象
.commit()	处理事务提交
.rollback()	处理事务回滚
.close()	关闭一个数据库连接

创建数据库

在硬盘上建立数据库

`1`	`con=sqlite3.connect("E:\Test.db")`

路径中单斜杠和双斜杠不做区分，且数据库的名称不区分大小写，即E:\Test.db 与 E:\\Test.db 与 E:\TEST.db 均相同。但需要注意的是： E:\test.db 会报错，因为编译器会识别到 \t 为制表符，因此认为路径不对。

`1`	`con=sqlite3.connect("Test.db")`

不加全路径则在项目文件下创建数据库

在内存上创建数据库

`1`	`con=sqlite3.connect("memory")`

两者差别

追求极致速度和临时性就选内存数据库；需要数据持久保存、大容量或共享访问则选文件数据库。

混合模式可以兼顾两者优点：你可以将整个文件数据库附加 (ATTACH) 到内存数据库中进行高速操作，处理完成后再将结果写回磁盘文件。这适合“热数据”需要内存加速，而“冷数据”需要持久化的复杂场景

创建游标

游标对象是数据库管理系统提供的一种数据访问机制，它就像一个指向查询结果集的指针，允许你逐行处理数据，而不是一次性操作整个结果集

方法	描述
.execute()	用来执行SQL语句
.executemany()	批量执行同一条SQL语句
.close()	用来关闭游标
.fetchone()	从查询结果中获取下一行数据
.fetchmany()	从结果中取出多条记录
.fetchall()	取出所有剩余记录
.scroll()	用于游标滚动

执行SQL语句

创建表

`1`	`cur.execute("CREATE TABLE IF NOT EXISTS test(id INTEGER PRIMARY KEY,name TEXT,age INTEGER)")`

新增数据

方法一

1
2

data = "5,'leon',22"
cur.execute('INSERT INTO test VALUES (%s)'%data)

方法二

`1`	`cur.execute("INSERT INTO test values(?,?,?)",(6,"zgq",20))`

方法三

`1`	`cur.executemany('INSERT INTO test VALUES (?,?,?)',[(3,'name3',19),(4,'name4',26)])`

更新数据

方法一

`1`	`cur.execute("UPDATE test SET name=? WHERE id=?",("nihao",1))`

方法二

`1`	`cur.execute("UPDATE test SET name='haha' WHERE id=1")`

删除数据

方法一

`1`	`n=cur.execute("DELETE FROM test WHERE id=?",(1,))`

方法二

`1`	`n=cur.execute("DELETE FROM test WHERE id=1")`

返回的n为被删除的对象

查询数据

`1`	`cur.execute("SELECT * FROM test")`

查询结果存储在游标对象cur中，可以使用对象的方法进行访问，例如遍历或使用.fetchone()等方法

删除表

`1`	`cur.execute("DROP TABLE Test ")`

事务回滚或提交

提交

`1`	`con.commit()`

回滚

`1`	`con.rollback()`

关闭数据库和游标

1
2

cur.close()
con.close()

一定要先关闭游标，再关闭数据库连接，否则会报错

案例

import sqlite3

# 连接到内存数据库并创建游标对象
conn = sqlite3.connect(':memory:')
cursor = conn.cursor()

print("=== 1. 使用 .execute() 创建表并插入单条数据 ===\n")

# .execute(): 执行一条SQL语句来创建表
create_table_sql = """
CREATE IF NOT EXISTS EXISTS users (
    id INTEGER PRIMARY KEY,
    name TEXT NOT NULL,
    age INTEGER
)
"""
cursor.execute(create_table_sql)

# .execute(): 执行一条INSERT语句插入单条数据
insert_sql = "INSERT INTO users (name, age) VALUES (?, ?)"
cursor.execute(insert_sql, ('Alice', 25))
print(f"插入单条数据，受影响的行数: {cursor.rowcount}")

print("\n=== 2. 使用 .executemany() 批量插入数据 ===\n")

# .executemany(): 执行同一条SQL语句，但传入多组参数
users_data = [
    ('Bob', 30),
    ('Charlie', 35),
    ('Diana', 28),
    ('Evan', 40)
]
cursor.executemany(insert_sql, users_data)
print(f"批量插入数据，受影响的行数: {cursor.rowcount}")

# 提交事务，使插入的数据生效
conn.commit()

print("\n=== 3. 使用 .fetch*() 系列方法查询数据 ===\n")

# .execute(): 执行查询语句
cursor.execute("SELECT * FROM users ORDER BY id")

print("--- 使用 .fetchone() 逐条获取 ---")
# .fetchone(): 获取结果集中的下一行
first_row = cursor.fetchone()
print(f"第一条记录: {first_row}")

second_row = cursor.fetchone()
print(f"第二条记录: {second_row}")

print("\n--- 使用 .fetchmany() 获取指定数量的记录 ---")
# .fetchmany(size): 获取指定数量的行
# 注意：此时游标指向第三条记录
next_few_rows = cursor.fetchmany(2) # 获取接下来的2条记录
print(f"接下来的两条记录: {next_few_rows}")

print("\n--- 使用 .fetchall() 获取所有剩余记录 ---")
# .fetchall(): 获取结果集中所有剩余的行
remaining_rows = cursor.fetchall()
print(f"所有剩余记录: {remaining_rows}")

# 再次执行查询，让游标回到结果集开头
cursor.execute("SELECT * FROM users ORDER BY id")
all_rows = cursor.fetchall()
print(f"\n--- 使用 .fetchall() 获取全部记录 ---")
print(f"全部记录: {all_rows}")

print("\n=== 4. 使用 .scroll() 滚动游标 ===\n")

# 为了演示.scroll()，我们重新执行查询
cursor.execute("SELECT * FROM users ORDER BY id")

# .scroll(value, mode='relative'): 相对当前位置移动游标
cursor.fetchone() # 先读取第一条，游标到第二条
print(f"读取第一条后，当前游标位置在第二条")

# 相对移动：从当前位置向后移动2条记录
cursor.scroll(2, mode='relative')
row_after_scroll = cursor.fetchone()
print(f"相对当前位置向后滚动2条后，读取的记录是: {row_after_scroll}") # 应该是第5条

# .scroll(value, mode='absolute'): 移动到结果集的绝对位置
cursor.scroll(0, mode='absolute') # 滚动到开头（第0条，但索引从0开始）
first_row_again = cursor.fetchone()
print(f"绝对滚动到开头后，读取的记录是: {first_row_again}") # 应该是第1条

print("\n=== 5. 使用 .close() 关闭游标 ===\n")

# .close(): 关闭游标，释放资源
print(f"关闭前，游标状态: {not cursor.closed}") # False 表示未关闭
cursor.close()
print(f"关闭后，游标状态: {cursor.closed}") # True 表示已关闭

# 关闭数据库连接
conn.close()

=== 1. 使用 .execute() 创建表并插入单条数据 ===

插入单条数据，受影响的行数: 1

=== 2. 使用 .executemany() 批量插入数据 ===

批量插入数据，受影响的行数: 4

=== 3. 使用 .fetch*() 系列方法查询数据 ===

--- 使用 .fetchone() 逐条获取 ---
第一条记录: (1, 'Alice', 25)
第二条记录: (2, 'Bob', 30)

--- 使用 .fetchmany() 获取指定数量的记录 ---
接下来的两条记录: [(3, 'Charlie', 35), (4, 'Diana', 28)]

--- 使用 .fetchall() 获取所有剩余记录 ---
所有剩余记录: [(5, 'Evan', 40)]

--- 使用 .fetchall() 获取全部记录 ---
全部记录: [(1, 'Alice', 25), (2, 'Bob', 30), (3, 'Charlie', 35), (4, 'Diana', 28), (5, 'Evan', 40)]

=== 4. 使用 .scroll() 滚动游标 ===

读取第一条后，当前游标位置在第二条
相对当前位置向后滚动2条后，读取的记录是: (5, 'Evan', 40)
绝对滚动到开头后，读取的记录是: (1, 'Alice', 25)

=== 5. 使用 .close() 关闭游标 ===

关闭前，游标状态: True
关闭后，游标状态: False

PyQt5

Fri, 22 Aug 2025 20:41:39 +0800

PyQt5能干什么

PyQt5的主要作用是创建UI界面，同时支持鼠标以及键盘的交互，不仅提供界面控件，还提供网络、数据库、多媒体等应用开发功能，具体来说：

UI控件（Widgets）：

最基础也是最重要的，提供大量开箱即用的的UI元素，可以像搭积木一样构建界面

基础控件：按钮（QPushButton）、标签（QLabel）、文本框（QLineEdit）、文本域（QTextEdit）、组合框（QComboBox）、列表（QListWidget）、表格（QTableWidget）等。
布局管理器：水平布局（QHBoxLayout）、垂直布局（QVBoxLayout）、网格布局（QGridLayout）等，用于自动排列和调整控件大小，确保窗口缩放时界面依然美观。
高级容器：选项卡（QTabWidget）、分组框（QGroupBox）、滚动区域（QScrollArea）、堆叠窗口（QStackedWidget）、停靠窗口（QDockWidget）等，用于组织复杂的界面结构。
主窗口框架：QMainWindow 类提供了标准应用程序主窗口的功能，包括菜单栏（QMenuBar）、工具栏（QToolBar）、状态栏（QStatusBar）和中心部件。

图形与视图框架：

处理大量的、交互式的2D图形对象，适合开发绘图软件、数据可视化、游戏编辑器。核心组件有：QGraphicsScene（场景，管理所有图形项）、QGraphicsView（视图，用于显示场景）、QGraphicsItem（图形项，如矩形、椭圆、自定义图形）

多媒体功能

音频播放：使用 QMediaPlayer 和 QAudioOutput 播放音频文件。
视频播放：使用 QMediaPlayer 和 QVideoWidget 播放视频文件。
摄像头访问：使用 QCamera 来捕获实时摄像头画面。

网络功能

HTTP/HTTPS 请求：通过 QNetworkAccessManager 进行网络通信，支持 GET、POST 等操作，比 Python 标准的 urllib 更强大、更易用。
TCP/UDP 通信：提供了 QTcpSocket, QTcpServer, QUdpSocket 等类，用于开发低层的网络应用，如聊天程序、自定义协议客户端/服务器。
WebSocket：支持现代 WebSocket 协议。

数据库连接

通过 QtSql 模块提供了统一的接口来操作各种数据库，如 SQLite、MySQL、PostgreSQL、ODBC 等。
内置了非常方便的模型/视图类（如 QSqlTableModel），可以轻松地将数据库中的表与UI控件（如 QTableView）绑定，实现数据的自动显示和编辑。

多线程（QThread）

桌面应用的UI主线程必须保持响应，否则会“卡住”。PyQt5 提供了 QThread 类，可以轻松地将耗时的操作（如下载文件、复杂计算）放到子线程中运行，并通过信号（Signal）与槽（Slot） 机制与主线程通信，更新UI进度，保证程序的流畅性

样式与主题（QSS - Qt Style Sheets）

类似于 Web 开发中的 CSS，你可以使用 QSS 来极大地美化应用程序的界面，可以轻松地自定义控件的外观、颜色、字体、边框、背景等，从而打造出独一无二的、现代化的UI风格，而无需修改代码逻辑

基本控件介绍

QMainWindow：

主窗口类（主界面），可以包含菜单栏、工具栏、状态栏、中心窗口等各种窗口部件，其中中心窗口是最重要的，可以是任何Qt窗口部件，常用成员函数：

setCentralWidget():设置中心窗口部件
setMenuBar():设置菜单栏
addToolBar():添加工具栏
statusBar():获取状态栏
show():显示主窗口

Qwidget:

是Qt框架中所有用户界面的基类，包括窗口、对话框、按钮、标签、文本框等，此外还提供一些基本的用户界面功能，例如绘制、事件处理、布局等。

QWidget提供了一些常用的属性和方法，例如size()、pos()、setWindowTitle()等，以便于管理和操作界面部件。

在创建自定义用户界面部件时，我们可以从QWidget派生出我们自己的部件类，并通过重载其成员函数来实现自定义行为。例如，我们可以通过重载QWidget的paintEvent()函数来绘制自己的部件，或者通过重载其mousePressEvent()函数来处理鼠标点击事件

QMain Window、Qwidget、QDialog的区别：

QDialog: 是对话窗口的基类，没有菜单栏、工具栏、状态栏。 QMainWindow：可以包含菜单栏、工具栏、状态栏和标题栏，是最常见的形式。 QWidget: 不确定窗口的用途，就使用Qwidget。

Spacers控件

用于布局的空白控件，在布局中创建空白区域来分隔其它控件，空白区域的大小由其内部设置size_policy控制。

该控件有两种类型：水平（QSpacerItem）和垂直（QSpacerItem），可以使用QHBoxLayout或QVBoxLayout将Spacer控件添加到布局中。在添加Spacer控件时，您可以指定其最小大小、最大大小和首选大小，以及其大小策略

Qlabel控件

显示文本或图像的控件，它通常被用于显示静态文本信息，可以通过设置其文本、字体、颜色、对齐方式等属性来自定义标签的样式和布局。可以将QLabel放置在主窗口、对话框或其他控件上，以便在应用程序中提供帮助文本、说明、状态消息等。

方法：

setText(text): 设置文本内容
setPixmap(pixmap): 设置图像内容
setAlignment(alignment): 设置文本或图像的对齐方式
setWordWrap( on): 当文本过长时是否自动换行
setFixedSize(width, height): 设置控件的固定大小
setStyleSheet(styleSheet): 设置控件的样式表

属性：

text(): 返回控件的文本内容
pixmap(): 返回控件的图像内容
alignment(): 返回控件的对齐方式
wordWrap(): 返回控件是否自动换行
font(): 返回控件的字体
color(): 返回控件的颜色

常用信号：

linkActivated:当控件中包含超链接时，用户单击链接时触发此信号。
linkHovered:当用户将鼠标悬停在超链接上时，触发此信号。
linkPressed:当用户按下并释放鼠标按钮时，同时鼠标位于超链接上时，触发此信号。

综合案例

import sys
from PyQt5.QtWidgets import (QApplication, QWidget, QLabel, QVBoxLayout, QLineEdit, 
                             QPushButton, QHBoxLayout, QFrame)
from PyQt5.QtCore import Qt, QTimer, pyqtSignal
from PyQt5.QtGui import QFont, QPalette, QColor, QPixmap, QLinearGradient, QBrush

# 自定义可点击QLabel（支持点击信号）
class ClickableLabel(QLabel):
    clicked = pyqtSignal()  # 自定义点击信号

    def __init__(self, text="", parent=None):
        super().__init__(text, parent)
        self.setCursor(Qt.PointingHandCursor)  # 设置手型光标

    def mousePressEvent(self, event):
        if event.button() == Qt.LeftButton:
            self.clicked.emit()  # 发射信号
        super().mousePressEvent(event)

class IntegratedDemo(QWidget):
    def __init__(self):
        super().__init__()
        self.setWindowTitle("QLabel功能集成示例")
        self.setGeometry(300, 300, 600, 500)
        self.initUI()
        
    def initUI(self):
        main_layout = QVBoxLayout()
        
        # ===== 1. 基础属性展示 =====
        frame1 = QFrame()
        frame1.setFrameShape(QFrame.Box)
        layout1 = QVBoxLayout()
        
        label_base = QLabel("基础属性示例：自定义字体/颜色/对齐")
        label_base.setFont(QFont("微软雅黑", 12, QFont.Bold))
        label_base.setStyleSheet("color: #FF0000; background-color: #FFFFCC;")
        label_base.setAlignment(Qt.AlignCenter)
        label_base.setFixedHeight(40)
        
        layout1.addWidget(label_base)
        frame1.setLayout(layout1)
        main_layout.addWidget(frame1)
        
        # ===== 2. 交互功能区域 =====
        frame2 = QFrame()
        frame2.setFrameShape(QFrame.Box)
        layout2 = QVBoxLayout()
        
        # 超链接交互
        link_label = QLabel('<a href="https://www.qt.io">访问Qt官网（悬停提示）</a>')
        link_label.setToolTip("点击打开Qt官方网站")
        link_label.linkHovered.connect(lambda link: print(f"链接悬停: {link}"))
        link_label.linkActivated.connect(self.open_link)
        
        # 自定义点击标签
        click_label = ClickableLabel("✨ 点我切换颜色（可点击标签）")
        click_label.setStyleSheet("border: 2px solid #9999FF; padding: 10px;")
        click_label.clicked.connect(self.toggle_label_color)
        
        layout2.addWidget(QLabel("交互功能区域："))
        layout2.addWidget(link_label)
        layout2.addWidget(click_label)
        frame2.setLayout(layout2)
        main_layout.addWidget(frame2)
        
        # ===== 3. 实时同步区域 =====
        frame3 = QFrame()
        frame3.setFrameShape(QFrame.Box)
        layout3 = QVBoxLayout()
        
        self.sync_lineedit = QLineEdit()
        self.sync_label = QLabel("同步显示文本")
        
        # 实时连接信号与槽
        self.sync_lineedit.textChanged.connect(self.sync_label.setText)
        
        layout3.addWidget(QLabel("实时同步：输入即更新"))
        layout3.addWidget(self.sync_lineedit)
        layout3.addWidget(self.sync_label)
        frame3.setLayout(layout3)
        main_layout.addWidget(frame3)
        
        # ===== 4. 动态效果区域 =====
        frame4 = QFrame()
        frame4.setFrameShape(QFrame.Box)
        layout4 = QVBoxLayout()
        
        # 充电进度效果
        self.charge_label = QLabel()
        self.charge_label.setFixedHeight(30)
        self.charge_label.setText("充电中: 0%")
        self.charge_label.setAlignment(Qt.AlignCenter)
        
        # 点击变色效果
        self.color_label = QLabel("点击下方按钮变色")
        self.color_label.setAlignment(Qt.AlignCenter)
        self.color_label.setFixedHeight(50)
        
        # 控制按钮
        btn_toggle = QPushButton("启动充电动画")
        btn_toggle.clicked.connect(self.toggle_charge_animation)
        btn_color = QPushButton("随机颜色")
        btn_color.clicked.connect(self.change_random_color)
        
        btn_layout = QHBoxLayout()
        btn_layout.addWidget(btn_toggle)
        btn_layout.addWidget(btn_color)
        
        layout4.addWidget(QLabel("动态效果区域："))
        layout4.addWidget(self.charge_label)
        layout4.addWidget(self.color_label)
        layout4.addLayout(btn_layout)
        frame4.setLayout(layout4)
        main_layout.addWidget(frame4)
        
        self.setLayout(main_layout)
        
        # 充电动画控制
        self.charge_timer = QTimer()
        self.charge_timer.timeout.connect(self.update_charge)
        self.charge_percent = 0
        self.is_charging = False

    # ===== 功能实现方法 =====
    def open_link(self, url):
        print(f"打开链接: {url}")  # 实际应用中可用QDesktopServices打开[1](@ref)
    
    def toggle_label_color(self):
        current_color = self.sender().palette().color(QPalette.Window)
        new_color = QColor("#FFCCFF") if current_color != QColor("#FFCCFF") else QColor("#CCFFFF")
        self.sender().setStyleSheet(f"background-color: {new_color.name()};")
        print("标签点击事件触发")
    
    def toggle_charge_animation(self):
        if not self.is_charging:
            self.charge_timer.start(200)  # 每200ms更新
            self.is_charging = True
        else:
            self.charge_timer.stop()
            self.is_charging = False
    
    def update_charge(self):
        self.charge_percent = (self.charge_percent + 5) % 105
        if self.charge_percent > 100:
            self.charge_label.setText("充电完成!")
            self.charge_timer.stop()
            self.is_charging = False
            return
        
        # 创建渐变进度条
        gradient = QLinearGradient(0, 0, self.charge_label.width(), 0)
        gradient.setColorAt(0, "#00FF00")
        gradient.setColorAt(self.charge_percent/100, "#00FF00")
        gradient.setColorAt(min(1.0, self.charge_percent/100 + 0.01), "#CCCCCC")
        
        # 应用渐变背景
        palette = self.charge_label.palette()
        palette.setBrush(QPalette.Window, QBrush(gradient))
        self.charge_label.setPalette(palette)
        self.charge_label.setText(f"充电中: {self.charge_percent}%")
    
    def change_random_color(self):
        color = QColor(randint(0,255), randint(0,255), randint(0,255))
        self.color_label.setStyleSheet(f"background-color: {color.name()}; color: white;")

if __name__ == "__main__":
    from random import randint
    app = QApplication(sys.argv)
    window = IntegratedDemo()
    window.show()
    sys.exit(app.exec_())

QLineEdit控件

该控件用于接收用户输入的单行文本编辑，允许输入和编辑文本信息；同时也可以限定输入内容的形式比如只允许输入数字、字母或特定字符，或者限定输入内容长度；可以使用信号和槽机制来处理用户输入的文本，以便在应用程序中执行特定的操作或验证用户输入的有效性。

方法：

setAlignment(alignment)：设置文本的对齐方式，alignment可以是Qt.AlignLeft、Qt.AlignRight、Qt.AlignCenter等值之一
setPlaceholderText(text)：设置控件的占位符文本，当控件没有内容时显示的文本
setReadOnly(readOnly)：设置控件是否为只读模式
setValidator(validator)：设置控件的输入验证器，用于限制用户输入的内容
textChanged.connect(slot)：文本改变时的信号，连接到相应的槽函数

属性：

text()：获取或设置控件的文本内容
setText(text)：设置控件的文本内容
clear()：清空控件的文本内容

综合案例

import sys
from PyQt5.QtWidgets import (QApplication, QWidget, QVBoxLayout, QLineEdit, QLabel, 
                            QPushButton, QHBoxLayout, QFormLayout, QCompleter)
from PyQt5.QtGui import QIntValidator, QDoubleValidator, QRegularExpressionValidator, QFont, QIcon
from PyQt5.QtCore import Qt, QRegularExpression

class LineEditDemo(QWidget):
    def __init__(self):
        super().__init__()
        self.initUI()
        
    def initUI(self):
        self.setWindowTitle("QLineEdit 综合功能演示")
        self.setGeometry(300, 300, 600, 450)
        layout = QVBoxLayout()
        
        # ===== 1. 基础功能区域 =====
        base_layout = QFormLayout()
        
        # 基础文本输入（实时反馈）
        self.basic_edit = QLineEdit()
        self.basic_edit.setPlaceholderText("输入实时显示在右侧")
        self.basic_label = QLabel("等待输入...")
        self.basic_edit.textChanged.connect(lambda: self.basic_label.setText(self.basic_edit.text()))
        base_layout.addRow("基础输入:", self.basic_edit)
        base_layout.addRow("实时反馈:", self.basic_label)
        
        # 整数验证（范围限制）
        self.int_edit = QLineEdit()
        self.int_edit.setValidator(QIntValidator(1, 100))  # 限制1-100整数
        self.int_edit.setPlaceholderText("输入1-100的整数")
        base_layout.addRow("整数验证:", self.int_edit)
        
        # 浮点数验证（格式限制）
        self.float_edit = QLineEdit()
        float_validator = QDoubleValidator(0.0, 100.0, 2)  # 范围0-100，2位小数
        float_validator.setNotation(QDoubleValidator.StandardNotation)
        self.float_edit.setValidator(float_validator)
        self.float_edit.setPlaceholderText("0.00-100.00")
        base_layout.addRow("浮点数验证:", self.float_edit)
        
        layout.addLayout(base_layout)
        
        # ===== 2. 高级功能区域 =====
        adv_layout = QFormLayout()
        
        # 正则表达式验证（邮箱格式）
        self.email_edit = QLineEdit()
        email_regex = QRegularExpression("^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}$")
        self.email_edit.setValidator(QRegularExpressionValidator(email_regex))
        self.email_edit.setPlaceholderText("example@domain.com")
        adv_layout.addRow("邮箱验证:", self.email_edit)
        
        # 输入掩码（电话号码）
        self.phone_edit = QLineEdit()
        self.phone_edit.setInputMask("999-9999-9999;#")  # 格式: 138-8888-8888
        adv_layout.addRow("电话掩码:", self.phone_edit)
        
        # 密码输入（显示切换）
        self.pwd_layout = QHBoxLayout()
        self.pwd_edit = QLineEdit()
        self.pwd_edit.setEchoMode(QLineEdit.Password)
        self.toggle_btn = QPushButton("显示")
        self.toggle_btn.setCheckable(True)
        self.toggle_btn.toggled.connect(self.toggle_pwd_visibility)
        self.pwd_layout.addWidget(self.pwd_edit)
        self.pwd_layout.addWidget(self.toggle_btn)
        adv_layout.addRow("密码输入:", self.pwd_layout)
        
        # 自动补全
        self.auto_edit = QLineEdit()
        completer = QCompleter(["Python", "Java", "C++", "JavaScript"])
        self.auto_edit.setCompleter(completer)
        self.auto_edit.setPlaceholderText("输入编程语言")
        adv_layout.addRow("自动补全:", self.auto_edit)
        
        layout.addLayout(adv_layout)
        
        # ===== 3. 交互反馈区域 =====
        feedback_layout = QHBoxLayout()
        
        # 清除按钮
        self.clear_edit = QLineEdit()
        self.clear_edit.setClearButtonEnabled(True)  # 启用内置清除按钮
        self.clear_edit.setPlaceholderText("输入后点击右侧X清除")
        feedback_layout.addWidget(QLabel("清除按钮:"))
        feedback_layout.addWidget(self.clear_edit)
        
        # 样式反馈
        self.style_edit = QLineEdit()
        self.style_edit.setPlaceholderText("输入'error'触发红色边框")
        self.style_edit.textChanged.connect(self.update_style)
        feedback_layout.addWidget(QLabel("动态样式:"))
        feedback_layout.addWidget(self.style_edit)
        
        layout.addLayout(feedback_layout)
        
        # ===== 4. 自定义操作按钮 =====
        action_layout = QHBoxLayout()
        self.action_edit = QLineEdit()
        self.action_edit.setPlaceholderText("右侧按钮可转为大写")
        
        # 添加自定义动作按钮
        upper_btn = QPushButton("⇧")
        upper_btn.clicked.connect(lambda: self.action_edit.setText(self.action_edit.text().upper()))
        action_layout.addWidget(QLabel("动作按钮:"))
        action_layout.addWidget(self.action_edit)
        action_layout.addWidget(upper_btn)
        
        layout.addLayout(action_layout)
        self.setLayout(layout)

    # ===== 功能实现方法 =====
    def toggle_pwd_visibility(self, checked):
        """切换密码显示/隐藏"""
        if checked:
            self.pwd_edit.setEchoMode(QLineEdit.Normal)
            self.toggle_btn.setText("隐藏")
        else:
            self.pwd_edit.setEchoMode(QLineEdit.Password)
            self.toggle_btn.setText("显示")

    def update_style(self, text):
        """根据输入内容动态更新样式"""
        if "error" in text.lower():
            self.style_edit.setStyleSheet("border: 2px solid red;")
        else:
            self.style_edit.setStyleSheet("")

if __name__ == '__main__':
    app = QApplication(sys.argv)
    demo = LineEditDemo()
    demo.show()
    sys.exit(app.exec_())

QTextEdit

该控件可以用于显示和编辑富文本的多行文本编辑控件。它可以用于创建编辑器、日记、HTML文本查看器等。可以在文本中插入多媒体内容，如图像、超链接、HTML表格等，并且可以在文本中使用样式来设置字体、颜色、背景、对齐等。QTextEdit还支持拼写检查、撤销/重做、自动缩进、文本选择等基本编辑功能

综合案例

import sys
from PyQt5.QtWidgets import (QApplication, QMainWindow, QTextEdit, QAction, QFileDialog, 
                            QToolBar, QStatusBar, QMessageBox, QColorDialog, QFontDialog)
from PyQt5.QtGui import QTextCursor, QTextCharFormat, QFont, QTextBlockFormat, QIcon, QPixmap
from PyQt5.QtCore import Qt

class RichTextEditor(QMainWindow):
    def __init__(self):
        super().__init__()
        self.setWindowTitle("QTextEdit 综合案例 - 富文本编辑器")
        self.setGeometry(300, 200, 900, 600)
        self.file_path = None
        self.init_ui()
        
    def init_ui(self):
        # ===== 1. 核心控件：QTextEdit =====
        self.text_edit = QTextEdit()
        self.text_edit.setAcceptRichText(True)  # 启用富文本支持
        self.text_edit.setPlaceholderText("输入内容或使用工具栏进行操作...")
        self.setCentralWidget(self.text_edit)
        
        # ===== 2. 菜单栏 =====
        self.create_menus()
        
        # ===== 3. 工具栏 =====
        toolbar = QToolBar("格式工具栏")
        self.addToolBar(toolbar)
        
        # 文本样式动作 - 使用文本代替图标
        bold_action = QAction("B", self)  # 使用文本代替图标
        bold_action.setToolTip("加粗")
        bold_action.triggered.connect(lambda: self.set_text_format("bold"))
        toolbar.addAction(bold_action)
        
        italic_action = QAction("I", self)
        italic_action.setToolTip("斜体")
        italic_action.triggered.connect(lambda: self.set_text_format("italic"))
        toolbar.addAction(italic_action)
        
        underline_action = QAction("U", self)
        underline_action.setToolTip("下划线")
        underline_action.triggered.connect(lambda: self.set_text_format("underline"))
        toolbar.addAction(underline_action)
        
        toolbar.addSeparator()
        
        # 字体选择
        font_action = QAction("字体", self)
        font_action.triggered.connect(self.choose_font)
        toolbar.addAction(font_action)
        
        # 颜色选择
        color_action = QAction("颜色", self)
        color_action.triggered.connect(self.choose_color)
        toolbar.addAction(color_action)
        
        toolbar.addSeparator()
        
        # 段落对齐
        align_left = QAction("左对齐", self)
        align_left.triggered.connect(lambda: self.set_alignment(Qt.AlignLeft))
        toolbar.addAction(align_left)
        
        align_center = QAction("居中", self)
        align_center.triggered.connect(lambda: self.set_alignment(Qt.AlignCenter))
        toolbar.addAction(align_center)
        
        align_right = QAction("右对齐", self)
        align_right.triggered.connect(lambda: self.set_alignment(Qt.AlignRight))
        toolbar.addAction(align_right)
        
        toolbar.addSeparator()
        
        # 插入功能
        insert_image = QAction("插入图片", self)
        insert_image.triggered.connect(self.insert_image)
        toolbar.addAction(insert_image)
        
        insert_link = QAction("插入链接", self)
        insert_link.triggered.connect(self.insert_link)
        toolbar.addAction(insert_link)
        
        # ===== 4. 状态栏 =====
        self.status_bar = QStatusBar()
        self.setStatusBar(self.status_bar)
        self.text_edit.textChanged.connect(self.update_status_bar)
        
        # ===== 5. 信号连接 =====
        self.text_edit.cursorPositionChanged.connect(self.cursor_position_changed)
        self.text_edit.selectionChanged.connect(self.selection_changed)
        
    def create_menus(self):
        menubar = self.menuBar()
        
        # 文件菜单
        file_menu = menubar.addMenu("文件")
        
        new_action = QAction("新建", self)
        new_action.setShortcut("Ctrl+N")
        new_action.triggered.connect(self.new_file)
        file_menu.addAction(new_action)
        
        open_action = QAction("打开", self)
        open_action.setShortcut("Ctrl+O")
        open_action.triggered.connect(self.open_file)
        file_menu.addAction(open_action)
        
        save_action = QAction("保存", self)
        save_action.setShortcut("Ctrl+S")
        save_action.triggered.connect(self.save_file)
        file_menu.addAction(save_action)
        
        save_as_action = QAction("另存为", self)
        save_as_action.triggered.connect(self.save_file_as)
        file_menu.addAction(save_as_action)
        
        file_menu.addSeparator()
        
        exit_action = QAction("退出", self)
        exit_action.setShortcut("Ctrl+Q")
        exit_action.triggered.connect(self.close)
        file_menu.addAction(exit_action)
        
        # 编辑菜单
        edit_menu = menubar.addMenu("编辑")
        
        undo_action = QAction("撤销", self)
        undo_action.setShortcut("Ctrl+Z")
        undo_action.triggered.connect(self.text_edit.undo)
        edit_menu.addAction(undo_action)
        
        redo_action = QAction("重做", self)
        redo_action.setShortcut("Ctrl+Y")
        redo_action.triggered.connect(self.text_edit.redo)
        edit_menu.addAction(redo_action)
        
        edit_menu.addSeparator()
        
        cut_action = QAction("剪切", self)
        cut_action.setShortcut("Ctrl+X")
        cut_action.triggered.connect(self.text_edit.cut)
        edit_menu.addAction(cut_action)
        
        copy_action = QAction("复制", self)
        copy_action.setShortcut("Ctrl+C")
        copy_action.triggered.connect(self.text_edit.copy)
        edit_menu.addAction(copy_action)
        
        paste_action = QAction("粘贴", self)
        paste_action.setShortcut("Ctrl+V")
        paste_action.triggered.connect(self.text_edit.paste)
        edit_menu.addAction(paste_action)
        
        # 视图菜单
        view_menu = menubar.addMenu("视图")
        
        readonly_action = QAction("只读模式", self, checkable=True)
        readonly_action.toggled.connect(self.toggle_readonly)
        view_menu.addAction(readonly_action)
        
        # 大文件优化功能
        large_file_action = QAction("加载大文件(分页)", self)
        large_file_action.triggered.connect(self.load_large_file)
        view_menu.addAction(large_file_action)

    # ===== 功能实现方法 =====
    def set_text_format(self, style):
        """设置文本格式（加粗/斜体/下划线）"""
        cursor = self.text_edit.textCursor()
        if not cursor.hasSelection():
            # 如果没有选择文本，则对即将输入的文本应用格式
            format = QTextCharFormat()
            if style == "bold":
                format.setFontWeight(QFont.Bold if not self.text_edit.fontWeight() == QFont.Bold else QFont.Normal)
            elif style == "italic":
                format.setFontItalic(not self.text_edit.fontItalic())
            elif style == "underline":
                format.setFontUnderline(not self.text_edit.fontUnderline())
                
            self.text_edit.setCurrentCharFormat(format)
            return
            
        fmt = QTextCharFormat()
        if style == "bold":
            fmt.setFontWeight(QFont.Bold if not cursor.charFormat().font().bold() else QFont.Normal)
        elif style == "italic":
            fmt.setFontItalic(not cursor.charFormat().fontItalic())
        elif style == "underline":
            fmt.setFontUnderline(not cursor.charFormat().fontUnderline())
        cursor.mergeCharFormat(fmt)

    def choose_font(self):
        """选择字体"""
        font, ok = QFontDialog.getFont(self.text_edit.font(), self)
        if ok:
            self.text_edit.setCurrentFont(font)

    def choose_color(self):
        """选择颜色"""
        color = QColorDialog.getColor()
        if color.isValid():
            self.text_edit.setTextColor(color)

    def set_alignment(self, alignment):
        """设置段落对齐方式"""
        cursor = self.text_edit.textCursor()
        block_fmt = QTextBlockFormat()
        block_fmt.setAlignment(alignment)
        cursor.mergeBlockFormat(block_fmt)

    def insert_image(self):
        """插入图片到光标位置"""
        file_path, _ = QFileDialog.getOpenFileName(
            self, "选择图片", "", "图片文件 (*.png *.jpg *.jpeg *.bmp *.gif)"
        )
        if file_path:
            cursor = self.text_edit.textCursor()
            # 使用QPixmap加载图片并插入
            pixmap = QPixmap(file_path)
            if not pixmap.isNull():
                # 缩放图片以适应编辑器宽度
                pixmap = pixmap.scaledToWidth(300, Qt.SmoothTransformation)
                cursor.insertImage(pixmap.toImage())

    def insert_link(self):
        """插入超链接"""
        from PyQt5.QtWidgets import QInputDialog
        
        text, ok = QInputDialog.getText(self, "插入链接", "请输入链接URL:")
        if ok and text:
            cursor = self.text_edit.textCursor()
            # 如果选择了文本，使用选中文本作为链接文本，否则使用URL
            if cursor.hasSelection():
                link_text = cursor.selectedText()
            else:
                link_text = text
                
            cursor.insertHtml(f'<a href="{text}">{link_text}</a>')

    def new_file(self):
        """新建文件"""
        if self.check_unsaved_changes():
            self.text_edit.clear()
            self.file_path = None
            self.setWindowTitle("QTextEdit 综合案例 - 富文本编辑器")

    def open_file(self):
        """打开文件"""
        if not self.check_unsaved_changes():
            return
            
        path, _ = QFileDialog.getOpenFileName(
            self, "打开文件", "", 
            "文本文件 (*.txt);;HTML文件 (*.html *.htm);;所有文件 (*)"
        )
        if path:
            try:
                with open(path, 'r', encoding='utf-8') as f:
                    if path.endswith(('.html', '.htm')):
                        self.text_edit.setHtml(f.read())
                    else:
                        self.text_edit.setPlainText(f.read())
                self.file_path = path
                self.setWindowTitle(f"QTextEdit 综合案例 - {path}")
            except Exception as e:
                QMessageBox.critical(self, "打开错误", f"打开文件时出错:\n{str(e)}")

    def save_file(self):
        """保存文件"""
        if self.file_path:
            self._save_to_file(self.file_path)
        else:
            self.save_file_as()

    def save_file_as(self):
        """另存为文件"""
        path, _ = QFileDialog.getSaveFileName(
            self, "保存文件", "", 
            "文本文件 (*.txt);;HTML文件 (*.html);;所有文件 (*)"
        )
        if path:
            self._save_to_file(path)
            self.file_path = path
            self.setWindowTitle(f"QTextEdit 综合案例 - {path}")

    def _save_to_file(self, path):
        """实际保存操作"""
        try:
            with open(path, 'w', encoding='utf-8') as f:
                if path.endswith('.html'):
                    f.write(self.text_edit.toHtml())
                else:
                    f.write(self.text_edit.toPlainText())
            self.text_edit.document().setModified(False)
            self.status_bar.showMessage(f"文件已保存: {path}", 3000)
        except Exception as e:
            QMessageBox.critical(self, "保存错误", f"保存文件时出错:\n{str(e)}")

    def toggle_readonly(self, state):
        """切换只读模式"""
        self.text_edit.setReadOnly(state)
        self.status_bar.showMessage(f"只读模式: {'开启' if state else '关闭'}", 2000)

    def update_status_bar(self):
        """更新状态栏统计信息"""
        text = self.text_edit.toPlainText()
        char_count = len(text)
        word_count = len(text.split())
        line_count = self.text_edit.document().blockCount()
        self.status_bar.showMessage(f"字符: {char_count} | 单词: {word_count} | 行数: {line_count}")

    def cursor_position_changed(self):
        """光标位置变化时显示行列号"""
        cursor = self.text_edit.textCursor()
        line = cursor.blockNumber() + 1
        col = cursor.columnNumber() + 1
        self.status_bar.showMessage(f"行: {line}, 列: {col}", 2000)

    def selection_changed(self):
        """文本选中时显示选中信息"""
        cursor = self.text_edit.textCursor()
        if cursor.hasSelection():
            selected = cursor.selectedText()
            self.status_bar.showMessage(f"已选: {len(selected)} 字符", 2000)

    def load_large_file(self):
        """大文件分页加载优化"""
        path, _ = QFileDialog.getOpenFileName(self, "打开大文件", "", "文本文件 (*.txt)")
        if not path:
            return
            
        # 大文件优化：只加载最后100行
        try:
            with open(path, 'r', encoding='utf-8', errors='ignore') as f:
                lines = []
                # 高效读取最后100行
                for line in f:
                    lines.append(line)
                    if len(lines) > 100:
                        lines.pop(0)
                
                self.text_edit.setPlainText(''.join(lines))
            self.status_bar.showMessage(f"已加载大文件最后100行: {path}", 5000)
        except Exception as e:
            QMessageBox.critical(self, "文件错误", f"读取文件失败:\n{str(e)}")

    def check_unsaved_changes(self):
        """检查未保存的更改"""
        if self.text_edit.document().isModified():
            reply = QMessageBox.question(self, "未保存更改", 
                                        "当前文档有未保存的更改。是否保存？",
                                        QMessageBox.Save | QMessageBox.Discard | QMessageBox.Cancel)
            if reply == QMessageBox.Save:
                self.save_file()
                return True
            elif reply == QMessageBox.Cancel:
                return False
        return True

if __name__ == '__main__':
    app = QApplication(sys.argv)
    editor = RichTextEditor()
    editor.show()
    sys.exit(app.exec_())

QDialog

该控件是常用的对话窗口，为QWidget的子类，例如询问用户是否需要保存文件，输入数据或显示一些信息，可以设置对话框的标题、大小、位置等属性，也可以添加各种控件，例如标签、按钮、文本框等，可以捕获对话框关闭事件和其他事件，可以返回一些数据或响应用户的操作。

方法：

exec_()：将对话框设置为模态并运行对话框的事件循环，直到对话框被关闭。此方法通常用于从对话框中获取一些数据或响应用户的操作。
show()：显示对话框，但不将其设置为模态。此方法通常用于显示一些信息或提供一些选项。
done(int result)：设置对话框的返回值，并关闭对话框。此方法通常在用户进行某些操作后调用，以便通知调用方对话框的结果。
accept()：设置对话框的返回值为QDialog.Accepted，并关闭对话框。此方法通常在用户确认某些操作后调用，以便通知调用方对话框的结果。
ect()：设置对话框的返回值为QDialog.Rejected，并关闭对话框。此方法通常在用户取消某些操作后调用，以便通知调用方对话框的结果。
setButtonLayout(list)：设置对话框底部的按钮布局。参数list应该是一个QDialogButtonBox中定义的一组按钮类型，例如QDialogButtonBox.Ok | QDialogButtonBox.Cancel
open()：将对话框设置为模态并运行对话框的事件循环，直到对话框被关闭。此方法与exec_()方法类似，但可以方便地打开多个对话框

除了上述方法外，QDialog还提供了一些其他方法，例如resize()、move()、close()、setVisible()等，这些方法与QWidget类似，用于设置对话框的大小、位置、可见性等

属性：

windowTitle：对话框的标题
windowIcon：对话框的图标
sizeGripEnabled：是否显示调整大小的手柄，默认为False
layout：对话框的布局管理器，用于控制对话框内部控件的位置和大小
modal：是否将对话框设置为模态，即禁止用户与其他窗口交互，直到对话框被关闭，默认为True。
result：对话框的返回值，通常用于表示用户的操作或输入。如果对话框是通过exec_()方法调用的，则返回值是对话框的退出码（通常是QDialog.Accepted或QDialog.Rejected）；如果对话框是通过show()方法调用的，则返回值始终是None
sizeHint：对话框的推荐大小。
acceptMode：对话框的接受模式，可以是QFileDialog.AcceptOpen（打开文件）、QFileDialog.AcceptSave（保存文件）或QFileDialog.AcceptSave（选择文件夹）
rejectAction：当用户按下Esc键或者点击“取消”按钮时，对话框执行的操作。默认情况下，对话框将执行reject()方法并关闭

信号：

finished(int result)：当对话框关闭并且返回值已经设置时发出。参数result表示对话框的返回值
accepted()：当用户确认某些操作并调用accept()方法时发出
rejected()：当用户取消某些操作并调用reject()方法时发出
resizeEvent(event)：当对话框的大小改变时发出。可以重写此方法来执行一些特定的操作

几种类型

普通对话框(QDialog)：最基本的对话框类型，用于显示消息、获取输入、提供选项等。它可以通过设置各种属性和使用布局管理器来控制对话框的大小、位置和内容
文件对话框(QFileDialog)：用于选择文件或文件夹的对话框。可以使用QFileDialog的静态方法创建各种类型的文件对话框，例如打开文件对话框、保存文件对话框、选择文件夹对话框等。
字体对话框(QFontDialog)：用于选择字体和字号的对话框。可以使用QFontDialog的静态方法创建字体对话框。
颜色对话框(QColorDialog)：用于选择颜色的对话框。可以使用QColorDialog的静态方法创建颜色对话框。
输入对话框(QInputDialog)：用于获取用户输入的对话框。可以使用QInputDialog的静态方法创建各种类型的输入对话框，例如文本输入对话框、整数输入对话框、浮点数输入对话框等。
消息框(QMessageBox)：用于显示消息和提供选项的对话框。可以使用QMessageBox的静态方法创建各种类型的消息框，例如信息框、警告框、错误框、询问框等.
鼠标指针对话框(QCursor)：用于显示不同类型的鼠标指针。可以使用QCursor的静态方法创建各种类型的鼠标指针对话框，例如箭头、十字形、等待指针等。

综合案例

import sys
import os
from PyQt5.QtWidgets import (QApplication, QDialog, QVBoxLayout, QHBoxLayout, 
                             QTextEdit, QPushButton, QMenuBar, QMenu, QAction, 
                             QFileDialog, QFontDialog, QInputDialog, QMessageBox)
from PyQt5.QtGui import QTextCursor, QCursor
from PyQt5.QtCore import Qt

class TextEditor(QDialog):
    def __init__(self):
        super().__init__()
        self.current_file = None
        self.init_ui()
        
    def init_ui(self):
        # 设置窗口属性
        self.setWindowTitle('简易文本编辑器 - PyQt5对话框示例')
        self.setGeometry(100, 100, 800, 600)
        
        # 创建主布局
        main_layout = QVBoxLayout()
        
        # 创建菜单栏
        menubar = QMenuBar()
        file_menu = QMenu('文件', self)
        edit_menu = QMenu('编辑', self)
        format_menu = QMenu('格式', self)
        help_menu = QMenu('帮助', self)
        
        # 添加文件菜单动作
        new_action = QAction('新建', self)
        new_action.triggered.connect(self.new_file)
        open_action = QAction('打开', self)
        open_action.triggered.connect(self.open_file)
        save_action = QAction('保存', self)
        save_action.triggered.connect(self.save_file)
        save_as_action = QAction('另存为', self)
        save_as_action.triggered.connect(self.save_as_file)
        exit_action = QAction('退出', self)
        exit_action.triggered.connect(self.close)
        
        file_menu.addAction(new_action)
        file_menu.addAction(open_action)
        file_menu.addAction(save_action)
        file_menu.addAction(save_as_action)
        file_menu.addSeparator()
        file_menu.addAction(exit_action)
        
        # 添加编辑菜单动作
        find_action = QAction('查找', self)
        find_action.triggered.connect(self.find_text)
        replace_action = QAction('替换', self)
        replace_action.triggered.connect(self.replace_text)
        
        edit_menu.addAction(find_action)
        edit_menu.addAction(replace_action)
        
        # 添加格式菜单动作
        font_action = QAction('字体', self)
        font_action.triggered.connect(self.change_font)
        
        format_menu.addAction(font_action)
        
        # 添加帮助菜单动作
        about_action = QAction('关于', self)
        about_action.triggered.connect(self.show_about)
        
        help_menu.addAction(about_action)
        
        # 将菜单添加到菜单栏
        menubar.addMenu(file_menu)
        menubar.addMenu(edit_menu)
        menubar.addMenu(format_menu)
        menubar.addMenu(help_menu)
        
        # 创建文本编辑区域
        self.text_edit = QTextEdit()
        
        # 创建底部按钮
        button_layout = QHBoxLayout()
        
        clear_btn = QPushButton('清空内容')
        clear_btn.clicked.connect(self.clear_text)
        
        status_btn = QPushButton('统计字数')
        status_btn.clicked.connect(self.count_words)
        
        button_layout.addWidget(clear_btn)
        button_layout.addWidget(status_btn)
        button_layout.addStretch()
        
        # 将组件添加到主布局
        main_layout.setMenuBar(menubar)
        main_layout.addWidget(self.text_edit)
        main_layout.addLayout(button_layout)
        
        self.setLayout(main_layout)
    
    def new_file(self):
        # 使用消息对话框确认是否保存当前文件 [7](@ref)
        if self.text_edit.document().isModified():
            reply = QMessageBox.question(self, '确认', 
                                       '当前文档已修改，是否保存？',
                                       QMessageBox.Save | QMessageBox.Discard | QMessageBox.Cancel)
            
            if reply == QMessageBox.Save:
                self.save_file()
            elif reply == QMessageBox.Cancel:
                return
        
        self.text_edit.clear()
        self.current_file = None
        self.setWindowTitle('新建文件 - 简易文本编辑器')
    
    def open_file(self):
        # 使用文件对话框选择文件 [1](@ref)
        file_path, _ = QFileDialog.getOpenFileName(self, '打开文件', '', 
                                                 '文本文件 (*.txt);;所有文件 (*)')
        
        if file_path:
            try:
                with open(file_path, 'r', encoding='utf-8') as f:
                    self.text_edit.setText(f.read())
                self.current_file = file_path
                self.setWindowTitle(f'{os.path.basename(file_path)} - 简易文本编辑器')
            except Exception as e:
                QMessageBox.critical(self, '错误', f'无法打开文件: {str(e)}')
    
    def save_file(self):
        if self.current_file:
            try:
                with open(self.current_file, 'w', encoding='utf-8') as f:
                    f.write(self.text_edit.toPlainText())
                self.text_edit.document().setModified(False)
                QMessageBox.information(self, '成功', '文件已保存！')
            except Exception as e:
                QMessageBox.critical(self, '错误', f'无法保存文件: {str(e)}')
        else:
            self.save_as_file()
    
    def save_as_file(self):
        # 使用文件对话框选择保存路径 [1](@ref)
        file_path, _ = QFileDialog.getSaveFileName(self, '另存为', '', 
                                                 '文本文件 (*.txt);;所有文件 (*)')
        
        if file_path:
            try:
                with open(file_path, 'w', encoding='utf-8') as f:
                    f.write(self.text_edit.toPlainText())
                self.current_file = file_path
                self.setWindowTitle(f'{os.path.basename(file_path)} - 简易文本编辑器')
                self.text_edit.document().setModified(False)
                QMessageBox.information(self, '成功', '文件已保存！')
            except Exception as e:
                QMessageBox.critical(self, '错误', f'无法保存文件: {str(e)}')
    
    def find_text(self):
        # 使用输入对话框获取查找内容 [2](@ref)
        text, ok = QInputDialog.getText(self, '查找', '输入要查找的内容:')
        
        if ok and text:
            # 使用QCursor改变光标状态
            QApplication.setOverrideCursor(QCursor(Qt.WaitCursor))
            content = self.text_edit.toPlainText()
            if text in content:
                # 定位到找到的文本
                cursor = self.text_edit.textCursor()
                cursor.movePosition(QTextCursor.Start)
                self.text_edit.setTextCursor(cursor)
                
                # 高亮所有匹配项
                self.text_edit.moveCursor(QTextCursor.Start)
                format = self.text_edit.textCursor().charFormat()
                format.setBackground(Qt.yellow)
                
                while self.text_edit.find(text):
                    self.text_edit.textCursor().setCharFormat(format)
                
                QMessageBox.information(self, '查找', f'找到 "{text}"！')
            else:
                QMessageBox.information(self, '查找', f'未找到 "{text}"')
            
            QApplication.restoreOverrideCursor()
    
    def replace_text(self):
        # 使用输入对话框获取替换内容 [2](@ref)
        find_text, ok1 = QInputDialog.getText(self, '替换', '输入要查找的内容:')
        
        if ok1 and find_text:
            replace_text, ok2 = QInputDialog.getText(self, '替换', '输入替换内容:')
            
            if ok2:
                content = self.text_edit.toPlainText()
                if find_text in content:
                    new_content = content.replace(find_text, replace_text)
                    self.text_edit.setPlainText(new_content)
                    QMessageBox.information(self, '替换', '替换完成！')
                else:
                    QMessageBox.information(self, '替换', f'未找到 "{find_text}"')
    
    def change_font(self):
        # 使用字体对话框选择字体 [8](@ref)
        current_font = self.text_edit.currentFont()
        font, ok = QFontDialog.getFont(current_font, self, '选择字体')
        
        if ok:
            self.text_edit.setCurrentFont(font)
    
    def clear_text(self):
        # 使用消息对话框确认清空操作 [7](@ref)
        reply = QMessageBox.question(self, '确认', 
                                   '确定要清空所有内容吗？',
                                   QMessageBox.Yes | QMessageBox.No)
        
        if reply == QMessageBox.Yes:
            self.text_edit.clear()
    
    def count_words(self):
        text = self.text_edit.toPlainText()
        char_count = len(text)
        word_count = len(text.split())
        line_count = text.count('\n') + 1 if text else 0
        
        # 使用消息对话框显示统计结果 [7](@ref)
        QMessageBox.information(self, '统计信息', 
                              f'字符数: {char_count}\n单词数: {word_count}\n行数: {line_count}')
    
    def show_about(self):
        # 使用消息对话框显示关于信息 [7](@ref)
        QMessageBox.about(self, '关于', 
                         '简易文本编辑器\n\n'
                         '演示PyQt5各种对话框的使用:\n'
                         '- QFileDialog: 文件打开和保存\n'
                         '- QFontDialog: 字体选择\n'
                         '- QInputDialog: 文本输入\n'
                         '- QMessageBox: 消息提示\n'
                         '- QCursor: 光标控制')
    
    def closeEvent(self, event):
        # 重写关闭事件，确认是否保存 [7](@ref)
        if self.text_edit.document().isModified():
            reply = QMessageBox.question(self, '确认退出', 
                                       '文档已修改，是否保存？',
                                       QMessageBox.Save | QMessageBox.Discard | QMessageBox.Cancel)
            
            if reply == QMessageBox.Save:
                self.save_file()
                event.accept()
            elif reply == QMessageBox.Discard:
                event.accept()
            else:
                event.ignore()
        else:
            event.accept()


if __name__ == '__main__':
    app = QApplication(sys.argv)
    editor = TextEditor()
    editor.show()
    sys.exit(app.exec_())

容器

常见的PyQt容器有：

QMainWindow：主窗口容器，通常包含菜单栏、工具栏、状态栏等
QWidget：基本的用户界面元素容器，可以作为其他容器的子容器
QGroupBox：分组框容器，可以将相关的组件放到一个分组框中，使它们更易于组织和查看
QTabWidget：选项卡容器，可以在多个选项卡中放置不同的组件，让用户轻松地在它们之间切换
QStackedWidget：堆栈容器，可以在同一位置上堆叠多个组件，只显示其中的一个，让用户可以轻松地在它们之间切换
QScrollArea：滚动区域容器，当容器中的组件太大，无法在当前视图中完全显示时，可以使用滚动区域容器
QSplitter：拆分器容器，可以将容器水平或垂直拆分为两个或更多子容器，让用户可以自由地调整它们的大小
QToolBar：工具栏容器，可以在主窗口或其他容器中放置多个工具栏，让用户可以快速访问常用功能

QGroupBox使用示例：

import sys
from PyQt5.QtWidgets import (QApplication, QDialog, QVBoxLayout, QHBoxLayout,
                             QGroupBox, QRadioButton, QCheckBox, QPushButton,
                             QLineEdit, QLabel, QComboBox)

class GroupBoxExample(QDialog):
    def __init__(self):
        super().__init__()
        self.setWindowTitle('QGroupBox 示例')
        self.setGeometry(300, 300, 400, 300)
        self.init_ui()
        
    def init_ui(self):
        main_layout = QVBoxLayout()
        
        # 创建第一个分组框 - 单选按钮组
        radio_group = QGroupBox("用户类型")
        radio_layout = QVBoxLayout()
        
        self.student_radio = QRadioButton("学生")
        self.teacher_radio = QRadioButton("教师")
        self.admin_radio = QRadioButton("管理员")
        
        self.student_radio.setChecked(True)
        
        radio_layout.addWidget(self.student_radio)
        radio_layout.addWidget(self.teacher_radio)
        radio_layout.addWidget(self.admin_radio)
        radio_group.setLayout(radio_layout)
        
        # 创建第二个分组框 - 复选框组
        checkbox_group = QGroupBox("兴趣爱好")
        checkbox_layout = QVBoxLayout()
        
        self.reading_check = QCheckBox("阅读")
        self.sports_check = QCheckBox("运动")
        self.music_check = QCheckBox("音乐")
        self.travel_check = QCheckBox("旅行")
        
        checkbox_layout.addWidget(self.reading_check)
        checkbox_layout.addWidget(self.sports_check)
        checkbox_layout.addWidget(self.music_check)
        checkbox_layout.addWidget(self.travel_check)
        checkbox_group.setLayout(checkbox_layout)
        
        # 创建第三个分组框 - 表单输入
        form_group = QGroupBox("个人信息")
        form_layout = QVBoxLayout()
        
        name_layout = QHBoxLayout()
        name_layout.addWidget(QLabel("姓名:"))
        self.name_input = QLineEdit()
        name_layout.addWidget(self.name_input)
        form_layout.addLayout(name_layout)
        
        age_layout = QHBoxLayout()
        age_layout.addWidget(QLabel("年龄:"))
        self.age_combo = QComboBox()
        self.age_combo.addItems([str(i) for i in range(18, 66)])
        age_layout.addWidget(self.age_combo)
        form_layout.addLayout(age_layout)
        
        form_group.setLayout(form_layout)
        
        # 提交按钮
        submit_btn = QPushButton("提交信息")
        submit_btn.clicked.connect(self.show_info)
        
        # 添加到主布局
        main_layout.addWidget(radio_group)
        main_layout.addWidget(checkbox_group)
        main_layout.addWidget(form_group)
        main_layout.addWidget(submit_btn)
        
        self.setLayout(main_layout)
    
    def show_info(self):
        # 获取用户类型
        user_type = "学生" if self.student_radio.isChecked() else \
                   "教师" if self.teacher_radio.isChecked() else "管理员"
        
        # 获取兴趣爱好
        hobbies = []
        if self.reading_check.isChecked(): hobbies.append("阅读")
        if self.sports_check.isChecked(): hobbies.append("运动")
        if self.music_check.isChecked(): hobbies.append("音乐")
        if self.travel_check.isChecked(): hobbies.append("旅行")
        
        # 获取个人信息
        name = self.name_input.text() or "未填写"
        age = self.age_combo.currentText()
        
        # 显示结果
        print(f"用户类型: {user_type}")
        print(f"姓名: {name}, 年龄: {age}")
        print(f"兴趣爱好: {', '.join(hobbies) if hobbies else '无'}")
        print("-" * 30)


if __name__ == '__main__':
    app = QApplication(sys.argv)
    window = GroupBoxExample()
    window.show()
    sys.exit(app.exec_())

QTabWidget使用示例：

import sys
from PyQt5.QtWidgets import (QApplication, QMainWindow, QTabWidget, QWidget, 
                             QVBoxLayout, QLabel, QPushButton, QLineEdit,
                             QListWidget, QTextEdit, QHBoxLayout)

class TabWidgetExample(QMainWindow):
    def __init__(self):
        super().__init__()
        self.setWindowTitle('QTabWidget 示例')
        self.setGeometry(100, 100, 600, 400)
        self.init_ui()
        
    def init_ui(self):
        # 创建主窗口的中心部件
        central_widget = QWidget()
        self.setCentralWidget(central_widget)
        
        # 创建主布局
        main_layout = QVBoxLayout(central_widget)
        
        # 创建标签页部件
        self.tab_widget = QTabWidget()
        
        # 创建三个标签页
        self.create_tab1()
        self.create_tab2()
        self.create_tab3()
        
        # 将标签页添加到主布局
        main_layout.addWidget(self.tab_widget)
        
        # 添加状态标签
        self.status_label = QLabel("当前标签: 信息页")
        main_layout.addWidget(self.status_label)
        
        # 连接标签切换信号
        self.tab_widget.currentChanged.connect(self.tab_changed)
    
    def create_tab1(self):
        """创建第一个标签页 - 信息页"""
        tab1 = QWidget()
        layout = QVBoxLayout(tab1)
        
        # 添加一些控件
        layout.addWidget(QLabel("欢迎使用标签页示例程序"))
        layout.addWidget(QLabel("这是第一个标签页"))
        
        # 添加输入框
        self.name_input = QLineEdit()
        self.name_input.setPlaceholderText("请输入您的姓名")
        layout.addWidget(self.name_input)
        
        # 添加按钮
        greet_btn = QPushButton("打招呼")
        greet_btn.clicked.connect(self.greet_user)
        layout.addWidget(greet_btn)
        
        # 添加结果标签
        self.greet_label = QLabel("")
        layout.addWidget(self.greet_label)
        
        layout.addStretch()
        self.tab_widget.addTab(tab1, "信息页")
    
    def create_tab2(self):
        """创建第二个标签页 - 列表页"""
        tab2 = QWidget()
        layout = QVBoxLayout(tab2)
        
        # 添加列表控件
        layout.addWidget(QLabel("项目列表:"))
        self.list_widget = QListWidget()
        self.list_widget.addItems(["项目1", "项目2", "项目3", "项目4"])
        layout.addWidget(self.list_widget)
        
        # 添加按钮布局
        btn_layout = QHBoxLayout()
        
        add_btn = QPushButton("添加项目")
        add_btn.clicked.connect(self.add_item)
        btn_layout.addWidget(add_btn)
        
        remove_btn = QPushButton("删除项目")
        remove_btn.clicked.connect(self.remove_item)
        btn_layout.addWidget(remove_btn)
        
        layout.addLayout(btn_layout)
        layout.addStretch()
        self.tab_widget.addTab(tab2, "列表页")
    
    def create_tab3(self):
        """创建第三个标签页 - 编辑页"""
        tab3 = QWidget()
        layout = QVBoxLayout(tab3)
        
        # 添加文本编辑控件
        layout.addWidget(QLabel("编辑区域:"))
        self.text_edit = QTextEdit()
        self.text_edit.setPlaceholderText("在此输入文本...")
        layout.addWidget(self.text_edit)
        
        # 添加按钮
        clear_btn = QPushButton("清空内容")
        clear_btn.clicked.connect(self.clear_text)
        layout.addWidget(clear_btn)
        
        layout.addStretch()
        self.tab_widget.addTab(tab3, "编辑页")
    
    def greet_user(self):
        """打招呼按钮的槽函数"""
        name = self.name_input.text().strip()
        if name:
            self.greet_label.setText(f"你好, {name}!")
        else:
            self.greet_label.setText("请输入您的姓名")
    
    def add_item(self):
        """添加项目按钮的槽函数"""
        self.list_widget.addItem(f"项目{self.list_widget.count() + 1}")
    
    def remove_item(self):
        """删除项目按钮的槽函数"""
        current_row = self.list_widget.currentRow()
        if current_row >= 0:
            self.list_widget.takeItem(current_row)
    
    def clear_text(self):
        """清空文本按钮的槽函数"""
        self.text_edit.clear()
    
    def tab_changed(self, index):
        """标签切换时的槽函数"""
        tab_name = self.tab_widget.tabText(index)
        self.status_label.setText(f"当前标签: {tab_name}")


if __name__ == '__main__':
    app = QApplication(sys.argv)
    window = TabWidgetExample()
    window.show()
    sys.exit(app.exec_())

QStackedWidget使用示例：

import sys
from PyQt5.QtWidgets import (QApplication, QMainWindow, QStackedWidget, QWidget,
                             QVBoxLayout, QLabel, QPushButton, QLineEdit,
                             QListWidget, QTextEdit, QHBoxLayout, QGroupBox)


class StackedWidgetExample(QMainWindow):
    def __init__(self):
        super().__init__()
        self.setWindowTitle('QStackedWidget 示例')
        self.setGeometry(100, 100, 600, 400)
        self.init_ui()

    def init_ui(self):
        # 创建主窗口的中心部件
        central_widget = QWidget()
        self.setCentralWidget(central_widget)

        # 创建主布局
        main_layout = QVBoxLayout(central_widget)

        # 创建堆叠窗口部件
        self.stacked_widget = QStackedWidget()

        # 创建三个页面
        self.create_page1()
        self.create_page2()
        self.create_page3()

        # 将堆叠窗口添加到主布局
        main_layout.addWidget(self.stacked_widget)

        # 创建导航按钮
        nav_layout = QHBoxLayout()

        prev_btn = QPushButton("上一页")
        prev_btn.clicked.connect(self.prev_page)
        nav_layout.addWidget(prev_btn)

        next_btn = QPushButton("下一页")
        next_btn.clicked.connect(self.next_page)
        nav_layout.addWidget(next_btn)

        main_layout.addLayout(nav_layout)

        # 添加状态标签
        self.status_label = QLabel("当前页面: 1/3")
        main_layout.addWidget(self.status_label)

    def create_page1(self):
        """创建第一个页面 - 信息页"""
        page1 = QWidget()
        layout = QVBoxLayout(page1)

        # 添加分组框
        group_box = QGroupBox("用户信息")
        group_layout = QVBoxLayout()

        # 添加输入框
        self.name_input = QLineEdit()
        self.name_input.setPlaceholderText("请输入您的姓名")
        group_layout.addWidget(self.name_input)

        # 添加按钮
        greet_btn = QPushButton("打招呼")
        greet_btn.clicked.connect(self.greet_user)
        group_layout.addWidget(greet_btn)

        # 添加结果标签
        self.greet_label = QLabel("")
        group_layout.addWidget(self.greet_label)

        group_box.setLayout(group_layout)
        layout.addWidget(group_box)
        layout.addStretch()

        self.stacked_widget.addWidget(page1)

    def create_page2(self):
        """创建第二个页面 - 列表页"""
        page2 = QWidget()
        layout = QVBoxLayout(page2)

        # 添加分组框
        group_box = QGroupBox("项目列表")
        group_layout = QVBoxLayout()

        # 添加列表控件
        self.list_widget = QListWidget()
        self.list_widget.addItems(["项目1", "项目2", "项目3", "项目4"])
        group_layout.addWidget(self.list_widget)

        # 添加按钮布局
        btn_layout = QHBoxLayout()

        add_btn = QPushButton("添加项目")
        add_btn.clicked.connect(self.add_item)
        btn_layout.addWidget(add_btn)

        remove_btn = QPushButton("删除项目")
        remove_btn.clicked.connect(self.remove_item)
        btn_layout.addWidget(remove_btn)

        group_layout.addLayout(btn_layout)
        group_box.setLayout(group_layout)
        layout.addWidget(group_box)
        layout.addStretch()

        self.stacked_widget.addWidget(page2)

    def create_page3(self):
        """创建第三个页面 - 编辑页"""
        page3 = QWidget()
        layout = QVBoxLayout(page3)

        # 添加分组框
        group_box = QGroupBox("文本编辑")
        group_layout = QVBoxLayout()

        # 添加文本编辑控件
        self.text_edit = QTextEdit()
        self.text_edit.setPlaceholderText("在此输入文本...")
        group_layout.addWidget(self.text_edit)

        # 添加按钮
        clear_btn = QPushButton("清空内容")
        clear_btn.clicked.connect(self.clear_text)
        group_layout.addWidget(clear_btn)

        group_box.setLayout(group_layout)
        layout.addWidget(group_box)
        layout.addStretch()

        self.stacked_widget.addWidget(page3)

    def greet_user(self):
        """打招呼按钮的槽函数"""
        name = self.name_input.text().strip()
        if name:
            self.greet_label.setText(f"你好, {name}!")
        else:
            self.greet_label.setText("请输入您的姓名")

    def add_item(self):
        """添加项目按钮的槽函数"""
        self.list_widget.addItem(f"项目{self.list_widget.count() + 1}")

    def remove_item(self):
        """删除项目按钮的槽函数"""
        current_row = self.list_widget.currentRow()
        if current_row >= 0:
            self.list_widget.takeItem(current_row)

    def clear_text(self):
        """清空文本按钮的槽函数"""
        self.text_edit.clear()

    def prev_page(self):
        """上一页按钮的槽函数"""
        current_index = self.stacked_widget.currentIndex()
        if current_index > 0:
            self.stacked_widget.setCurrentIndex(current_index - 1)
            self.update_status()

    def next_page(self):
        """下一页按钮的槽函数"""
        current_index = self.stacked_widget.currentIndex()
        if current_index < self.stacked_widget.count() - 1:
            self.stacked_widget.setCurrentIndex(current_index + 1)
            self.update_status()

    def update_status(self):
        """更新状态标签"""
        current_index = self.stacked_widget.currentIndex() + 1
        total_pages = self.stacked_widget.count()
        self.status_label.setText(f"当前页面: {current_index}/{total_pages}")


if __name__ == '__main__':
    app = QApplication(sys.argv)
    window = StackedWidgetExample()
    window.show()
    sys.exit(app.exec_())

QSplitters使用示例：

import sys
from PyQt5.QtWidgets import (QApplication, QMainWindow, QSplitter, QWidget, 
                             QVBoxLayout, QHBoxLayout, QLabel, QTextEdit, 
                             QListWidget, QTreeWidget, QTreeWidgetItem)

class SplitterExample(QMainWindow):
    def __init__(self):
        super().__init__()
        self.setWindowTitle('QSplitter 示例')
        self.setGeometry(100, 100, 800, 600)
        self.init_ui()
        
    def init_ui(self):
        # 创建主窗口的中心部件
        central_widget = QWidget()
        self.setCentralWidget(central_widget)
        
        # 创建主布局
        main_layout = QVBoxLayout(central_widget)
        
        # 创建水平分割器
        horizontal_splitter = QSplitter()
        horizontal_splitter.setOrientation(0)  # 0 表示水平方向
        
        # 创建左侧区域 - 文本编辑区
        left_widget = QWidget()
        left_layout = QVBoxLayout(left_widget)
        left_layout.addWidget(QLabel("文本编辑区"))
        self.text_edit = QTextEdit()
        self.text_edit.setPlaceholderText("在此输入文本...")
        left_layout.addWidget(self.text_edit)
        horizontal_splitter.addWidget(left_widget)
        
        # 创建垂直分割器（嵌套在水平分割器中）
        vertical_splitter = QSplitter()
        vertical_splitter.setOrientation(1)  # 1 表示垂直方向
        
        # 创建右上区域 - 列表区
        top_right_widget = QWidget()
        top_right_layout = QVBoxLayout(top_right_widget)
        top_right_layout.addWidget(QLabel("项目列表"))
        self.list_widget = QListWidget()
        self.list_widget.addItems(["项目1", "项目2", "项目3", "项目4"])
        top_right_layout.addWidget(self.list_widget)
        vertical_splitter.addWidget(top_right_widget)
        
        # 创建右下区域 - 树形结构区
        bottom_right_widget = QWidget()
        bottom_right_layout = QVBoxLayout(bottom_right_widget)
        bottom_right_layout.addWidget(QLabel("树形结构"))
        self.tree_widget = QTreeWidget()
        self.tree_widget.setHeaderLabels(["名称", "类型"])
        
        # 添加树形结构数据
        root = QTreeWidgetItem(self.tree_widget)
        root.setText(0, "根节点")
        
        child1 = QTreeWidgetItem(root)
        child1.setText(0, "子节点1")
        child1.setText(1, "文件夹")
        
        child2 = QTreeWidgetItem(root)
        child2.setText(0, "子节点2")
        child2.setText(1, "文件")
        
        self.tree_widget.expandAll()
        bottom_right_layout.addWidget(self.tree_widget)
        vertical_splitter.addWidget(bottom_right_widget)
        
        # 将垂直分割器添加到水平分割器
        horizontal_splitter.addWidget(vertical_splitter)
        
        # 设置初始比例
        horizontal_splitter.setSizes([300, 500])
        vertical_splitter.setSizes([200, 300])
        
        # 添加分割器到主布局
        main_layout.addWidget(horizontal_splitter)
        
        # 添加状态标签
        self.status_label = QLabel("拖动分隔条调整各区域大小")
        main_layout.addWidget(self.status_label)
        
        # 连接信号
        horizontal_splitter.splitterMoved.connect(self.update_status)
        vertical_splitter.splitterMoved.connect(self.update_status)
    
    def update_status(self, pos, index):
        """更新状态标签"""
        self.status_label.setText(f"当前分隔条位置: {pos}")


if __name__ == '__main__':
    app = QApplication(sys.argv)
    window = SplitterExample()
    window.show()
    sys.exit(app.exec_())

布局管理器

QFormLayout

用于构建图形用户界面（GUI）中表单的布局管理器。它可以在表单中自动地安排各种控件（例如文本框、复选框、下拉框等）的位置和大小，以便它们以最优化的方式显示在表单上。

简化表单的设计和排版工作，以及提高表单的可读性和易用性
根据表单中控件的类型和数量，自动地生成最佳的布局
提供了一些常用的功能，例如表单边距、控件间距、对齐方式、自动换行等

QGridLayout

用于将控件以网格的形式排列在窗口中。每个单元格可以包含一个控件，且所有单元格大小相等。控件可以跨越多个行和列，这是通过指定控件的位置以及它在行和列中所占的单元格数量来实现的。重要特点：

创建GridLayout对象：可以通过将QWidget作为参数传递给QGridLayout构造函数来创建一个GridLayout对象。然后可以使用addWidget()方法将控件添加到布局中
指定控件的位置：可以使用addWidget()方法的第二个和第三个参数来指定控件的位置。例如，addWidget(button, 0, 0)将button添加到第0行和第0列的单元格中
控件的大小和跨度：可以使用addWidget()方法的第四个和第五个参数来指定控件在行和列中所占的单元格数量。例如，addWidget(label, 0, 0, 1, 2)将label添加到第0行和第0列的单元格中，并让它跨越第0列和第1列的两个单元格
添加空白单元格：可以使用addSpacing()方法添加空白的单元格，从而调整控件之间的距离
对齐方式：可以使用setAlignment()方法设置控件在单元格中的对齐方式。可以指定水平和垂直方向的对齐方式，也可以将对齐方式设置为水平和垂直方向的组合
自动调整大小：可以使用setColumnStretch()和setRowStretch()方法来设置单元格的大小。可以使用addStretch()方法添加一个伸缩项，以便在窗口大小改变时自动调整大小

信号与槽以及关联控件

信号与槽的介绍

信号是用于在对象之间传递信息的一种机制。一个信号表示了一个事件或状态的变化，当这个事件或状态变化时，信号被发射（emit）。可以将信号连接到一个或多个槽函数中，当信号被发射时，连接的槽函数会被调用执行。槽函数则是用于接收和处理信号的函数。

常用**connect()**方法来将信号连接到槽函数中，该方法的基本语法为：

`1`	`sender.signal.connect(receiver.slot)`

sender表示发送信号的对象，signal表示信号的名称，connect()方法将信号signal连接到receiver对象的槽函数slot中。槽函数可以是任何可调用的Python函数

高级的信号与槽机制：

使用自定义信号：可以定义自己的信号，并将其连接到槽函数中。自定义信号可以通过QObject类的signal()方法定义，并使用emit()方法发射信号
使用Lambda表达式：可以使用Lambda表达式作为槽函数，Lambda表达式可以简洁地表示一个函数
使用信号参数：PyQt5中的信号可以带有参数，参数可以在信号发射时被传递给槽函数
一个信号连接多个槽函数：可以将一个信号连接到多个槽函数中，所有的槽函数都会在信号被发射时被调用执行

QPushButton

Qt中常用的按钮控件，可以用于在GUI中创建各种类型的按钮，如普通按钮、复选框按钮、单选框按钮等。

其构造函数为：

1
2
3

QPushButton(parent=None)            #创建一个无标签的按钮
QPushButton(str, parent=None)		#创建一个有标签的按钮
QPushButton(QIcon, str, parent=None)#创建一个既有图标又有标签的按钮

可以调用的方法有：

setText()方法设置按钮的文本标签
setIcon()方法设置按钮的图标
setEnabled()用于设置按钮是否可用
setFlat()用于设置按钮是否平面
setCheckable()用于设置按钮是否可选中等

还可以通过信号与槽机制来响应用户的点击事件。当用户单击按钮时，会发出clicked()信号，可以通过连接这个信号来执行特定的操作。

import sys
from PyQt5.QtWidgets import QApplication, QMainWindow, QPushButton, QLabel, QHBoxLayout, QVBoxLayout, QWidget
from PyQt5.QtGui import QIcon
from PyQt5.QtCore import Qt

class MyMainWindow(QMainWindow):
    def __init__(self):
        super().__init__()
        self.initUI()

    def initUI(self):
        self.setWindowTitle('QPushButton Demo')
        self.setGeometry(300, 300, 400, 300)

        # 创建一个QPushButton并设置文本标签和图标
        btn = QPushButton('Click me!', self)
        btn.setIcon(QIcon('icon.png'))

        # 连接按钮的clicked信号到槽函数onBtnClicked
        btn.clicked.connect(self.onBtnClicked)

        # 创建一个QLabel用于显示按钮状态
        self.label = QLabel('Button not clicked', self)

        # 创建水平布局和垂直布局，并将按钮和标签添加到布局中
        hbox = QHBoxLayout()
        hbox.addStretch(1)
        hbox.addWidget(btn)
        hbox.addStretch(1)

        vbox = QVBoxLayout()
        vbox.addStretch(1)
        vbox.addLayout(hbox)
        vbox.addStretch(1)
        vbox.addWidget(self.label, alignment=Qt.AlignCenter)

        # 创建一个QWidget，并将垂直布局添加到QWidget中
        widget = QWidget()
        widget.setLayout(vbox)
        self.setCentralWidget(widget)

    def onBtnClicked(self):
        self.label.setText('Button clicked')

if __name__ == '__main__':
    app = QApplication(sys.argv)
    win = MyMainWindow()
    win.show()
    sys.exit(app.exec_())

QRadioButton

一个单选按钮控件，可以用于从多个互斥的选项中选择一个选项。与QCheckBox不同，QRadioButton只允许选择一个选项。

基本属性和方法：

setText()设置按钮的文本
isChecked()检查按钮是否被选中
setChecked()设置按钮的选中状态
toggled()每当按钮的选中状态发生变化时，都会发出toggled()信号

import sys
from PyQt5.QtWidgets import QApplication, QMainWindow, QRadioButton


class MyMainWindow(QMainWindow):
    def __init__(self):
        super().__init__()
        self.initUI()

    def initUI(self):
        self.setWindowTitle('QRadioButton Demo')
        self.setGeometry(300, 300, 400, 300)

        # 创建两个单选框按钮
        rb1 = QRadioButton('Option 1', self)
        rb1.move(50, 50)
        rb1.setChecked(True)

        rb2 = QRadioButton('Option 2', self)
        rb2.move(50, 80)

        # 绑定toggled()信号
        rb1.toggled.connect(self.onToggled)
        rb2.toggled.connect(self.onToggled)

    def onToggled(self, checked):
        sender = self.sender()
        if checked:
            print(sender.text() + ' is checked')


if __name__ == '__main__':
    app = QApplication(sys.argv)
    win = MyMainWindow()
    win.show()
    sys.exit(app.exec_())

QcheckBox

一个复选框控件，可以用于从多个选项中选择一个或多个选项。与QRadioButton不同，QCheckBox允许选择多个选项。

基本属性和方法：

setText()：设置复选框的文本。
isChecked()：检查复选框是否被选中。
setChecked()：设置复选框的选中状态。
stateChanged()：每当复选框的选中状态发生变化时，都会发出stateChanged()信号

import sys
from PyQt5.QtWidgets import QApplication, QMainWindow, QCheckBox

class MyMainWindow(QMainWindow):
    def __init__(self):
        super().__init__()
        self.initUI()

    def initUI(self):
        self.setWindowTitle('QCheckBox Demo')
        self.setGeometry(300, 300, 400, 300)

        # 创建两个复选框
        cb1 = QCheckBox('Option 1', self)
        cb1.move(50, 50)

        cb2 = QCheckBox('Option 2', self)
        cb2.move(50, 80)

        # 绑定stateChanged()信号
        cb1.stateChanged.connect(self.onStateChanged)
        cb2.stateChanged.connect(self.onStateChanged)

    def onStateChanged(self, state):
        sender = self.sender()
        if state == 2:
            print(sender.text() + ' is checked')
        else:
            print(sender.text() + ' is unchecked')

if __name__ == '__main__':
    app = QApplication(sys.argv)
    win = MyMainWindow()
    win.show()
    sys.exit(app.exec_())

QComboBox

下拉列表控件，允许用户从预定义的一组选项中选择一个或多个选项。它通常用于表示枚举类型的值或选择一组预定义的选项。

基本属性和方法：

addItem()：添加一个项到下拉列表中。
addItems()：添加多个项到下拉列表中。
setCurrentIndex()：设置当前选中的项的索引。
currentText()：返回当前选中的项的文本。
currentIndexChanged()：每当当前选中的项发生变化时，都会发出currentIndexChanged()信号。

import sys
from PyQt5.QtWidgets import (QApplication, QMainWindow, QComboBox,
                             QPushButton, QVBoxLayout, QWidget, QLabel)


class ComboBoxDemo(QMainWindow):
    def __init__(self):
        super().__init__()
        self.setWindowTitle('QComboBox 演示')
        self.setGeometry(300, 300, 400, 300)
        self.initUI()

    def initUI(self):
        # 创建中心部件和布局
        central_widget = QWidget()
        self.setCentralWidget(central_widget)
        layout = QVBoxLayout(central_widget)

        # 创建标签显示当前选择
        self.status_label = QLabel("当前选择: 无")
        layout.addWidget(self.status_label)

        # 创建下拉列表并添加选项
        self.combo_box = QComboBox()
        self.combo_box.addItem('选项 1')
        self.combo_box.addItem('选项 2')
        self.combo_box.addItem('选项 3')
        self.combo_box.addItem('选项 4')
        self.combo_box.addItem('选项 5')

        # 绑定信号
        self.combo_box.currentIndexChanged.connect(self.on_index_changed)
        layout.addWidget(self.combo_box)

        # 创建按钮用于设置当前索引
        self.create_set_index_buttons(layout)

        # 添加随机选择按钮
        random_btn = QPushButton("随机选择")
        random_btn.clicked.connect(self.set_random_index)
        layout.addWidget(random_btn)

        # 添加重置按钮
        reset_btn = QPushButton("重置选择")
        reset_btn.clicked.connect(self.reset_selection)
        layout.addWidget(reset_btn)

        # 初始化状态
        self.update_status()

    def create_set_index_buttons(self, layout):
        """创建设置索引的按钮"""
        # 水平布局用于放置按钮
        button_layout = QVBoxLayout()

        # 为每个选项创建设置按钮
        for i in range(self.combo_box.count()):
            btn = QPushButton(f"设置为选项 {i + 1}")
            # 使用lambda函数传递索引值
            btn.clicked.connect(lambda checked, idx=i: self.set_current_index(idx))
            button_layout.addWidget(btn)

        layout.addLayout(button_layout)

    def set_current_index(self, index):
        """设置当前选中的索引"""
        self.combo_box.setCurrentIndex(index)

    def set_random_index(self):
        """随机选择一个索引"""
        import random
        count = self.combo_box.count()
        if count > 0:
            random_index = random.randint(0, count - 1)
            self.combo_box.setCurrentIndex(random_index)

    def reset_selection(self):
        """重置选择（设置为无选择）"""
        self.combo_box.setCurrentIndex(-1)

    def on_index_changed(self, index):
        """当下拉列表选择改变时调用"""
        self.update_status()

    def update_status(self):
        """更新状态标签"""
        index = self.combo_box.currentIndex()
        text = self.combo_box.currentText()

        if index == -1:
            self.status_label.setText("当前选择: 无")
        else:
            self.status_label.setText(f"当前选择: 选项 {index + 1} ({text})")


if __name__ == '__main__':
    app = QApplication(sys.argv)
    win = ComboBoxDemo()
    win.show()
    sys.exit(app.exec_())

独立组件

滑块控件

图形用户界面中常见的一种控件，也称为滑杆、拖动条、进度条等，用于调节数值类型的参数。用户通过拖动滑块的滑块块（Thumb）来改变滑块的值，滑块的范围和步长可以通过设置属性进行控制。在PyQt5中，QSlider是用于创建滑块控件的类。

常用的属性和方法：

value()：获取当前滑块的值。
setValue(value)：设置当前滑块的值。
minimum()：获取滑块的最小值。
setMinimum(value)：设置滑块的最小值。
maximum()：获取滑块的最大值。
setMaximum(value)：设置滑块的最大值。
singleStep()：获取滑块的步长。
setSingleStep(value)：设置滑块的步长。
sliderMoved.connect(slot)：将slot函数连接到滑块拖动事件。
valueChanged.connect(slot)：将slot函数连接到滑块值改变事件。在使用QS

import sys
from PyQt5.QtWidgets import QApplication, QWidget, QLabel, QSlider, QHBoxLayout, QVBoxLayout, QPushButton
from PyQt5.QtCore import Qt


class SliderDemo(QWidget):
    def __init__(self):
        super().__init__()
        self.initUI()

    def initUI(self):
        # 创建一个水平布局和垂直布局
        hlayout = QHBoxLayout()
        vlayout = QVBoxLayout()

        # 创建一个标签和滑块控件，并添加到水平布局中
        self.label = QLabel('Value: 0')
        self.slider = QSlider(Qt.Horizontal)
        self.slider.valueChanged[int].connect(self.onSliderValueChanged)
        hlayout.addWidget(self.label)
        hlayout.addWidget(self.slider)

        # 创建一个重置按钮，并添加到垂直布局中
        reset_btn = QPushButton('Reset')
        reset_btn.clicked.connect(self.onResetBtnClicked)
        vlayout.addLayout(hlayout)
        vlayout.addWidget(reset_btn)

        # 设置窗口的布局
        self.setLayout(vlayout)

        # 设置窗口的标题和大小
        self.setWindowTitle('Slider Demo')
        self.resize(300, 200)

    def onSliderValueChanged(self, value):
        # 当滑块的值改变时更新标签的文本
        self.label.setText(f'Value: {value}')

    def onResetBtnClicked(self):
        # 重置滑块的值为0，并更新标签的文本
        self.slider.setValue(0)
        self.label.setText('Value: 0')


if __name__ == '__main__':
    app = QApplication(sys.argv)
    demo = SliderDemo()
    demo.show()
    sys.exit(app.exec_())

树控件

一种常见的用户界面控件，它可以用来展示层次化的数据结构，例如文件系统、目录结构、组织结构等等。树控件通常由多个节点（Node）组成，每个节点都可以包含多个子节点。在PyQt5中，树控件是通过QTreeWidget类来实现的。

操作树控件方法：

添加节点：可以通过QTreeWidget.addTopLevelItem()方法或QTreeWidgetItem.addChild()方法来添加节点。
删除节点：可以通过QTreeWidget.takeTopLevelItem()方法或QTreeWidgetItem.removeChild()方法来删除节点。
获取节点：可以通过QTreeWidget.topLevelItem()方法或QTreeWidgetItem.child()方法来获取节点。
设置节点属性：可以通过QTreeWidgetItem.setText()、QTreeWidgetItem.setIcon()等方法来设置节点的文本、图标等属性。
选择节点：可以通过QTreeWidget.currentItem()方法获取当前选中的节点，也可以通过QTreeWidgetItem.setSelected


import sys
from PyQt5.QtWidgets import QApplication, QMainWindow, QTreeWidget, QTreeWidgetItem

class OrganizationChart(QMainWindow):
    def __init__(self):
        super().__init__()

        self.setWindowTitle("组织结构图")
        self.resize(500, 400)

        self.treeWidget = QTreeWidget()
        self.treeWidget.setHeaderLabels(["姓名", "职位", "部门"])

        self.populateTreeWidget()

        self.setCentralWidget(self.treeWidget)

    def populateTreeWidget(self):
        # 创建根节点
        root = QTreeWidgetItem(self.treeWidget, ["总经理", "总经理", ""])

        # 创建部门节点1
        department1 = QTreeWidgetItem(root, ["市场部", "部门经理", ""])
        employee1 = QTreeWidgetItem(department1, ["张三", "销售经理", "市场部"])
        employee2 = QTreeWidgetItem(department1, ["李四", "市场专员", "市场部"])

        # 创建部门节点2
        department2 = QTreeWidgetItem(root, ["技术部", "部门经理", ""])
        employee3 = QTreeWidgetItem(department2, ["王五", "技术总监", "技术部"])
        employee4 = QTreeWidgetItem(department2, ["赵六", "开发工程师", "技术部"])

        # 展开根节点
        self.treeWidget.expandItem(root)

if __name__ == "__main__":
    app = QApplication(sys.argv)

    organizationChart = OrganizationChart()
    organizationChart.show()

    sys.exit(app.exec_())

停靠控件

一种常用的界面布局控件，它允许用户在主窗口中创建可停靠的面板或工具栏，以便对应用程序进行灵活的布局和组织。停靠控件提供了一种便捷的方式来管理和切换应用程序的功能模块，使用户可以根据自己的需求动态调整界面布局。在 PyQt 中，停靠控件由QDockWidget类实现。它可以与 QMainWindow 或 QMainWindows 的派生类一起使用，使得应用程序的主窗口可以容纳多个停靠控件，并支持拖动、停靠和浮动等操作。

实现步骤：

创建停靠控件对象：使用 QDockWidget 类创建一个停靠控件对象，并将需要承载的内容设置为其子部件。
设置停靠属性：可以设置停靠控件的标题、图标、位置等属性，以及允许的停靠区域和停靠方式。
将停靠控件添加到主窗口：使用 QMainWindow 或 QMainWindows 的派生类将停靠控件添加到主窗口中的合适位置，通常使用 addDockWidget() 方法来完成。

import sys
from PyQt5.QtWidgets import QApplication, QMainWindow, QDockWidget, QTextEdit, QAction, QFileDialog, QMessageBox, QVBoxLayout, QWidget, QLabel, QPushButton, QTreeWidget, QTreeWidgetItem

class NotePad(QMainWindow):
    def __init__(self):
        super().__init__()

        self.initUI()

    def initUI(self):
        self.setWindowTitle("NotePad")
        self.setGeometry(100, 100, 800, 600)

        # 创建文本编辑区域
        self.textEdit = QTextEdit()
        self.setCentralWidget(self.textEdit)

        # 创建停靠控件
        dock = QDockWidget("File Actions", self)
        dock.setAllowedAreas(Qt.LeftDockWidgetArea)

        # 创建停靠控件中的内容，包括打开文件按钮和保存文件按钮
        openButton = QPushButton("Open File")
        openButton.clicked.connect(self.openFile)

        saveButton = QPushButton("Save File")
        saveButton.clicked.connect(self.saveFile)

        layout = QVBoxLayout()
        layout.addWidget(openButton)
        layout.addWidget(saveButton)

        widget = QWidget()
        widget.setLayout(layout)
        dock.setWidget(widget)

        # 将停靠控件添加到主窗口的左侧停靠区域
        self.addDockWidget(Qt.LeftDockWidgetArea, dock)

        # 创建菜单和动作
        self.createActions()
        self.createMenus()

        # 创建侧边栏
        self.createSidebar()

        self.show()

    def createActions(self):
        self.openAction = QAction("Open File", self)
        self.openAction.triggered.connect(self.openFile)

        self.saveAction = QAction("Save File", self)
        self.saveAction.triggered.connect(self.saveFile)

    def createMenus(self):
        self.fileMenu = self.menuBar().addMenu("File")
        self.fileMenu.addAction(self.openAction)
        self.fileMenu.addAction(self.saveAction)

    def createSidebar(self):
        # 创建侧边栏
        sidebarDock = QDockWidget("Notes", self)
        sidebarDock.setAllowedAreas(Qt.LeftDockWidgetArea)

        # 创建树控件
        treeWidget = QTreeWidget()
        treeWidget.setHeaderLabels(["Notes"])

        # 添加示例笔记
        root = QTreeWidgetItem(treeWidget)
        root.setText(0, "Notebook")

        note1 = QTreeWidgetItem(root)
        note1.setText(0, "Note 1")

        note2 = QTreeWidgetItem(root)
        note2.setText(0, "Note 2")

        # 将树控件添加到侧边栏
        sidebarDock.setWidget(treeWidget)
        self.addDockWidget(Qt.LeftDockWidgetArea, sidebarDock)

    def openFile(self):
        fileName, _ = QFileDialog.getOpenFileName(self, "Open File")
        if fileName:
            try:
                with open(fileName, 'r') as file:
                    content = file.read()
                self.textEdit.setPlainText(content)
            except Exception as e:
                QMessageBox.critical(self, "Error", str(e))

    def saveFile(self):
        fileName, _ = QFileDialog.getSaveFileName(self, "Save File")
        if fileName:
            try:
                with open(fileName, 'w') as file:
                    content = self.textEdit.toPlainText()
                    file.write(content)
                QMessageBox.information(self, "Success", "File saved successfully.")
            except Exception as e:
                QMessageBox.critical(self, "Error", str(e))

if __name__ == '__main__':
    app = QApplication(sys.argv)
    notepad = NotePad()
    sys.exit(app.exec_())

国家大学生就业服务平台岗位爬取

Wed, 20 Aug 2025 17:47:51 +0800

获取Cookie

起初在进入到岗位页面时，发现无需登录也能访问岗位列表，因此打算直接从网络中找到返回工作列表的请求，通过侧边栏搜索相关字段，定位请求位置:

获取其中的请求URL和Cookie等参数，构造请求头并发起请求。在此过程中发现请求URL中最后一段数字是在不断变化的：

查询网页内部的js文件发现，该串数字和时间有关，因此大胆猜测这段数字可能是时间戳，采用代码测试：

import time
def generate_timestamp():
    """生成13位时间戳"""
    return str(int(time.time() * 1000))
print(generate_timestamp())
#output->1755764369564

代码测试结果与URL的末端数字相似，因此得证。但在爬取的过程中，发现在未登录状态下只能浏览前10页内容。因此需要解决登录问题，找到相关请求：

根据相关字段向该URL提交表单并获取登录后的Cookie，但用Python获取Cookie后发现依旧无法获取，返回的结果：

一开始我怀疑是获取的Cookie有问题，因此使用代码分析直接从网页上获取的Cookie的变化，试图找到规律：

from difflib import  SequenceMatcher
#将Cookie进行切割
def Cookie_split(Cookie):
    fragments = Cookie.split("; ")
    dic = {}
    for fragment in fragments:
        key,value = fragment.split('=',1)
        dic[key] = value
    return dic


def compare_strings(str1,str2):
    matcher = SequenceMatcher(None,str1,str2)
    for op , i1 , i2 ,j1 ,j2 in matcher.get_opcodes():
        if op == 'replace':
            print(f"在位置{i1}替换了“{str1[i1:i2]}”为“{str2[j1:j2]}”")
        elif op == 'delete':
            print(f"在位置{i1}删除了“{str1[i1:i2]}”")
        elif op == 'insert':
            print(f"在位置{i1}插入了“{str1[i1:i2]}”")

#Cookie比较
def Cookie_compare(Cookie1,Cookie2):
    """比较两个Cookie的差别"""
    cookie_dic1 = Cookie_split(Cookie1)
    cookie_dic2 = Cookie_split(Cookie2)

    key_list1 = cookie_dic1.keys()
    key_list2 = cookie_dic2.keys()
    print(key_list1)
    print(key_list2)

    # Cookie中属性的比较
    diff = list(set(key_list1) ^ set(key_list2))
    if diff == []:
        print("两个Cookie在属性上一致")
        for key in key_list1:
            print(f"|--------------------------{key}的差异点-------------------------|")
            compare_strings(cookie_dic1[key],cookie_dic2[key])
            print(f"|--------------------------------------------------------------|")

    else:
        print(f"两个Cookie的属性差异：{diff}")
        same_attribute = list(set(key_list1) & set(key_list2))
        for key in same_attribute:
            print(f"|--------------------------{key}的差异点-------------------------|")
            compare_strings(cookie_dic1[key],cookie_dic2[key])
            print(f"|--------------------------------------------------------------|")


if __name__ == "__main__":
    Cookie_compare(Cookie6,Cookie7)

在比较的过程中发现，当网页保持登录状态时，从网页获取的Cookie可以正常使用，而当关闭网页后，之前获取的Cookie就失效了，因此怀疑整个流程如图：

所以如果要保持Cookie的有效性，就必须保持登录状态。因此考虑使用Selenium进行模拟登录，再从其中获取组成Cookie所需的相关字段。事实上，能直接获取的字段并不全，因此通过上面的比较代码，找到Cookie中的不变（有时不变）部分和变动（每次登录都会改变）部分，幸运的是变动部分都能在直接获取的字段中找到。

def keep_connect(chrome_location,username,password):
    """使用selenium模拟登录，获取Cookie，并维持登录状态防止服务器端将Cookie注销"""
    options = webdriver.ChromeOptions()
    options.binary_location = chrome_location
    options.add_argument("ignore-certificate-errors")
    options.add_experimental_option("detach", True)
    driver = webdriver.Chrome(options=options, executable_path='../chromedriver.exe')

    login_url = 'https://account.chsi.com.cn/passport/login?service=https://www.ncss.cn/student/connect/chsi&entrytype=stu'
    driver.get(login_url)
    time.sleep(1)

    acc_input = driver.find_element(By.XPATH, r'/html/body/div/div[2]/div[2]/div/div[2]/form/div[1]/input')
    acc_input.send_keys(username)

    pwd_input = driver.find_element(By.XPATH, f'/html/body/div/div[2]/div[2]/div/div[2]/form/div[2]/input')
    pwd_input.send_keys(password)
    driver.find_element(By.XPATH, r'/html/body/div/div[2]/div[2]/div/div[2]/form/div[4]').click()

    element = WebDriverWait(driver, 10).until(EC.element_to_be_clickable((By.XPATH, r"/html/body/div/span/span/a[1]")))
    element.click()

    dic = {}

    for i in driver.get_cookies():
        dic[i['name']] = i['value']

    return dic


def Cookie_concat(got_property):
    """将从keep_connect函数中获取到的Cookie数据进行重新包装"""
    changed_property_list = ['SESSION', 'Hm_lpvt_378ff17a1ac046691cf78376632d1ed4', '_ga','_ga_6CXWRD3K0D']

    no_change = {
        '_ga_1ESVLDHDYL': 'GS1.1.1726503021.3.0.1726503021.0.0.0',
        '_abfpc': 'd7760a7e8d00953eaa18b111273b00d6ad83f1cc_2.0',
        'cna': 'eac1e178d67b00529df2b287b5842f2c',
        '_gid': 'GA1.2.673435621.1755336171',
        'aliyungf_tc': 'bfc4565f794c9e6ac253a5c09f4a937f2afb69e01fc7b413d486aaeaadf06249',
        'XSRF-CCKTOKEN': 'a12b3436b08549ba2f33a4aefa9a1454',
        'CHSICC_CLIENTFLAGNCSS': 'aba5b818eaa8bc94d6fb1ddf17d1df4f',
        'CHSICC01': '!DzrVNB/pHD1H78bzYxYLahOzddj6Y4XQ6NJ5RnOPIOyzHzKixC+5X5WINIjztT+S4x5PGaf/cowaI/Q=',
        'CHSICC_CLIENTFLAGSTUDENT': '5d0ab9cce044f18a699886e7d6705555',
        'Hm_lvt_378ff17a1ac046691cf78376632d1ed4': '1754926580,1754968150,1755336169,1755411478',
        'HMACCOUNT': 'CEB955474E107530',
        'acw_tc': 'ac11000117554230396983911ee7b259a823321b52a20a878c0b42ee677273',
        '_gat_gtag_UA_105074615_1': '1'
    }

    property_all = no_change.copy()

    for i in changed_property_list:
        property_all[i] = got_property[i]
    property_rank = ['SESSION','_ga_1ESVLDHDYL','_abfpc','cna','_gid','aliyungf_tc','acw_tc','XSRF-CCKTOKEN','CHSICC_CLIENTFLAGNCSS','CHSICC01','CHSICC_CLIENTFLAGSTUDENT','Hm_lvt_378ff17a1ac046691cf78376632d1ed4','HMACCOUNT','_gat_gtag_UA_105074615_1','Hm_lpvt_378ff17a1ac046691cf78376632d1ed4','_ga','_ga_6CXWRD3K0D']

    Cookie=''

    for i in property_rank:
        Cookie = Cookie + i + '=' + property_all[i] + '; '
    print('完成Cookie创建')

    return Cookie


def simulate_login_get_cookie(chrome_location,username,password):
    """将模拟登录部分和包装Cookie部分整合在一起"""
    dic = keep_connect(chrome_location=chrome_location,username=username,password=password)
    return Cookie_concat(dic)

获取数据

数据分为两类，一类是岗位列表数据，另一类是岗位详情页数据。

岗位列表数据

岗位列表数据即如图所示：

该类数据可以直接从返回的响应中的"data"–>“list"中找到，相关代码为：

def get_job_data(http,Cookie,page=1,page_size=10):
    """获取岗位数据"""
    baseurl = "https://www.ncss.cn/student/jobs/jobslist/ajax/"
    #构造请求头
    headers = {
        'User-Agent':ua.random,
        'Connection':'keep-alive',
        'Cookie':Cookie,
        "Accept": "application/json,*/*",
        'Referer':"https://account.chsi.com.cn/passport/login?service=https://job.ncss.cn/student/connect/chsi&entrytype=stu"
    }
    
    # 查询参数
    params = {
        "jobType": "",
        "areaCode": "",
        "jobName": "",
        "monthPay": "",
        "industrySectors": "",
        "property": "",
        "categoryCode": "",
        "memberLevel": "",
        "recruitType": "",
        "offset": page,
        "limit": page_size,
        "keyUnits": "",
        "degreeCode": "",
        "sourcesName": "0",
        "sourcesType": "",
        "_": generate_timestamp()  # 动态时间戳
    }

    try:
        resp = http.request(
            method='GET',
            url=baseurl,
            fields=params,
            headers=headers
        )
        if resp.status in [403,401]:
            print(f"请求第{page}页时登录过期")
            return None
        elif resp.status == 200:
            data = json.loads(resp.data.decode('UTF-8'))
            return data['data']['list']
        else:
            print(f"请求第{page}页时错误，状态码{resp.status}")
            return None

    except Exception as e:
        print(f"请求第{page}页时发生错误:{e}")
        return None

详情页数据

详情页数据主要为详情页中的岗位介绍部分：

该部分主要是使用BeautifulSoup对返回的结果进行解析，找到相关属性内容的位置并进行解析，代码如下：

def fetch_detail_page(job_id,http,Cookie):
    """获取详情页数据"""

    headers = {
        'User-Agent':ua.random,
        'Cookie':Cookie,
        'Referer':'https://job.ncss.cn/student/jobs/index.html'
    }

    detail_url = f"https://www.ncss.cn/student/jobs/{job_id}/detail.html"
    try:
        resp = http.request(
            'GET',
            detail_url,
            headers = headers
        )
        if resp.status == 200:
            return resp.data.decode('utf-8')
        elif resp.status in [401,403]:
            print(f"获取{job_id}详情页时登录过期")
            return None
        else:
            print(f"请求失败，状态码{resp.status}")
            return None
    except Exception as e:
        print(f"请求失败，{str(e)}")
        return None



def pares_detail_job_info(html,job_info):
    """将爬取到的详情页进行解析，获取“岗位介绍”部分的数据"""
    soup = BeautifulSoup(html,'html.parser')

    job_detail_describe_div =soup.find(name='pre',attrs={'class':"mainContent mainContent"})
    job_detail_describe = job_detail_describe_div.getText()

    job_info.update({
        "岗位介绍":job_detail_describe
    })

    return job_info

效率与反爬

考虑到爬取的数据量稍多，因此使用Urllib3进行分布式爬取，一个主进程，两个工作线程（岗位列表和详情页），采用消费者-生产者模型，同时使用fake_useragent模块不断改变User-Agent的值，代码如下：

def process_manager(total_pages,http,Cookie,num_list_workers=2,num_detail_workers=8,output_address=""):
    """进程管理器（主进程）"""
    global  enqueued_jobs_count
    start_time = time.time()
    print(f"开始爬取任务，总页数: {total_pages}")

    #创建Manager
    with Manager() as manager:
        #创建队列
        list_page_queue = manager.Queue()
        detail_task_queue = manager.Queue(maxsize=5000)
        result_queue = manager.Queue()

        #添加列表页任务
        for page in range(1,total_pages+1):
            list_page_queue.put(page)

        expected_total_list_pages = total_pages
        expected_total_detail_jobs = total_pages * 10

        #进度条
        list_pbar = tqdm(total=expected_total_list_pages,desc='列表页',unit='页',dynamic_ncols=True,file=sys.stdout)
        detail_pbar = tqdm(total=expected_total_detail_jobs,desc='详情页',unit='项',dynamic_ncols=True,file=sys.stdout)

        #创建并启动线程
        threads = []

        #列表页工作线程
        for i in range(num_list_workers):
            t = threading.Thread(
                target=list_page_worker,
                args=(list_page_queue,http,Cookie,detail_task_queue,list_pbar),
                name=f"ListWorker-{i+1}",
                daemon=True
            )
            t.start()
            threads.append(t)

        #详情页工作线程
        for i in range(num_detail_workers):
            t = threading.Thread(
                target=detail_page_worker,
                args=(detail_task_queue,result_queue,http,Cookie,detail_pbar),
                name=f"DetailWorker-{i+1}",
                daemon=True
            )
            t.start()
            threads.append(t)

        #结果写入线程
        writer_thread = threading.Thread(
            target=result_writer,
            args=(result_queue,output_address),
            name="ResultWriter",
            daemon=True
        )
        writer_thread.start()

        #等待列表页队列为空（等待完成列表页任务）
        list_page_queue.join()

        #通知列表页任务线程退出
        for _ in range(num_list_workers):
            list_page_queue.put(None)
        print(f"所有列表页任务已完成,{num_list_workers}个工作线程已退出")


        #调整详情任务总数
        with progress_lock:
            actual_enqueued = enqueued_jobs_count
        if actual_enqueued > 0 and actual_enqueued < detail_pbar.total:
            detail_pbar.total = actual_enqueued
            detail_pbar.refresh()


        #等待详情页任务队列为空（详情页任务完成）
        detail_task_queue.join()

        #通知详情页工作线程退出
        for _ in range(num_detail_workers):
            detail_task_queue.put(None)
        print(f"所有详情页任务已完成,{num_detail_workers}个工作线程已退出")


        #通知结果写入线程退出
        result_queue.put(None)

        for t in threads:
            t.join(timeout=10)

        writer_thread.join(timeout=10)

        elapsed_time = time.time() - start_time

        list_pbar.close()
        detail_pbar.close()

        print(f"爬取完成! 总耗时: {elapsed_time:.2f} 秒")

项目流程图

完整代码

import queue
import random
import threading
import time
from multiprocessing import Manager
from bs4 import BeautifulSoup
import urllib3
import json
from tqdm.auto import tqdm
import sys
from  fake_useragent import UserAgent
from selenium import  webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver.support.ui import WebDriverWait


#抑制认证警告
urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)


def keep_connect(chrome_location,username,password):
    """使用selenium模拟登录，获取Cookie，并维持登录状态防止服务器端将Cookie注销"""
    options = webdriver.ChromeOptions()
    options.binary_location = chrome_location
    options.add_argument("ignore-certificate-errors")
    options.add_argument("--headless")
    options.add_argument("--disable-gpu")
    options.add_argument("--disable-software-rasterizer")
    options.add_experimental_option("detach", True)
    driver = webdriver.Chrome(options=options,executable_path='../chromedriver.exe')

    login_url = 'https://account.chsi.com.cn/passport/login?service=https://www.ncss.cn/student/connect/chsi&entrytype=stu'
    driver.get(login_url)
    time.sleep(1)

    acc_input = driver.find_element(By.XPATH, r'/html/body/div/div[2]/div[2]/div/div[2]/form/div[1]/input')
    acc_input.send_keys(username)

    pwd_input = driver.find_element(By.XPATH, f'/html/body/div/div[2]/div[2]/div/div[2]/form/div[2]/input')
    pwd_input.send_keys(password)
    driver.find_element(By.XPATH, r'/html/body/div/div[2]/div[2]/div/div[2]/form/div[4]').click()

    element = WebDriverWait(driver, 10).until(EC.element_to_be_clickable((By.XPATH, r"/html/body/div/span/span/a[1]")))
    element.click()

    dic = {}

    for i in driver.get_cookies():
        dic[i['name']] = i['value']

    return dic


def Cookie_concat(got_property):
    """将从keep_connect函数中获取到的Cookie数据进行重新包装"""
    changed_property_list = ['SESSION', 'Hm_lpvt_378ff17a1ac046691cf78376632d1ed4', '_ga','_ga_6CXWRD3K0D']

    no_change = {
        '_ga_1ESVLDHDYL': 'GS1.1.1726503021.3.0.1726503021.0.0.0',
        '_abfpc': 'd7760a7e8d00953eaa18b111273b00d6ad83f1cc_2.0',
        'cna': 'eac1e178d67b00529df2b287b5842f2c',
        '_gid': 'GA1.2.673435621.1755336171',
        'aliyungf_tc': 'bfc4565f794c9e6ac253a5c09f4a937f2afb69e01fc7b413d486aaeaadf06249',
        'XSRF-CCKTOKEN': 'a12b3436b08549ba2f33a4aefa9a1454',
        'CHSICC_CLIENTFLAGNCSS': 'aba5b818eaa8bc94d6fb1ddf17d1df4f',
        'CHSICC01': '!DzrVNB/pHD1H78bzYxYLahOzddj6Y4XQ6NJ5RnOPIOyzHzKixC+5X5WINIjztT+S4x5PGaf/cowaI/Q=',
        'CHSICC_CLIENTFLAGSTUDENT': '5d0ab9cce044f18a699886e7d6705555',
        'Hm_lvt_378ff17a1ac046691cf78376632d1ed4': '1754926580,1754968150,1755336169,1755411478',
        'HMACCOUNT': 'CEB955474E107530',
        'acw_tc': 'ac11000117554230396983911ee7b259a823321b52a20a878c0b42ee677273',
        '_gat_gtag_UA_105074615_1': '1'
    }

    property_all = no_change.copy()

    for i in changed_property_list:
        property_all[i] = got_property[i]
    property_rank = ['SESSION','_ga_1ESVLDHDYL','_abfpc','cna','_gid','aliyungf_tc','acw_tc','XSRF-CCKTOKEN','CHSICC_CLIENTFLAGNCSS','CHSICC01','CHSICC_CLIENTFLAGSTUDENT','Hm_lvt_378ff17a1ac046691cf78376632d1ed4','HMACCOUNT','_gat_gtag_UA_105074615_1','Hm_lpvt_378ff17a1ac046691cf78376632d1ed4','_ga','_ga_6CXWRD3K0D']

    Cookie=''

    for i in property_rank:
        Cookie = Cookie + i + '=' + property_all[i] + '; '
    print("------------------完成Cookie创建------------------")

    return Cookie


def simulate_login_get_cookie(chrome_location,username,password):
    """将模拟登录部分和包装Cookie部分整合在一起"""
    dic = keep_connect(chrome_location=chrome_location,username=username,password=password)
    return Cookie_concat(dic)


ua = UserAgent()


def generate_timestamp():
    """生成13位时间戳"""
    return str(int(time.time() * 1000))



def get_job_data(http,Cookie,page=1,page_size=10):
    """获取岗位数据"""
    baseurl = "https://www.ncss.cn/student/jobs/jobslist/ajax/"
    #构造请求头
    headers = {
        'User-Agent':ua.random,
        'Connection':'keep-alive',
        'Cookie':Cookie,
        "Accept": "application/json,*/*",
        'Referer':"https://account.chsi.com.cn/passport/login?service=https://job.ncss.cn/student/connect/chsi&entrytype=stu"
    }
    
    # 查询参数
    params = {
        "jobType": "",
        "areaCode": "",
        "jobName": "",
        "monthPay": "",
        "industrySectors": "",
        "property": "",
        "categoryCode": "",
        "memberLevel": "",
        "recruitType": "",
        "offset": page,
        "limit": page_size,
        "keyUnits": "",
        "degreeCode": "",
        "sourcesName": "0",
        "sourcesType": "",
        "_": generate_timestamp()  # 动态时间戳
    }

    try:
        resp = http.request(
            method='GET',
            url=baseurl,
            fields=params,
            headers=headers
        )
        if resp.status in [403,401]:
            tqdm.write(f"请求第{page}页时登录过期")
            return None
        elif resp.status == 200:
            data = json.loads(resp.data.decode('UTF-8'))
            return data['data']['list']
        else:
            tqdm.write(f"请求第{page}页时错误，状态码{resp.status}")
            return None

    except Exception as e:
        tqdm.write(f"请求第{page}页时发生错误:{e}")
        return None




def fetch_detail_page(job_id,http,Cookie):
    """获取详情页数据"""

    headers = {
        'User-Agent':ua.random,
        'Cookie':Cookie,
        'Referer':'https://job.ncss.cn/student/jobs/index.html'
    }

    detail_url = f"https://www.ncss.cn/student/jobs/{job_id}/detail.html"
    try:
        resp = http.request(
            'GET',
            detail_url,
            headers = headers
        )
        if resp.status == 200:
            return resp.data.decode('utf-8')
        elif resp.status in [401,403]:
            tqdm.write(f"获取{job_id}详情页时登录过期")
            return None
        else:
            tqdm.write(f"请求失败，状态码{resp.status}")
            return None
    except Exception as e:
        tqdm.write(f"请求失败，{str(e)}")
        return None



def pares_detail_job_info(html,job_info):
    """将爬取到的详情页进行解析，获取“岗位介绍”部分的数据"""
    soup = BeautifulSoup(html,'html.parser')

    job_detail_describe_div =soup.find(name='div',attrs={'class':"details"})
    if job_detail_describe_div is not None:
        job_detail_describe = job_detail_describe_div.getText()
    else:
        tqdm.write(f"未找到岗位描述元素，岗位ID:{job_info.get('岗位ID')}")
        job_detail_describe = "未知"

    job_info.update({
        "岗位介绍":job_detail_describe
    })

    return job_info



def parse_job_info(job):
    """解析岗位信息"""
    id = job.get("jobId")
    timeStamp = job.get("updateDate")
    timeArray = time.localtime(float(timeStamp)/1000)

    return {
        "岗位ID":id,
       "职位名称":job.get("jobName"),
        "薪资水平":str(job.get("lowMonthPay"))+'k-'+str(job.get('highMonthPay'))+'k',
        "招聘人数":job.get("headCount"),
        "学历要求":job.get("degreeName"),
        "招聘方":job.get("recName"),
        "公司规模":job.get("recScale"),
        "地区":job.get("areaCodeName"),
        "福利":job.get("recTags"),
        "专业要求":job.get("major"),
        "岗位更新时间":time.strftime("%Y-%m-%d %H:%M:%S",timeArray),
        "详情网址":f"https://www.ncss.cn/student/jobs/{id}/detail.html"
    }





def list_page_worker(list_page_queue, http, Cookie, detail_task_queue, list_pbar):
    """获取岗位列表的工作流程"""
    global list_get_wrong, list_pages_done, enqueued_jobs_count

    while True:
        page = None
        try:
            page = list_page_queue.get(timeout=30)

            if page is None:
                list_page_queue.task_done()   # 对应主线程 put(None)
                break

            # 爬取列表页
            jobs = get_job_data(http=http, Cookie=Cookie, page=page, page_size=10)
            if jobs:
                for job in jobs:
                    job_info = parse_job_info(job)
                    detail_task_queue.put(job_info)
                    with progress_lock:
                        enqueued_jobs_count += 1
            time.sleep(random.uniform(0.5, 1.5))

        except queue.Empty:
            thread_name = threading.current_thread().name
            tqdm.write(f"列表页任务队列空，线程 {thread_name} 准备退出")
            continue

        except Exception as e:
            tqdm.write(f"列表页工作线程异常: {str(e)}")
            if page:
                list_get_wrong.append(page)
            time.sleep(5)

        finally:
            if page is not None:  # 只在真实任务时更新
                list_pages_done += 1
                list_pbar.update(1)
                list_page_queue.task_done()




def detail_page_worker(detail_task_queue,result_queue,http,Cookie,detail_pbar):
    """详情页工作流程"""

    global detail_get_wrong,detail_jobs_done

    while True:
        job_info = None
        job_id =None
        try:
            job_info = detail_task_queue.get(timeout=30)

            if job_info is None:
                detail_task_queue.task_done()
                break

            job_id = job_info.get("岗位ID")

            # print(f"开始爬取详情页{job_id}")

            html = fetch_detail_page(job_id, http, Cookie)

            if html:
                new_job_info = pares_detail_job_info(html, job_info)
                result_queue.put(new_job_info)
            # print(f"详情页{job_id}解析完成")
            else:
                tqdm.write(f"详情页{job_id}爬取失败")

            time.sleep(random.uniform(0.3, 0.8))

        except queue.Empty:
            thread_name = threading.current_thread().name
            tqdm.write(f"详情页任务队列空，线程{thread_name}准备退出")
            continue

        except Exception as e:
            tqdm.write(f"详情页工作线程异常: {str(e)}")
            if job_id:
                detail_get_wrong.append(job_id)
            time.sleep(3)
        finally:
            if job_info is not None:
                detail_jobs_done += 1
                detail_pbar.update(1)
                detail_task_queue.task_done()


def result_writer(result_queue, output_address):
    """结果写入线程"""
    struc_time = time.localtime()
    time_year = struc_time.tm_year
    time_month = struc_time.tm_mon
    time_day = struc_time.tm_mday

    output_file = output_address + f'{time_year}_{time_month}_{time_day}_jobs'

    count = 0
    with open(output_file, "a", encoding='utf-8', newline='') as f:
        while True:
            try:
                # 获取结果
                result = result_queue.get(timeout=120)
                if result is None:
                    break

                f.write(json.dumps(result, ensure_ascii=False) + "\n")
                f.flush()

                count += 1

                if count % 100 == 0:
                    tqdm.write(f"已写入 {count} 条结果")

                result_queue.task_done()
            except queue.Empty:
                tqdm.write("结果写入线程超时退出")
                break
            except Exception as e:
                tqdm.write(f"结果写入异常: {str(e)}")

    tqdm.write(f"结果写入完成，共写入 {count} 条数据")



def process_manager(total_pages,http,Cookie,num_list_workers=2,num_detail_workers=8,output_address=""):
    """进程管理器（主进程）"""
    global  enqueued_jobs_count
    start_time = time.time()
    tqdm.write(f"开始爬取任务，总页数: {total_pages}")

    #创建Manager
    with (Manager() as manager):
        #创建队列
        list_page_queue = manager.Queue()
        detail_task_queue = manager.Queue(maxsize=5000)
        result_queue = manager.Queue()

        #添加列表页任务
        for page in range(1,total_pages+1):
            list_page_queue.put(page)

        expected_total_list_pages = total_pages
        expected_total_detail_jobs = total_pages * 10

        #进度条
        list_pbar = tqdm(total=expected_total_list_pages,desc='列表页',unit='页',dynamic_ncols=True,file=sys.stdout)
        detail_pbar = tqdm(total=expected_total_detail_jobs,desc='详情页',unit='项',dynamic_ncols=True,file=sys.stdout)

        #创建并启动线程
        threads = []

        #列表页工作线程
        for i in range(num_list_workers):
            t = threading.Thread(
                target=list_page_worker,
                args=(list_page_queue,http,Cookie,detail_task_queue,list_pbar),
                name=f"ListWorker-{i+1}",
                daemon=True
            )
            t.start()
            threads.append(t)

        #详情页工作线程
        for i in range(num_detail_workers):
            t = threading.Thread(
                target=detail_page_worker,
                args=(detail_task_queue,result_queue,http,Cookie,detail_pbar),
                name=f"DetailWorker-{i+1}",
                daemon=True
            )
            t.start()
            threads.append(t)

        #结果写入线程
        writer_thread = threading.Thread(
            target=result_writer,
            args=(result_queue,output_address),
            name="ResultWriter",
            daemon=True
        )
        writer_thread.start()

        #等待列表页队列为空（等待完成列表页任务）
        list_page_queue.join()

        #通知列表页任务线程退出
        for _ in range(num_list_workers):
            list_page_queue.put(None)
        tqdm.write(f"所有列表页任务已完成,{num_list_workers}个工作线程已退出")


        #调整详情任务总数
        with progress_lock:
            actual_enqueued = enqueued_jobs_count
        if actual_enqueued > 0 and actual_enqueued < detail_pbar.total:
            detail_pbar.total = actual_enqueued
            detail_pbar.refresh()


        #等待详情页任务队列为空（详情页任务完成）
        detail_task_queue.join()

        #通知详情页工作线程退出
        for _ in range(num_detail_workers):
            detail_task_queue.put(None)
        tqdm.write(f"所有详情页任务已完成,{num_detail_workers}个工作线程已退出")


        #通知结果写入线程退出
        result_queue.put(None)

        for t in threads:
            t.join(timeout=10)

        writer_thread.join(timeout=10)

        elapsed_time = time.time() - start_time

        list_pbar.close()
        detail_pbar.close()

        print(f"爬取完成! 总耗时: {elapsed_time:.2f} 秒")


if __name__ == "__main__":
    #全局变量
    progress_lock = threading.Lock()
    list_pages_done = 0
    detail_jobs_done =0
    enqueued_jobs_count = 0
    # 配置爬取参数
    TOTAL_PAGES = 200  # 要爬取的列表页总数
    NUM_LIST_WORKERS = 2  # 列表页工作线程数
    NUM_DETAIL_WORKERS = 5  # 详情页工作线程数
    OUTPUT_ADDRESS = ""  # 输出文件的地址，默认为项目地址
    #配置模拟登录参数
    chrome_location = r'D:\python_project\Google\Chrome\Application\chrome.exe' #chrome启动器的位置
    username = "" #模拟登录的账号
    password = ""#模拟登陆的密码

    detail_get_wrong = [] #获取详情失败的job_id
    list_get_wrong = [] #获取岗位失败的页码


    #构建连接池
    print("------------------开始构建连接池------------------")
    http = urllib3.PoolManager(
        num_pools=50,
        maxsize=50,
        cert_reqs='CERT_NONE',
        assert_hostname=False,
        block=True,
        timeout=urllib3.Timeout(connect=5.0, read=10.0),
        retries=urllib3.Retry(total=3, backoff_factor=0.5),
    )
    print("------------------完成构建连接池------------------")

    #模拟登录，维持登录状态，获取组成Cookie的必要的参数
    print("-------------------开始模拟登录-------------------")
    Cookie = simulate_login_get_cookie(chrome_location=chrome_location,username=username,password=password)
    print("-------------------完成模拟登录-------------------")

    # 启动爬虫
    print("-------------------开始网络爬取-------------------")
    process_manager(
        total_pages=TOTAL_PAGES,
        num_list_workers=NUM_LIST_WORKERS,
        num_detail_workers=NUM_DETAIL_WORKERS,
        output_address=OUTPUT_ADDRESS,
        http = http,
        Cookie = Cookie
    )
    print("-------------------完成网络爬取-------------------")

问题 OR 改进

当前的爬取仍需要登录才能获取，如何才能以非登录状态获取所需的数据
可以增加代理，从而不断变动IP使得不易被锁IP

Urllib3

Tue, 05 Aug 2025 12:10:50 +0800

Urllib3

特点：

连接池管理：在客户端和服务器之间复用已有连接，避免每次请求都重新建立新连接，核心是PoolManager,内部维护一个或多个ConnectionPool；
线程安全：适合在多线程环境下进行并发请求；
重试机制：请求失败自动重试；
SSL/TLS验证：建立 HTTPS 连接时，客户端校验服务器提供的数字证书是否可信，并通过 TLS 协议完成数据加密通道的协商；
代理支持：在客户端（你）访问目标网站时，通过一个中间服务器（代理服务器）中转请求和响应，而不是直接访问目标网站；
文件上传：支持 multipart 文件上传；
编码处理：自动处理响应内容的编码问题；

核心类与方法：

PoolManager：最核心类，负责管理连接池和所有请求。

http = urllib3.PoolManager(
	num_pools = 50,          #连接池数量
    maxsize = 10,            #每个连接池最大连接数
    block = True,            #连接池满时是否阻塞等待
    timeout = 30.0,	         #请求超时时间
    retries = 3,  			 #默认重试次数
    headers={'User-Agent':''}
)

GET请求：

response = http.request(
	'GET',
    'http://',
    fields = {'arg':'value'} #查询参数
)

POST请求：

#表单数据
response = http.request(
	'POST',
    'http://',
    fields = {'field':'value'}
)

#JSON数据
import json
response = http.request(
	'POST',
    'http://',
    body = json.dumps({'key':'value'}).encode('utf-8'),
    headers = {'Content-Type':'application/json'}
)

PUT/DELETE请求：

#PUT请求
response = http.request(
	'PUT',
    'http://',
    body = b 'data to put'
)

#DELETE请求
response = http.request(
	'DELETE',
    'http://'
)

文件上传：

with open('example.txt','rb') as f:
    file_data = f.read()

response = http.request(
	'POST',
    'http://',
    fields = {
        'filefield':('example.txt',file_data,'text/plain'),
        'description':'File upload example'
    }
)

响应处理与重要属性

响应对象属性：

response = http.request('GET','http://exmaple.com')

#状态码
print(response.status)
#响应头
print(reponse.headers)
#响应体
print(response.data)
print(response.data.decode('utf-8'))#解码为字符串
#重新定向历史
print(response.redirect_location)
#消耗时间
print(response.elapsed)

响应内容处理：

#JSON响应处理
import json
json_response = json.loads(response.data.decode('utf-8'))

#流式响应处理
response = http.request(
	'GET',
    'http://exmaple.com/largefile',
    preload_content=False
)

try:
    for chunk in response.stream(1024):#每次读1024字节
        process_chunk(chunk)
finally:
     response.release_conn()#释放连接

高级特性与配置

重试机制：

from urllib3.util.retry import Retry

retry_strategy = Retry(
	total = 3, 			#重试总次数
    backoff_factor = 1, #重试间隔增长因子
    status_forcelist = [500,502,503,504]#指定哪些状态码会触发自动重试
)
http = urllib3.PoolManager(retries = retry_strategy)

超时设置：

#全局超时
http = urllib3.PoolManager(timeout=2.0)

#单个请求超时 
response = http.request(
    'GET',
    'http://example.com',
    timeout=5.0 
)

#分别设置连接和读取超时 
response = http.request(
    'GET',
    'http://example.com',
    timeout=urllib3.Timeout(connect=2.0, read=10.0)
)

SSL/TLS配置：

#禁用证书验证(不推荐生产环境使用)
http = urllib3.PoolManager(
    cert_reqs='CERT_NONE',#不校验证书有效性
    assert_hostname=False #不检查证书是否匹配域名
)


#自定义CA证书 
http = urllib3.PoolManager(
    cert_reqs='CERT_REQUIRED',
    ca_certs='/path/to/certificate.pem')#自定义CA

#客户端证书认证 
http = urllib3.PoolManager(
    #证书文件路径
    cert_file='/path/to/client_cert.pem',
    #证书对应私钥文件路径
    key_file='/path/to/client_key.pem')

代理配置：


#HTTP代理 
http = urllib3.ProxyManager(
    #代理服务器地址
    'http://proxy.example.com:8080/',
    #身份认证信息
    proxy_headers={'Proxy-Authorization': 'Basic ...'})

#SOCKS代理(需要安装PySocks)
pip install pysocks 

from urllib3.contrib.socks import SOCKSProxyManager 
proxy = SOCKSProxyManager(
    'socks5://user:password@127.0.0.1:1080/'
)

性能优化技巧

连接池调优：

#根据应用场景调整连接池参数 
http = urllib3.PoolManager(
    num_pools=10,      # 适合大多数应用 
    maxsize=10,        # 每个连接池最大连接数 
    block=True,        # 连接池满时阻塞而非创建新连接 
    timeout=60.0       # 适当延长超时时间 
)

连接重用：

#使用上下文管理器确保连接正确释放 
with http.request('GET', 'http://example.com', preload_content=False) as response:
    process_response(response)
#连接自动返回到连接池

批处理请求（使用线程池并发发起请求，并收集响应对象）：

from concurrent.futures import ThreadPoolExecutor 

urls = ['http://example.com/1',
        'http://example.com/2',
        'http://example.com/3']

def fetch(url):
    return http.request('GET', url)

with ThreadPoolExecutor(max_workers=5) as executor:
    results = list(executor.map(fetch, urls))

6.常见的应用场景

Web API调用：

import json 
from urllib.parse import urlencode 

base_url = "https://api.example.com/v1"

def get_user(user_id):
    response = http.request(
        'GET',
        f"{base_url}/users/{user_id}",
        headers={'Authorization': 'Bearer token123'}
    )
    return json.loads(response.data.decode('utf-8'))

def search_users(query, limit=10):
    params = {'q': query, 'limit': limit}
    response = http.request(
        'GET',
        f"{base_url}/users/search?{urlencode(params)}"
    )
    return json.loads(response.data.decode('utf-8'))

网页抓取：

from bs4 import BeautifulSoup 

def scrape_website(url):
    response = http.request('GET', url)
    if response.status == 200:
        soup = BeautifulSoup(response.data, 'html.parser')
        # 提取数据...
        return {
            'title': soup.title.string,
            #遍历所有的a标签，并提取其中的href属性
            'links': [a['href'] for a in soup.find_all('a')]
        }
    return None

文件下载：

def download_file(url, save_path):
    with http.request('GET', url, preload_content=False) as response:
        if response.status == 200:
            with open(save_path, 'wb') as f:
                for chunk in response.stream(1024):
                    f.write(chunk)
            return True 
    return False

微服务通信：

import json 

def call_service(service_url, method, payload=None):
    headers = {
        'Content-Type': 'application/json',
        'X-Request-ID': 'unique-id-123'
    }

    body = json.dumps(payload).encode('utf-8') if payload else None 

    response = http.request(
        method.upper(),
        service_url,
        headers=headers,
        body=body 
    )

    if response.status >= 400:
        raise Exception(f"Service error: {response.status}")

    return json.loads(response.data.decode('utf-8'))

常见问题

异常处理：

import urllib3.exceptions 

try:
    response = http.request('GET', 'http://example.com')
except urllib3.exceptions.HTTPError as e:
    print(f"HTTP错误: {e}")
except urllib3.exceptions.SSLError as e:
    print(f"SSL错误: {e}")
except urllib3.exceptions.TimeoutError as e:
    print(f"请求超时: {e}")
except urllib3.exceptions.RequestError as e:
    print(f"请求错误: {e}")
except Exception as e:
    print(f"其他错误: {e}")

调试技巧：

#启用调试日志 
import logging 
logging.basicConfig(level=logging.DEBUG)

#或者只启用urllib3的调试日志 
logger = logging.getLogger('urllib3')
logger.setLevel(logging.DEBUG)

#查看连接池状态 
print(http.connection_pool_kw)
print(http.pools)

与request库的对比

更底层的控制：直接访问连接池和底层配置
更小的内存占用：没有 requests 的额外抽象层
更早的错误检测：在请求发送前就能检测到某些问题
更灵活的流处理：对大型文件或流式API更友好
大多数情况用request，精细控制或高性能用urllib3

一些问题

Q	当我向https://www.xiaohongshu.com/发起请求失败时，urllib3会自动重新定向到https://www.xiaohongshu.com/explore，这是为什么，程序为什么会知道https://www.xiaohongshu.com/explore是正确的
A	不是urllib3“知道正确地址”，重新定向是服务端的行为，当向https://www.xiaohongshu.com/发起请求后，小红书的服务器会返回一个HTTP 301或302响应，将正确的网址返回给客户端，同时urllib会默认自动跟随重定向。

Q	JSON响应处理和流式响应处理的区别
A	对于JSON响应处理，response.data一次性读取全部内容，再将其解析为Python对象；流式响应处理，不会把整个响应体加载进内存。JSON响应处理适用于REST API、结构化数据；流式响应处理适用于下载大文件、音视频流等场景

Q	线程与并发的关系
A	线程是并发的一种实现方式，但并发并不限于线程，线程像“工人”，并发像“工人排班的调度方式”，一个线程处理一个任务，多个线程合作是实现

Q	PoolManager和ProxyManager的区别
A	ProxyManager是继承自PoolManager，专门用来处理从代理服务器发出的请求，其重写了PoolManager的部分方法，确保所有的请求都从预定的代理进行，并且它能根据目标的URL的方案和代理类型，智能的选择使用HTTP转发或HTTP CONNECT通道

一些测试代码

一些库导入

import urllib3
import threading
import time
from urllib3.exceptions import EmptyPoolError
import json
import logging
logging.basicConfig(level=logging.DEBUG)

测试连接复用：

# 创建连接池，最大连接数设置为 1（便于观察复用）
http = urllib3.HTTPConnectionPool("httpbin.org", maxsize=1)

# 第一次请求
print("第1次请求")
r1 = http.request("GET", "/get")
print("响应状态码:", r1.status)

# 暂停 1 秒
time.sleep(1)
# 第二次请求
print("\n第2次请求")
r2 = http.request("GET", "/get")
print("响应状态码:", r2.status)

'''
#通过如下方式，检查底层 socket 是否复用
print("连接池中连接数量:", len(http.pool))
for conn in http.pool:
    print("连接对象:", conn)
'''

'''
#测试“不复用的情况”，可以设置 retries=0，并且让服务器关闭连接
r = http.request("GET", "/get", headers={"Connection": "close"})
'''

测试限制连接数+阻塞模式:

# 设置连接池为 maxsize=1，block=False
http = urllib3.HTTPConnectionPool("httpbin.org", maxsize=1, block=False)

# 请求函数：保持连接占用一段时间
def make_request(name):
    print(f"[{name}] 准备发送请求")
    try:
        r = http.request("GET", "/delay/5", preload_content=False, timeout=10.0)
        print(f"[{name}] 已发送请求，延迟读取内容")
        time.sleep(6)  # 保持连接被占用
        r.release_conn()  # 主动释放连接
        print(f"[{name}] 释放连接")
    except EmptyPoolError as e:
        print(f"[{name}] 连接池耗尽异常: {e}")
    except Exception as e:
        print(f"[{name}] 其他异常: {e}")

# 第一个线程：占住唯一连接
t1 = threading.Thread(target=make_request, args=("线程1",))
# 第二个线程：争抢连接
t2 = threading.Thread(target=make_request, args=("线程2",))

t1.start()
time.sleep(0.2)  # 保证线程1先占住连接
t2.start()

t1.join()
t2.join()
'''
连接池已满且不允许阻塞新的请求时，新的连接请求将会被丢弃。这意味着连接池无法处理所有的请求，可能会导致一些请求失败或被延迟处理。
所以在触发连接池已满的情况下不会报错且能正常运行，但在DEBUG日志下会有警告。
'''

验证连接池（num_pool）作用:

'num_pool控制的是最多允许缓存多少个不同主机的连接池，每一个host:port组合会对应一个connectionpool实例，当请求的host数超过num_pools时，旧的连接池将会被清理(LRU策略)'
# 创建连接池管理器，最多2个主机连接池
http = urllib3.PoolManager(num_pools=2, maxsize=1)

hosts = [
    "http://httpbin.org/get",
    "https://www.xiaohongshu.com/explore",
    "http://baidu.com"  # 任意有效网址也可
]

def fetch(url):
    try:
        r = http.request("GET", url)
        print(f"访问 {url} 状态码: {r.status}")
    except Exception as e:
        print(f"访问 {url} 出错: {e}")

# 访问3个不同host，超出num_pools限制
for i in range(2):
    for url in hosts:
        fetch(url)
        time.sleep(0.5)
'''
可以观察到每次发送请求前都得先建立连接，这是因为只能允许存在两个连接池，当继续往里添加连接池时，会把旧的清理，使得再次连接时需要重新建立连接
'''