以学生选课场景为例来进行对比

背景说明
假设我们有一个高校教务系统，包含以下实体：

• 学生（Student）：有学号、姓名
• 课程（Course）：有课程编号、课程名、学分
• 选课关系（Enroll）：学生选了某门课，可能包含成绩（grade）

在关系型数据库中，这通常用三张表实现；在 Neo4j 中，则用节点和关系直接建模。

索引（Index）

索引用于加速查找起点（如按学号找学生、按课程名找课）。

💡 注意：Neo4j 的索引只用于 MATCH 的起点（如 (s:Student {studentId: '2023001'})），后续遍历靠图结构，无需 JOIN。

查询示例

1. 选择并返回所有记录

2. 返回特定字段、排序与分页

需求：列出学分最高的前 5 门课程。

3. 按名称查找单门课程

需求：查找课程名为 “数据库原理” 的课程信息。

更简洁：属性直接写在 {} 中，无需 WHERE。

4. 按列表筛选课程

需求：查找 “高等数学” 和 “线性代数” 两门课的信息。

5. 多条件筛选

需求：查找课程名以 “数据” 开头 且 学分 ≥ 3 的课程。

💡 Neo4j 用 STARTS WITH / CONTAINS / ENDS WITH 替代 LIKE，更直观。

6. 连接学生与课程

需求：找出选了 “数据库原理” 的所有学生姓名。

SQL（需要多次 JOIN）

1
2
3
4
5

SELECT DISTINCT s.name
FROM students s
JOIN enrollments e ON s.student_id = e.student_id
JOIN courses c ON e.course_id = c.course_id
WHERE c.course_name = '数据库原理';

Cypher（直接走关系）

1
2

MATCH (c:Course {courseName: '数据库原理'}) <-[:ENROLL]- (s:Student)
RETURN DISTINCT s.name;

无需 JOIN！关系本身就是路径。
关系类型 :ENROLL 直接表达了“学生选课”的语义。

7. 聚合：每门课的选课人数

需求：统计每门课程有多少人选，按人数降序，取前 3。

💡 OPTIONAL MATCH 相当于 LEFT JOIN，确保没被选的课也显示（人数为 0）。

8. 聚合：每个学生的总学分

需求：计算学生 “张三” 已修课程的总学分。

图遍历天然支持“从学生出发，走到课程，累加学分”。

9. 列出每个学生选的课程（集合聚合）

需求：列出每位学生及其所选课程名（逗号分隔或列表形式）。

COLLECT() 自动将多行合并为列表，结果更结构化（适合 JSON 输出）。

总结对比

Neo4j 图数据库将数据存储为节点、关系和属性，而不是以表格或文档形式。

• 节点 表示图数据模型中的实体或离散对象。节点可以通过关系连接，在属性中存储数据，并按标签分类

  一个节点可以有多个标签 (:User:Customer)

  如：

  1 2 3 4

  (:Person {name: "张三", age: 30}) # Person 是 标签（Label） # {name: "张三", age: 30} 是 属性

• 关系 表示图数据模型中节点之间的连接。关系将源节点连接到目标节点，在属性中存储数据，并按类型分类

  • 关系是有方向的 （A → B ≠ B → A）
  • 有类型（Type）（必须大写，如 KNOWS, BOUGHT）
  • 也可以有属性

  1	(:Person {name: "张三"})-[:FRIEND]->(:Person {name: "李四"})

• 属性 用于在节点和关系上存储数据的键值对

对比：MySQL vs Neo4j

查询语言：Cypher

基础语法对比

常用 Cypher 示例

1. 创建节点

1

CREATE (:Person {name: "王五", city: "北京"});

2. 创建带关系的结构

1
2
3
4

CREATE 
  (a:Person {name: "张三"}),
  (b:Person {name: "李四"}),
  (a)-[:FRIEND {since: 2020}]->(b);

3. 查询某人

1
2

MATCH (p:Person {name: "张三"})
RETURN p.name, p.city;

4. 查询朋友的朋友（2跳）

1
2

MATCH (me:Person {name: "张三"})-[:FRIEND*2]->(friendOfFriend)
RETURN friendOfFriend.name;

*2 表示 2 跳关系，*1..3 表示 1 到 3 跳

5. 忽略方向查询

1
2

MATCH (a)-[r:FRIEND]-(b)  // 无箭头 = 双向
RETURN a.name, b.name;

6. 更新节点

1
2
3

MATCH (p:Person {name: "张三"})
SET p.age = 31
RETURN p;

7. 删除关系（先匹配再删除）

1
2
3

MATCH (a:Person)-[r:FRIEND]->(b:Person)
WHERE a.name = "张三" AND b.name = "李四"
DELETE r;

8. 通过标签查询

1
2
3
4
5
6
7
8
9
10

// 找出所有带 :Person 标签的节点（不管有没有其他标签）
MATCH (p:Person) RETURN p;

// 找出同时有 :Person 和 :Customer 的节点
MATCH (p:Person:Customer) RETURN p;

// 找出有 :Person 但没有 :Admin 标签的节点（需用 WHERE）
MATCH (p:Person)
WHERE NOT p:Admin
RETURN p;

Anaconda 的虚拟环境功能是解决 Python 项目依赖冲突的核心工具，尤其适合多项目并行开发（如同时维护 Python 3.6 的旧项目和 Python 3.11 的新项目）。

为什么要使用多个环境？

如果不使用环境，这些依赖会冲突。使用环境可以完全隔离。

环境创建：从基础到进阶

1. 基础创建：指定 Python 版本

创建环境时必须明确 Python 版本（避免默认版本不匹配），语法如下：

1
2
3

# 格式：conda create -n 环境名 python=具体版本
conda create -n data-analysis python=3.8  # 数据分析环境，Python 3.8
conda create -n tf2x python=3.7           # TensorFlow 2.x 环境，Python 3.7（适配性更高）

• 版本选择原则：优先选择项目依赖包支持的稳定版本（如 PyTorch 2.0+ 推荐 Python 3.8-3.10）。
• 命名规范：建议包含「项目类型 + Python 版本」（如 django32-py310），避免混淆。

2. 进阶创建：一键安装依赖包

创建环境时直接安装核心包，减少后续操作步骤：

1
2
3

# 创建环境并安装 numpy、pandas、jupyter（数据科学常用包）
conda create -n ds-py39 python=3.9 numpy pandas jupyter -y
# -y 参数：自动确认安装（无需手动输入 y）

• 适用场景：新建项目时已知需要的核心依赖（如开发 Flask 项目时，可直接安装 flask gunicorn）。

• 通道选择：若默认通道安装慢，可指定conda-forge通道（社区维护，包更全）：

  1	conda create -n ml-py310 python=3.10 -c conda-forge scikit-learn xgboost

环境管理

1. 环境激活：跨平台差异

不同操作系统的激活命令一致，但终端显示略有不同：

1

conda activate data-analysis  # 激活名为 data-analysis 的环境

• 激活成功标识：终端提示符前会显示 (环境名)，如 (data-analysis) user@mac:~$。
• 常见问题：
  • Windows 下激活失败：需先打开「Anaconda Prompt」（而非系统 cmd），或在 cmd 中先执行 conda init cmd.exe 初始化。
  • Linux/macOS 下激活失败：执行 source ~/anaconda3/bin/activate 初始化 conda 环境后再激活。

2. 环境查看：详细信息与筛选

除了基础的 conda env list，还可查看环境的详细配置：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

# 1. 查看所有环境（* 表示当前激活环境）
conda env list
# 输出示例：
# base                  *  /Users/user/anaconda3
# data-analysis           /Users/user/anaconda3/envs/data-analysis
# tf2x                    /Users/user/anaconda3/envs/tf2x

# 2. 查看当前环境的 Python 版本和包路径
which python  # Linux/macOS：输出当前环境的 Python 路径
where python  # Windows：输出当前环境的 Python 路径
python --version  # 确认当前环境的 Python 版本

# 3. 查看指定环境的已安装包（无需激活该环境）
conda list -n tf2x  # 查看 tf2x 环境的所有包
conda list -n tf2x | grep tensorflow  # 筛选 tf2x 环境中与 tensorflow 相关的包

3. 退出（停用）环境

1

conda deactivate

退出当前环境，回到 base 或系统环境。

4. 环境删除：安全操作与清理

删除环境前建议先确认环境名称，避免误删：

1
2
3
4
5
6
7
8

# 1. 先查看所有环境，确认要删除的环境名
conda env list

# 2. 删除环境（--all 表示删除环境下的所有包和配置）
conda remove -n tf2x --all -y  # -y 自动确认，避免二次提示

# 3. 清理残留缓存（可选，释放磁盘空间）
conda clean -a  # 删除所有缓存的包和索引（不影响已创建的环境）

• 注意：删除环境是不可逆操作，若需保留依赖配置，建议先导出 environment.yml（见下文）。

5. 查看当前环境已安装的包

1
2

# 激活环境后执行
conda list

或指定环境：

1

conda list -n ml-project

依赖管理：导出、共享与同步

1. 导出环境配置：environment.yml

导出环境的完整依赖（包括 Conda 包和 Pip 包），用于备份或团队共享：

1
2
3
4

# 激活目标环境后导出（确保依赖完整）
conda activate data-analysis
conda env export --from-history > environment.yml
# --from-history：仅导出手动安装的包（忽略自动安装的依赖，文件更简洁）

• environment.yml 结构解析：

  1 2 3 4 5 6 7 8 9 10 11

  name: data-analysis # 环境名 channels: # 安装包时的通道优先级 - defaults - conda-forge dependencies: # 依赖列表 - python=3.8 # Python 版本 - numpy=1.24.3 # Conda 安装的包（带版本） - pandas=2.0.1 - pip: # Pip 安装的包（会自动放在 pip 列表下） - python-dotenv==1.0.0 - requests==2.31.0

2. 从配置文件创建环境：团队同步

拿到他人分享的 environment.yml 后，一键创建相同环境：

1
2
3

# 从 environment.yml 创建环境（自动创建环境名并安装所有依赖）
conda env create -f environment.yml -y
# 若环境已存在，可先删除再创建，或使用 update 命令更新

• 团队协作优势：确保所有成员使用相同版本的 Python 和包，避免「本地能跑，线上报错」的问题。

3. 更新环境依赖：添加或删除包

项目开发中需新增或删除依赖时，无需重建环境：

1
2
3
4
5
6
7
8
9
10
11
12

# 1. 激活环境后安装新包（Conda 包）
conda activate data-analysis
conda install matplotlib=3.7.1 -y  # 安装指定版本的 matplotlib

# 2. 安装 Pip 包（Conda 仓库没有的包）
pip install streamlit==1.22.0

# 3. 删除环境中的某个包（Conda 包）
conda remove -n data-analysis matplotlib -y  # 无需激活环境，指定环境名即可

# 4. 根据更新后的依赖，重新导出环境配置
conda env export --from-history > environment.yml

4. 从 environment.yml 更新环境

1

conda env update -f environment.yml --prune

--prune 会删除不再需要的包。

高级场景：克隆环境、Jupyter 集成与 IDE 配置

1. 克隆环境：快速复制配置

当需要基于现有环境创建新环境（如在 data-analysis 基础上添加深度学习包），克隆比重新安装更高效：

1
2
3
4
5
6

# 克隆 data-analysis 环境，创建新环境 data-analysis-ml
conda create -n data-analysis-ml --clone data-analysis -y

# 激活新环境，安装额外包
conda activate data-analysis-ml
conda install scikit-learn tensorflow -y

• 适用场景：测试依赖升级（如克隆环境后升级 pandas 版本，不影响原环境）。

2. Jupyter Notebook/Lab 集成 Conda 环境

默认情况下，Jupyter 只能使用 base 环境的内核，需手动添加其他环境的内核：

1
2
3
4
5
6
7
8
9
10
11

# 1. 激活目标环境
conda activate data-analysis

# 2. 安装 ipykernel（用于将环境注册为 Jupyter 内核）
conda install ipykernel -y

# 3. 注册内核（--name 为内核名，--display-name 为 Jupyter 中显示的名称）
python -m ipykernel install --user --name=data-analysis --display-name "Python (data-analysis)"

# 4. 启动 Jupyter，在「Kernel > Change Kernel」中选择注册的内核
jupyter notebook

• 删除多余内核：若环境已删除，可清理 Jupyter 内核：

  1 2	jupyter kernelspec list # 查看所有内核 jupyter kernelspec remove data-analysis # 删除指定内核

3. IDE 中使用 Conda 环境（VS Code/PyCharm）

（1）VS Code 配置

1. 打开项目文件夹，按 Ctrl+Shift+P（Windows/Linux）或 Cmd+Shift+P（macOS），输入「Python: Select Interpreter」。
2. 选择「Enter interpreter path > Find…」，导航到 Conda 环境的 Python 可执行文件：
   • Linux/macOS 路径：~/anaconda3/envs/环境名/bin/python
   • Windows 路径：C:\Users\用户名\anaconda3\envs\环境名\python.exe
3. 配置完成后，终端会自动激活该环境（需启用「终端：激活环境」设置）。

（2）PyCharm 配置

1. 打开项目，进入「File > Settings > Project: 项目名 > Python Interpreter」（Windows/Linux）或「PyCharm > Settings > Project: 项目名 > Python Interpreter」（macOS）。
2. 点击右上角的「齿轮图标 > Add」，选择「Conda Environment > Existing environment」。
3. 浏览到 Conda 环境的 Python 可执行文件（路径同上），点击「OK」即可。

完整示例：从零开始

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

# 1. 创建环境
conda create -n web-dev python=3.10 flask django

# 2. 激活环境
conda activate web-dev

# 3. 安装更多包
conda install requests
pip install python-dotenv

# 4. 查看已安装包
conda list

# 5. 导出环境配置
conda env export > environment.yml

# 6. 退出环境
conda deactivate

# 7. 删除环境（可选）
conda remove -n web-dev --all

避坑指南：常见问题与解决方案

1. Conda 命令执行慢或超时

• 问题：默认通道（defaults）在国内访问慢，导致安装包或创建环境超时。

• 解决方案：添加国内镜像源（如清华镜像）：

  1 2 3 4 5 6 7 8

  # 1. 查看当前镜像源 conda config --show-sources # 2. 添加清华镜像源 conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/free/ conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/main/ conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud/conda-forge/ conda config --set show_channel_urls yes # 显示包的来源通道

2. 环境激活后，conda 命令失效

• 问题：Linux/macOS 下执行 conda activate 后，提示 conda: command not found。

• 解决方案：重新初始化 Conda 环境：

  1 2 3 4 5 6

  # Linux/macOS：初始化 bash 终端（根据终端类型选择，如 zsh 则用 conda init zsh） source ~/anaconda3/bin/activate conda init bash # 重启终端后，重新激活环境 conda activate data-analysis

3. Pip 安装的包在 Conda 列表中不显示

• 问题：用 pip install 安装的包，执行 conda list 时看不到。

• 原因：Conda 优先显示 Conda 仓库安装的包，Pip 包需通过 pip list 查看。

• 解决方案：

  1 2	pip list # 查看当前环境中所有 Pip 安装的包 pip show requests # 查看指定 Pip 包的详细信息（如安装路径、依赖）

4. 避免在 base 环境安装太多包

建议：

• base 环境只保留 conda, jupyter, numpy 等基础工具。
• 每个项目用独立环境。

核心命令速查表（含高级操作）

总结

Anaconda 虚拟环境的核心价值在于「隔离依赖、统一配置」。无论是个人多项目开发，还是团队协作，掌握环境的创建、依赖导出、IDE 集成等操作，都能显著提升开发效率，避免依赖冲突带来的问题。建议养成「一个项目一个环境」的习惯，并定期导出 environment.yml 备份配置

协程（Coroutine）是 Python 实现高效异步编程的核心技术，尤其适合处理 I/O 密集型任务（如网络请求、文件读写、数据库操作）。它通过「协作式调度」实现并发，避免了线程切换的开销，能在单线程内高效处理成千上万的并发任务。本文将从基础概念到实战应用，全面解析 Python3 协程的使用。

协程的核心概念：为什么需要协程？

在理解协程前，先明确它与线程、进程的区别，以及解决的核心问题：

协程的核心优势：

1. 轻量级：一个进程可包含上千个协程，每个协程仅占用几 KB 内存（线程通常需 MB 级）。
2. 无锁竞争：协程在单线程内执行，共享资源无需加锁（避免死锁问题）。
3. 高效切换：协程切换由程序主动控制（如遇到 I/O 时暂停），无需操作系统介入，切换速度比线程快 100+ 倍。

Python3 协程的演进：从 yield 到 async/await

Python 协程的语法经历了多次迭代，目前推荐使用 Python3.5+ 引入的 async/await 语法（简洁、直观，是官方标准）。

关键语法区别：

• 生成器协程（旧方式，不推荐）：用 def 定义，通过 yield 暂停 / 恢复，需手动处理调度。
• 原生协程（新方式，推荐）：用 async def 定义，通过 await 暂停 / 恢复，配合 asyncio 库实现自动调度。

原生协程基础：async/await 语法

1. 定义协程函数

用 async def 定义协程函数，调用后返回协程对象（而非直接执行函数体）：

1
2
3
4
5
6
7
8
9
10
11

# 定义协程函数
async def hello(name):
    print(f"Hello, {name} (协程开始)")
    # 模拟 I/O 操作（如网络请求、文件读写），此处用 asyncio.sleep 代替
    await asyncio.sleep(1)  # await 暂停协程，等待异步操作完成
    print(f"Hello, {name} (协程结束)")
    return f"Result: {name}"

# 调用协程函数：返回协程对象，不执行函数体
coro = hello("Python")
print(type(coro))  # 输出：<class 'coroutine'>

2. 运行协程：必须通过异步事件循环

协程不能直接调用执行，需通过 asyncio 库的事件循环（Event Loop） 调度。事件循环是协程的 “管理者”，负责：

• 启动协程
• 暂停 / 恢复协程（遇到 await 时暂停，异步操作完成后恢复）
• 调度多个协程并发执行

方式 1：asyncio.run()（Python3.7+ 推荐）

asyncio.run() 是简化版接口，自动创建事件循环、运行协程、关闭循环：

1
2
3
4
5
6
7
8
9
10
11

import asyncio

async def hello(name):
    print(f"Hello, {name} (开始)")
    await asyncio.sleep(1)  # 模拟 I/O 等待，释放事件循环
    print(f"Hello, {name} (结束)")
    return f"Result: {name}"

# 运行协程（自动管理事件循环）
result = asyncio.run(hello("Async"))
print(result)  # 输出：Result: Async

执行流程解析：

1. asyncio.run(hello("Async")) 创建事件循环，启动协程。
2. 协程执行到 await asyncio.sleep(1) 时，暂停自身，并将控制权交还给事件循环。
3. 事件循环等待 1 秒（期间可调度其他协程），待 sleep 完成后，恢复协程继续执行。
4. 协程执行完毕，事件循环关闭，返回结果。

3. 并发运行多个协程

事件循环可同时调度多个协程，实现 “并发”（单线程内交替执行）。常用方式有两种：asyncio.gather() 和 asyncio.create_task()。

方式 1：asyncio.gather()（批量运行，等待所有完成）

适合已知所有协程，需等待全部执行完毕后获取结果：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

import asyncio

async def task(name, delay):
    print(f"任务 {name} 开始，延迟 {delay} 秒")
    await asyncio.sleep(delay)  # 模拟 I/O 操作
    print(f"任务 {name} 结束")
    return f"任务 {name} 结果"

async def main():
    # 批量创建协程，并发运行
    results = await asyncio.gather(
        task("A", 2),  # 延迟 2 秒
        task("B", 1),  # 延迟 1 秒
        task("C", 1.5) # 延迟 1.5 秒
    )
    print("所有任务结果：", results)

# 运行主协程
asyncio.run(main())

输出与分析：

1
2
3
4
5
6
7

任务 A 开始，延迟 2 秒
任务 B 开始，延迟 1 秒
任务 C 开始，延迟 1.5 秒
任务 B 结束  # 1 秒后先完成
任务 C 结束  # 1.5 秒后完成
任务 A 结束  # 2 秒后完成
所有任务结果： ['任务 A 结果', '任务 B 结果', '任务 C 结果']

• 三个任务 “并发” 执行，总耗时 ≈ 2 秒（等于最长任务的延迟），而非 2+1+1.5=4.5 秒。
• asyncio.gather() 会按协程传入顺序返回结果，即使任务完成顺序不同。

方式 2：asyncio.create_task()（动态创建任务，灵活控制）

适合动态添加任务（如循环创建），可单独跟踪每个任务的状态：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

import asyncio

async def task(name, delay):
    print(f"任务 {name} 开始，延迟 {delay} 秒")
    await asyncio.sleep(delay)
    print(f"任务 {name} 结束")
    return f"任务 {name} 结果"

async def main():
    # 1. 创建任务（添加到事件循环）
    task1 = asyncio.create_task(task("A", 2))
    task2 = asyncio.create_task(task("B", 1))
    
    # 2. 可在任务运行中做其他操作
    print("主协程：等待任务完成...")
    
    # 3. 等待任务完成，获取结果
    result1 = await task1
    result2 = await task2
    
    print("任务 1 结果：", result1)
    print("任务 2 结果：", result2)

asyncio.run(main())

输出：

1
2
3
4
5
6
7

主协程：等待任务完成...
任务 A 开始，延迟 2 秒
任务 B 开始，延迟 1 秒
任务 B 结束
任务 A 结束
任务 1 结果： 任务 A 结果
任务 2 结果： 任务 B 结果

协程的核心机制：await 关键字的作用

await 是协程的 “暂停开关”，仅能在 async def 函数内使用，作用是：

1. 暂停当前协程：当执行到 await 异步对象 时，当前协程释放事件循环控制权，进入 “等待” 状态。
2. 等待异步操作完成：异步对象（如 asyncio.sleep()、异步网络请求）完成后，事件循环唤醒当前协程，继续执行后续代码。
3. 传递结果：异步对象的返回值会作为 await 表达式的结果，供协程后续使用。

哪些对象可以被 await？

只有可等待对象（Awaitable） 才能跟在 await 后，主要包括：

• 协程对象（async def 函数返回的对象）
• 任务对象（asyncio.create_task() 创建的对象）
• Future 对象（底层异步结果容器，较少直接使用）

错误示例：await 不能用于普通函数或同步操作（如 time.sleep()）：

1
2
3
4
5
6
7
8
9

import asyncio
import time

async def bad_task():
    # 错误：time.sleep() 是同步函数，不能被 await
    # await time.sleep(1)  # 报错：TypeError: object NoneType can't be used in 'await' expression
    
    # 正确：用 asyncio.sleep()（异步版本）
    await asyncio.sleep(1)

实战：协程处理异步 I/O 任务

协程的核心价值体现在异步 I/O 场景（如并发爬取网页、异步读写数据库）。以下以 “并发爬取多个网页” 为例，展示协程的高效性。

示例：异步爬取网页（使用 aiohttp 库）

requests 库是同步的，需用 aiohttp（异步 HTTP 客户端）配合协程实现异步爬取：

1. 安装依赖：

1

pip install aiohttp  # 异步 HTTP 库

2. 异步爬取代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

import asyncio
import aiohttp

# 异步爬取单个网页
async def fetch_url(session, url):
    try:
        # 异步发送 HTTP 请求（await 等待响应）
        async with session.get(url, timeout=5) as response:
            status = response.status
            content_length = response.headers.get("Content-Length", "未知")
            return f"URL: {url} | 状态码: {status} | 内容长度: {content_length}"
    except Exception as e:
        return f"URL: {url} | 爬取失败: {str(e)}"

# 主协程：并发爬取多个网页
async def main():
    # 待爬取的 URL 列表
    urls = [
        "https://www.baidu.com",
        "https://www.github.com",
        "https://www.python.org",
        "https://www.csdn.net",
        "https://www.zhihu.com"
    ]
    
    # 创建异步 HTTP 会话（复用连接，提高效率）
    async with aiohttp.ClientSession() as session:
        # 1. 批量创建任务（并发爬取）
        tasks = [asyncio.create_task(fetch_url(session, url)) for url in urls]
        
        # 2. 等待所有任务完成，获取结果
        results = await asyncio.gather(*tasks)
        
        # 3. 打印结果
        for result in results:
            print(result)

# 运行主协程
if __name__ == "__main__":
    import time
    start_time = time.time()
    asyncio.run(main())
    end_time = time.time()
    print(f"总耗时：{end_time - start_time:.2f} 秒")

输出分析：

• 5 个网页并发爬取，总耗时 ≈ 1-2 秒（取决于网络延迟），而同步爬取需 5 倍左右时间。
• aiohttp.ClientSession 复用 HTTP 连接，避免频繁建立连接的开销，进一步提升效率。

协程 vs 线程：如何选择？

选择建议：

1. 优先用协程：处理高并发 I/O 任务（如 API 服务、爬虫、消息队列消费者），效率远超线程。
2. 用线程：
   • 场景简单，无需学习异步语法；
   • 依赖仅支持同步的库（无法用协程改写）；
   • 轻量级 CPU 密集任务（如简单计算）。
3. CPU 密集型任务：无论是协程还是线程，都受 GIL 限制，建议用多进程（multiprocessing）。

常见问题与避坑指南

1. 协程中不能使用同步 I/O 库

问题：在协程中使用 requests（同步 HTTP）、time.sleep()（同步睡眠）等，会阻塞整个事件循环，导致所有协程无法并发。解决：替换为对应的异步库：

• 同步 requests → 异步 aiohttp
• 同步 time.sleep() → 异步 asyncio.sleep()
• 同步 sqlite3 → 异步 asyncpg（PostgreSQL）/ aiomysql（MySQL）

2. await 只能在 async def 函数内使用

问题：在普通 def 函数中使用 await，会报错 SyntaxError: 'await' outside async function。解决：将普通函数改为协程函数（async def），或在协程函数内调用该普通函数（若函数无异步操作）。

3. 事件循环的线程安全问题

问题：一个事件循环只能在一个线程内运行，不能在多线程中共享事件循环。解决：

• 每个线程创建独立的事件循环；
• 用 asyncio.run_coroutine_threadsafe() 在其他线程调度协程（复杂场景，需谨慎）。

4. 协程的异常处理

问题：协程中未捕获的异常会导致程序崩溃，需正确处理。解决：用 try-except 捕获 await 后的异常：

1
2
3
4
5
6
7
8

async def task():
    try:
        await asyncio.sleep(1)
        raise ValueError("自定义异常")
    except ValueError as e:
        print(f"捕获异常：{e}")

asyncio.run(task())  # 输出：捕获异常：自定义异常

核心语法速查表

线程（Thread）是 Python 实现并发编程的重要方式，适合处理 I/O 密集型任务（如网络请求、文件读写）。Python3 通过 threading 模块提供了完善的线程支持，本文将详细介绍线程的创建、管理、同步及实战应用。

线程的基本概念

• 线程：操作系统调度的最小单位，属于进程的一部分，多个线程共享进程的内存空间。
• 并发：多个任务交替执行（单核 CPU 模拟多任务）。
• 并行：多个任务同时执行（多核 CPU 真正同时运行）。
• Python 线程特点：
  • 受 GIL（全局解释器锁）限制，CPU 密集型任务多线程效率可能不如单线程；
  • I/O 密集型任务（如网络请求、文件读写）能显著提升效率。

线程的创建与启动

Python3 中创建线程主要有两种方式：使用 threading.Thread 类和继承 threading.Thread 类重写 run() 方法。

方式一：直接使用 threading.Thread

通过 threading.Thread(target=函数名, args=参数) 创建线程对象，调用 start() 启动线程。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

import threading
import time

# 定义线程执行的函数
def task(name, delay):
    for i in range(3):
        print(f"线程 {name} 执行第 {i+1} 次，时间：{time.ctime()}")
        time.sleep(delay)  # 模拟I/O操作（如网络请求）

# 创建线程对象
t1 = threading.Thread(target=task, args=("Thread-1", 1))  # args为元组，传递参数
t2 = threading.Thread(target=task, args=("Thread-2", 2))

# 启动线程（自动调用target函数）
t1.start()
t2.start()

# 等待线程结束（主程序阻塞，直到t1、t2执行完毕）
t1.join()
t2.join()

print("所有线程执行完毕")

输出说明：两个线程交替执行，Thread-1 间隔 1 秒，Thread-2 间隔 2 秒，体现并发特性。

方式二：继承 threading.Thread 类

重写 run() 方法（线程执行的核心逻辑），通过 start() 启动。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

import threading
import time

class MyThread(threading.Thread):
    def __init__(self, name, delay):
        super().__init__()  # 调用父类构造方法
        self.name = name
        self.delay = delay

    # 重写run()方法，线程启动后自动执行
    def run(self):
        for i in range(3):
            print(f"线程 {self.name} 执行第 {i+1} 次，时间：{time.ctime()}")
            time.sleep(self.delay)

# 创建线程实例
t1 = MyThread("Thread-1", 1)
t2 = MyThread("Thread-2", 2)

# 启动线程
t1.start()
t2.start()

# 等待线程结束
t1.join()
t2.join()

print("所有线程执行完毕")

线程的核心方法与属性

示例：守护线程（后台线程）

守护线程用于服务其他线程（如日志记录），主程序结束后自动退出，无需等待其完成。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

import threading
import time

def daemon_task():
    while True:  # 无限循环，模拟后台服务
        print("守护线程运行中...")
        time.sleep(1)

# 创建守护线程
daemon_thread = threading.Thread(target=daemon_task)
daemon_thread.daemon = True  # 设置为守护线程（必须在start()前）

daemon_thread.start()

# 主程序执行3秒后结束
time.sleep(3)
print("主程序结束，守护线程自动退出")

输出：主程序结束后，守护线程的无限循环会被强制终止。

线程同步：解决资源竞争

多个线程共享全局变量时，可能因资源竞争导致数据不一致。需通过同步机制（如锁、信号量）保证操作的原子性。

1. 锁（threading.Lock）

最常用的同步方式，通过 acquire() 获取锁，release() 释放锁，确保同一时间只有一个线程执行临界区代码。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

import threading

# 全局变量（共享资源）
count = 0
lock = threading.Lock()  # 创建锁对象

def increment():
    global count
    for _ in range(1000000):
        # 获取锁（若已被占用则阻塞等待）
        lock.acquire()
        try:
            count += 1  # 临界区：需要同步的操作
        finally:
            # 确保锁释放，避免死锁
            lock.release()

# 创建两个线程，同时修改count
t1 = threading.Thread(target=increment)
t2 = threading.Thread(target=increment)

t1.start()
t2.start()
t1.join()
t2.join()

print(f"最终count值：{count}")  # 若不加锁，结果可能小于2000000；加锁后正确为2000000

说明：count += 1 实际包含 “读取 - 修改 - 写入” 三步，不加锁时可能因线程交替执行导致数据错误，加锁后确保操作完整执行。

2. 可重入锁（threading.RLock）

允许同一线程多次获取锁（避免递归调用时死锁），需释放相同次数。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

import threading

rlock = threading.RLock()

def inner():
    rlock.acquire()
    print("inner 获得锁")
    rlock.release()

def outer():
    rlock.acquire()
    print("outer 获得锁")
    inner()  # 同一线程再次获取锁
    rlock.release()

t = threading.Thread(target=outer)
t.start()
t.join()

3. 其他同步工具

线程池：高效管理线程

频繁创建 / 销毁线程会消耗资源，线程池可预先创建固定数量的线程，重复利用以提高效率。Python3 通过 concurrent.futures.ThreadPoolExecutor 实现。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

from concurrent.futures import ThreadPoolExecutor, as_completed
import threading
import time

def task(num):
    print(f"任务 {num} 开始，线程：{threading.current_thread().name}")
    time.sleep(2)  # 模拟I/O操作
    print(f"任务 {num} 结束")
    return num * 2  # 返回结果

# 创建线程池（最多3个线程）
with ThreadPoolExecutor(max_workers=3) as executor:
    # 提交5个任务
    futures = [executor.submit(task, i) for i in range(5)]
    
    # 获取任务结果（按完成顺序）
    for future in as_completed(futures):
        result = future.result()
        print(f"任务结果：{result}")

优势：

• 自动管理线程生命周期，避免频繁创建开销；
• 方便获取任务结果（future.result()）；
• 支持批量提交任务，简化代码。

线程 vs 进程：如何选择？

常见问题与避坑指南

1. GIL 导致的 CPU 密集型性能问题Python 的 GIL 限制同一时间只有一个线程执行 Python 字节码，因此多线程不适合 CPU 密集型任务（如大规模计算），建议用多进程（multiprocessing）。

2. 死锁风险多个线程互相等待对方释放锁会导致死锁，避免方式：

   • 按固定顺序获取锁；
   • 使用 with 语句自动管理锁（with lock: ... 替代 acquire()/release()）。

   1 2 3

   # 安全的锁使用方式（自动释放） with lock: count += 1 # 临界区操作

1. 全局变量的线程安全非原子操作（如 count += 1、列表 append() 后 pop()）需加锁保护，原子操作（如简单赋值 a = 1）无需同步。

实战案例：多线程爬取网页

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

import threading
import requests
from concurrent.futures import ThreadPoolExecutor

# 爬取网页内容
def fetch_url(url):
    try:
        response = requests.get(url, timeout=5)
        return f"{url} 状态码：{response.status_code}"
    except Exception as e:
        return f"{url} 爬取失败：{str(e)}"

# 待爬取的URL列表
urls = [
    "https://www.baidu.com",
    "https://www.github.com",
    "https://www.python.org",
    "https://www.csdn.net"
]

# 使用线程池并发爬取
with ThreadPoolExecutor(max_workers=2) as executor:
    results = executor.map(fetch_url, urls)  # 批量提交任务

for result in results:
    print(result)

说明：网络请求属于 I/O 密集型任务，多线程能显著减少总耗时（无需等待前一个请求完成再发起下一个）。

总结

Python3 线程是处理并发任务的重要工具，尤其适合 I/O 密集型场景。核心要点：

• 通过 threading.Thread 或继承类创建线程，start() 启动，join() 等待结束；
• 用锁（Lock）解决共享资源竞争问题；
• 线程池（ThreadPoolExecutor）高效管理线程，推荐优先使用；
• 避开 GIL 限制，CPU 密集型任务优先选多进程

在 PHP 中，函数参数的传递方式有两种：值传递（默认值）和引用传递。理解这两种机制的区别对于助于理解变量在函数内外的交互方式，避免意外的变量修改或性能问题。

值传递（Pass by Value）

值传递是 PHP 中默认的参数传递方式。当使用值传递时，函数会接收参数的副本，函数内部对参数的修改不会影响外部原始变量。

1
2
3
4
5
6
7
8
9
10
11

<?php
function increment($number) {
    $number++; // 修改的是参数的副本
    echo "函数内部：{$number}<br>"; // 输出：函数内部：11
}

$original = 10;
increment($original);
echo "函数外部：{$original}"; // 输出：函数外部：10（原始变量未改变）
?>

值传递的特点：

• 函数内部操作的是原始值的副本，不影响外部变量
• 适合传递简单类型（整数、字符串、布尔值等）
• 传递大型变量（如大数组）时，会复制数据，可能消耗更多内存

引用传递（Pass by Reference）

引用传递允许函数接收变量的内存地址，而非值的副本。函数内部对参数的修改会直接影响外部原始变量，无需返回值即可同步变化。

引用传递通过在参数前添加 & 符号声明。

1
2
3
4
5
6
7
8
9
10
11

<?php
function incrementByReference(&$number) { // 参数前加&表示引用传递
    $number++; // 直接修改原始变量
    echo "函数内部：{$number}<br>"; // 输出：函数内部：11
}

$original = 10;
incrementByReference($original);
echo "函数外部：{$original}"; // 输出：函数外部：11（原始变量被修改）
?>

引用传递的特点：

• 函数内部操作的是原始变量，修改会同步到外部
• 传递时无需复制数据，适合大型变量（如大数组、对象），可节省内存
• 调用函数时不能直接传递值，必须传递变量（如 incrementByReference(10) 会报错）

引用传递的适用场景

1. 需修改外部变量时

当函数需要修改外部变量且不希望通过返回值赋值时，引用传递很有用。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

<?php
// 交换两个变量的值
function swap(&$a, &$b) {
    $temp = $a;
    $a = $b;
    $b = $temp;
}

$x = 5;
$y = 10;
swap($x, $y);

echo "x = {$x}, y = {$y}"; // 输出：x = 10, y = 5
?>

2. 处理大型数据时

传递大型数组或字符串时，引用传递可避免复制大量数据，提高性能。

1
2
3
4
5
6
7
8
9
10
11
12

<?php
// 处理大型数组（假设包含10000个元素）
function processLargeArray(&$largeArray) {
    // 直接操作原始数组，无需复制
    foreach ($largeArray as &$item) {
        $item = $item * 2;
    }
}

$myArray = range(1, 10000); // 生成大型数组
processLargeArray($myArray); // 引用传递，节省内存
?>

3. 函数返回多个值时

虽然 PHP 函数只能返回一个值，但通过引用传递可间接实现 “返回” 多个修改后的值。

1
2
3
4
5
6
7
8
9
10
11
12

<?php
function calculate(&$sum, &$product, $a, $b) {
    $sum = $a + $b;
    $product = $a * $b;
}

$x = 0;
$y = 0;
calculate($x, $y, 5, 3);

echo "和：{$x}, 积：{$y}"; // 输出：和：8, 积：15
?>

对象的传递方式（特殊情况）

在 PHP 中，对象默认按 “引用语义” 传递，但严格来说并非引用传递，而是对象标识符（类似指针）的 值传递。当对象作为参数传递时，函数内部修改对象的属性会影响外部对象，但重新赋值对象变量不会影响外部。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

<?php
class Person {
    public $name;
    public function __construct($name) {
        $this->name = $name;
    }
}

function changeName($person, $newName) {
    // 修改对象属性（会影响外部）
    $person->name = $newName;
    
    // 重新赋值对象变量（不会影响外部）
    $person = new Person("New Person");
}

$person = new Person("John");
changeName($person, "Jane");

echo $person->name; // 输出：Jane（属性修改被保留）
?>

说明：对象传递时，函数接收的是对象标识符的副本，因此：

• 修改对象属性会影响外部（操作的是同一对象）
• 重新赋值参数（如 $person = new Person()）不会影响外部（只是修改了副本的指向）

引用传递与值传递的核心区别

最佳实践

1. 优先使用值传递：默认情况下使用值传递，避免意外修改外部变量，使代码更可预测。
2. 谨慎使用引用传递：引用传递会增加代码耦合度（函数与外部变量强关联），仅在必要时使用。
3. 对象传递无需显式引用：对象默认的传递机制已能满足大多数需求，无需额外添加 &。
4. 大型数组考虑引用传递：处理包含大量元素的数组时，引用传递可显著提升性能。
5. 明确文档说明：使用引用传递时，在函数注释中明确说明参数会被修改，方便其他开发者理解。

总结

PHP 中的值传递和引用传递是两种不同的参数传递机制：

• 值传递：传递副本，内部修改不影响外部，适合大多数场景。
• 引用传递：传递地址，内部修改同步到外部，适合需共享修改或优化大型数据传递的场景。

PHP8 对面向对象编程（OOP）进行了多项增强，引入了新特性并改进了现有功能，使类和接口的使用更加灵活和强大。本文将详细介绍 PHP8 中类和接口的定义、特性及新功能。

类的基本概念与定义

类是面向对象编程的基本构建块，用于封装数据和操作数据的方法。

1. 基本类定义

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

<?php
class Person {
    // 属性
    public $name;
    public $age;
    
    // 构造方法
    public function __construct(string $name, int $age) {
        $this->name = $name;
        $this->age = $age;
    }
    
    // 方法
    public function greet() {
        return "Hello, my name is {$this->name} and I'm {$this->age} years old.";
    }
    
    public function birthday() {
        $this->age++;
    }
}

// 创建对象
$person = new Person("John", 30);
echo $person->greet(); // 输出：Hello, my name is John and I'm 30 years old.

$person->birthday();
echo $person->greet(); // 输出：Hello, my name is John and I'm 31 years old.
?>

2. 属性与访问修饰符

PHP 支持三种访问修饰符，用于控制类成员的访问权限：

• public：公共成员，可以在任何地方访问
• protected：受保护成员，只能在类内部和子类中访问
• private：私有成员，只能在类内部访问

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

<?php
class BankAccount {
    public $accountNumber;      // 公共属性
    protected $balance;         // 受保护属性
    private $pinCode;           // 私有属性
    
    public function __construct(string $accountNumber, float $balance, string $pinCode) {
        $this->accountNumber = $accountNumber;
        $this->balance = $balance;
        $this->pinCode = $pinCode;
    }
    
    // 公共方法可以访问所有属性
    public function getBalance(string $pin) {
        if ($this->verifyPin($pin)) {
            return $this->balance;
        }
        return "Invalid PIN";
    }
    
    // 受保护方法
    protected function addFunds(float $amount) {
        $this->balance += $amount;
    }
    
    // 私有方法
    private function verifyPin(string $pin) {
        return $pin === $this->pinCode;
    }
}

$account = new BankAccount("123456", 1000.00, "1234");
echo $account->accountNumber; // 可以访问公共属性
echo $account->getBalance("1234"); // 可以通过公共方法访问受保护和私有属性
// echo $account->balance; // 错误：不能直接访问受保护属性
// echo $account->pinCode; // 错误：不能直接访问私有属性
?>

PHP8 类的新特性

1. 构造方法属性提升（PHP8.0+）

PHP8 引入了构造方法属性提升，允许在构造方法参数中直接声明类属性，简化代码。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

<?php
// 传统方式
class UserOld {
    public $name;
    public $email;
    
    public function __construct(string $name, string $email) {
        $this->name = $name;
        $this->email = $email;
    }
}

// PHP8 构造方法属性提升
class UserNew {
    // 在构造方法参数中直接声明属性
    public function __construct(
        public string $name,
        public string $email
    ) {
        // 无需赋值，PHP自动处理
    }
}

$user = new UserNew("John Doe", "john@example.com");
echo $user->name; // 输出：John Doe
echo $user->email; // 输出：john@example.com
?>

2. 只读属性（PHP8.1+）

PHP8.1 引入了 readonly 关键字，用于声明只能初始化一次且不能修改的属性。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

<?php
class Product {
    public readonly string $name;
    public readonly float $price;
    
    public function __construct(string $name, float $price) {
        $this->name = $name;
        $this->price = $price;
    }
}

$product = new Product("Laptop", 999.99);
echo $product->name; // 输出：Laptop

// $product->name = "Phone"; // 错误：Cannot modify readonly property
?>

3. 联合类型（PHP8.0+）

PHP8 支持联合类型，表示一个参数或返回值可以是多种类型中的一种。

1
2
3
4
5
6
7
8
9
10
11
12
13
14

<?php
class Calculator {
    // 接受int或float类型的参数
    public function add(int|float $a, int|float $b): int|float {
        return $a + $b;
    }
}

$calc = new Calculator();
echo $calc->add(2, 3); // 输出：5（int）
echo $calc->add(2.5, 3.5); // 输出：6（float）
echo $calc->add(2, 3.5); // 输出：5.5（float）
?>

4. 命名参数（PHP8.0+）

PHP8 支持命名参数，允许在调用方法时通过参数名指定值，而不必严格按照参数顺序。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

<?php
class Message {
    public function send(string $to, string $subject, string $body): void {
        echo "Sending to: $to\n";
        echo "Subject: $subject\n";
        echo "Body: $body\n";
    }
}

$message = new Message();

// 使用命名参数，无需考虑顺序
$message->send(
    subject: "Hello",
    to: "john@example.com",
    body: "This is a test message"
);
?>

继承与多态

1. 类的继承

PHP 支持单继承，使用 extends 关键字实现类的继承。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

<?php
class Animal {
    protected string $name;
    
    public function __construct(string $name) {
        $this->name = $name;
    }
    
    public function getName(): string {
        return $this->name;
    }
    
    public function makeSound(): string {
        return "Some generic sound";
    }
}

// 继承Animal类
class Dog extends Animal {
    // 重写父类方法
    public function makeSound(): string {
        return "Woof! Woof!";
    }
    
    // 子类新增方法
    public function fetch(): string {
        return "{$this->name} is fetching the ball";
    }
}

$dog = new Dog("Buddy");
echo $dog->getName(); // 输出：Buddy（继承的方法）
echo $dog->makeSound(); // 输出：Woof! Woof!（重写的方法）
echo $dog->fetch(); // 输出：Buddy is fetching the ball（新增的方法）
?>

2. 抽象类与抽象方法

抽象类使用 abstract 关键字声明，不能被实例化，只能被继承。抽象方法没有实现，必须在子类中实现。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

<?php
abstract class Shape {
    protected string $color;
    
    public function __construct(string $color) {
        $this->color = $color;
    }
    
    public function getColor(): string {
        return $this->color;
    }
    
    // 抽象方法，子类必须实现
    abstract public function getArea(): float;
}

class Circle extends Shape {
    private float $radius;
    
    public function __construct(string $color, float $radius) {
        parent::__construct($color);
        $this->radius = $radius;
    }
    
    // 实现抽象方法
    public function getArea(): float {
        return pi() * $this->radius * $this->radius;
    }
}

$circle = new Circle("red", 5);
echo $circle->getColor(); // 输出：red
echo $circle->getArea(); // 输出：78.5398...
?>

接口

接口定义了类应该实现的方法，但不提供方法的实现。类使用 implements 关键字实现接口。

1. 基本接口定义与实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

<?php
// 定义接口
interface Logger {
    public function log(string $message): void;
    public function error(string $message): void;
}

// 实现接口
class FileLogger implements Logger {
    private string $filename;
    
    public function __construct(string $filename) {
        $this->filename = $filename;
    }
    
    public function log(string $message): void {
        $this->writeToFile("LOG: " . $message);
    }
    
    public function error(string $message): void {
        $this->writeToFile("ERROR: " . $message);
    }
    
    private function writeToFile(string $message): void {
        $timestamp = date('Y-m-d H:i:s');
        file_put_contents(
            $this->filename,
            "[$timestamp] $message\n",
            FILE_APPEND
        );
    }
}

// 使用实现了接口的类
$logger = new FileLogger('app.log');
$logger->log('Application started');
$logger->error('Something went wrong');
?>

2. 接口继承

接口可以继承其他接口，使用 extends 关键字。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35