Python on 吾爱主机

Python asyncio 事件循环与 Task 取消：原理、API 与工程实践

Mon, 20 Jul 2026 00:00:00 +0800

高并发 HTTP 客户端、WebSocket 网关、爬虫调度、微服务侧车——Python 侧大量 IO 密集型场景会落到 asyncio。写得不好时，常见症状是：协程“创建了却从不调度”、后台 Task 被 GC 悄悄干掉、超时后资源不释放、CancelledError 被误吞导致 TaskGroup / timeout 行为异常。

本文基于官方文档 asyncio — Asynchronous I/O、Coroutines and Tasks、Runners、Developing with asyncio，以及 PEP 492，把 事件循环协作调度、Task 生命周期、结构化并发、取消与超时 讲清楚，并给出可复现的写法与排障清单。

一、问题背景：并发不等于多线程

asyncio 的定位很明确：

asyncio is a library to write concurrent code using the async/await syntax.
asyncio is often a perfect fit for IO-bound and high-level structured network code.

它解决的是“大量等待网络/磁盘时如何让 CPU 去干别的活”，而不是用多核并行跑 CPU 密集计算。事件循环通常跑在 一个线程 内：某个 Task 在执行同步代码时，同线程的其他 Task 无法推进；只有执行到 await，当前 Task 挂起，循环才调度下一个。

若把 time.sleep、同步 requests、重型 JSON/CPU 计算直接塞进协程，等价于堵死整条事件循环。官方开发指南的原则是：阻塞工作放到线程池（asyncio.to_thread / loop.run_in_executor），循环线程只做非阻塞 IO 与调度。

概念	含义	工程后果
协程函数 `async def`	调用后得到协程对象，不会自动运行	只写 `foo()` 而不 `await`/`create_task` 会 RuntimeWarning
Awaitable	可被 `await` 的对象	三类主路径：协程、Task、Future
Event loop	调度 Task/回调、做网络 IO、跑子进程	应用层优先用 `asyncio.run`，少直接操作 loop
Task	被调度执行的协程包装	可取消、可聚合、可命名/追踪

二、核心模型：协作式调度 + 弱引用 Task

1. 必须“跑起来”，而不能只“创建”

import asyncio

async def main():
 print("hello")
 await asyncio.sleep(1)
 print("world")

asyncio.run(main())

官方示例同时强调反例：

>>> main()
<coroutine object main at 0x...>

单纯调用协程不会把它排进事件循环。入口应使用 asyncio.run(coro)：它负责创建/关闭循环、收尾异步生成器、关闭默认 executor。同一线程已有运行中的 loop 时不能再调用 asyncio.run（嵌套场景用 asyncio.Runner 或上层框架提供的生命周期）。

2. 并发来自 Task，不是“多写几个 await”

串行：

await say_after(1, "hello")
await say_after(2, "world") # 总耗时约 3s

并发：

task1 = asyncio.create_task(say_after(1, "hello"))
task2 = asyncio.create_task(say_after(2, "world"))
await task1
await task2 # 总耗时约 2s

create_task 把协程包成 Task 并立即调度。一个极易踩坑的细节（官方明确写出）：

The event loop only keeps weak references to tasks. A task that isn’t referenced elsewhere may get garbage collected at any time, even before it’s done.

“发后不管”的后台任务必须放进集合，并在 done 回调里移除：

background_tasks: set[asyncio.Task] = set()

def spawn(coro):
 task = asyncio.create_task(coro)
 background_tasks.add(task)
 task.add_done_callback(background_tasks.discard)
 return task

3. 结构化并发：优先 `TaskGroup`（3.11+）

asyncio.TaskGroup 把“创建 + 等待全部结束”绑在异步上下文管理器里：

async def main():
 async with asyncio.TaskGroup() as tg:
 tg.create_task(say_after(1, "hello"))
 tg.create_task(say_after(2, "world"))
 # 退出 with 时，组内任务均已结束

组内若有任务抛出非 CancelledError 的异常，会汇总为 ExceptionGroup / BaseExceptionGroup 再抛出。相对“手写 create_task + 忘记 await”，TaskGroup 更不容易留下孤儿任务。

API	典型用途	注意点
`create_task`	灵活并发、需要 Task 句柄	保持强引用；自行处理汇合
`TaskGroup`	结构化并发、统一收口	异常变为 ExceptionGroup；依赖取消语义正确
`gather(*aws, return_exceptions=False)`	固定一批 awaitable 一起等	默认某任务异常会影响整体策略；结果顺序与入参一致
`wait(aws, return_when=...)`	需要 `done/pending` 集合或 FIRST_COMPLETED	入参必须是 Future/Task 集合，不能是裸协程习惯用法

gather 适合“固定 N 路、要按入参顺序拿结果”：

results = await asyncio.gather(
 fetch(u1),
 fetch(u2),
 fetch(u3),
 return_exceptions=True, # 单个失败不中断其余；结果里可能是 Exception 实例
)

return_exceptions=False（默认）时，任一 awaitable 以异常结束，gather 会把该异常传播给调用方（其余任务的收尾策略仍需按版本与场景理解，工程上更稳妥的是用 TaskGroup 明确“有错就结构化失败”）。wait 则返回 (done, pending)，并可用 FIRST_COMPLETED / FIRST_EXCEPTION / ALL_COMPLETED 控制返回时机，适合“谁先完成谁处理、其余取消”的竞态选路。

三、取消与超时：CancelledError 是协作信号

1. 取消发生在“下一次机会”

task.cancel() 请求取消后，目标 Task 会在 下一次可取消点（通常是 await）注入 asyncio.CancelledError。官方建议：

用 try/finally 做资源清理（关连接、放回连接池、落盘状态）；
若显式 except CancelledError，清理完成后 一般应继续抛出；
CancelledError 直接继承 BaseException，因此普通 except Exception 抓不到它——这是刻意设计。

吞掉取消会破坏结构化并发组件：

asyncio.TaskGroup and asyncio.timeout() are implemented using cancellation internally and might misbehave if a coroutine swallows asyncio.CancelledError.

2. 超时：`wait_for` 与 `timeout` 上下文

# 超时后取消 awaitable，并抛 TimeoutError
try:
 await asyncio.wait_for(long_job(), timeout=5)
except TimeoutError:
 ...

wait_for 在超时路径会取消目标任务；为避免取消可包 shield（见下）。函数会等到取消真正完成，因此总等待可能略大于 timeout。

3.11+ 更推荐上下文管理器写法：

async def main():
 try:
 async with asyncio.timeout(10):
 await long_running_task()
 except TimeoutError:
 # TimeoutError 只能在 with 之外捕获
 ...

timeout 会取消 当前 Task，内部把 CancelledError 转成 TimeoutError。timeout_at(when) 用绝对 deadline，适合与外部截止时间对齐。

3. `shield`：挡外层取消，不挡内层自杀

res = await asyncio.shield(critical_section())

外层 Task 被取消时，critical_section 对应 Task 不一定 被取消；但从调用方看，await 仍会抛 CancelledError。若 critical_section 自己取消自己，shield 挡不住。完全“无视取消”通常不推荐——多数场景应清理后退出。

4. 可复现小实验：串行 vs 并发 vs 超时取消

把下面脚本存为 asyncio_lab.py，用本机 Python 3.11+ 直接跑，对照耗时与异常类型：

import asyncio
import time

async def work(name: str, delay: float, fail: bool = False):
 print(f"{name}: start")
 try:
 await asyncio.sleep(delay)
 if fail:
 raise RuntimeError(f"{name} failed")
 print(f"{name}: done")
 return name
 finally:
 print(f"{name}: cleanup")

async def demo_serial():
 t0 = time.perf_counter()
 await work("A", 1)
 await work("B", 1)
 print("serial_sec=", round(time.perf_counter() - t0, 2))

async def demo_concurrent():
 t0 = time.perf_counter()
 async with asyncio.TaskGroup() as tg:
 tg.create_task(work("A", 1))
 tg.create_task(work("B", 1))
 print("concurrent_sec=", round(time.perf_counter() - t0, 2))

async def demo_timeout_cancel():
 try:
 async with asyncio.timeout(0.3):
 await work("slow", 2)
 except TimeoutError:
 print("got TimeoutError as expected")

async def demo_swallow_cancel_bad():
 async def bad():
 try:
 await asyncio.sleep(10)
 except asyncio.CancelledError:
 print("swallowed cancel — TaskGroup/timeout 可能异常")
 # 反例：清理后应 re-raise
 return "oops"

 task = asyncio.create_task(bad())
 await asyncio.sleep(0.05)
 task.cancel()
 print("bad_result=", await asyncio.gather(task, return_exceptions=True))

async def main():
 await demo_serial()
 await demo_concurrent()
 await demo_timeout_cancel()
 await demo_swallow_cancel_bad()

if __name__ == "__main__":
 asyncio.run(main())

预期现象：

串行约 2s，并发约 1s，说明 await 串接 ≠ 并发；
超时路径打印 cleanup 后得到 TimeoutError（timeout 上下文在内部完成 CancelledError 转换）；
吞掉 CancelledError 会让任务“以普通返回值结束”，外层若误以为已取消，容易泄漏后续逻辑。

四、工程实践：从入口到排障

1. 入口与生命周期

async def app():
 # 创建共享资源：连接池、httpx.AsyncClient 等
 async with lifespan():
 await serve()

if __name__ == "__main__":
 asyncio.run(app(), debug=False) # 开发可 debug=True

需要在同一 loop 多次跑顶层协程时，用 asyncio.Runner 上下文，而不是嵌套 asyncio.run。

2. 阻塞调用迁出事件循环

def blocking_io():
 # 同步 SDK / 磁盘 / 旧库
 return open("/etc/hosts").read()

async def handler():
 data = await asyncio.to_thread(blocking_io)
 return data

to_thread 会传播 contextvars，适合 IO 型阻塞；CPU 密集可考虑进程池 executor。

3. 取消友好的业务骨架

async def fetch_with_cleanup(session, url):
 resp = None
 try:
 resp = await session.get(url)
 return await resp.text()
 finally:
 if resp is not None:
 await resp.aclose()

原则：

所有可能长时间 await 的路径都假定可被取消；
持有的锁、文件、连接在 finally 释放；
不要用裸 except Exception: pass 包住整段协程。

4. 并发扇出模板

async def fan_out(urls: list[str], limit: int = 20):
 sem = asyncio.Semaphore(limit)

 async def one(url: str):
 async with sem:
 return await fetch(url)

 async with asyncio.TaskGroup() as tg:
 tasks = [tg.create_task(one(u)) for u in urls]
 return [t.result() for t in tasks]

限流用 Semaphore，汇合用 TaskGroup，超时可在外层 async with asyncio.timeout(...) 包住整组或单个 one。

5. 调试开关

开发期打开 debug mode（任选其一）：

环境变量 PYTHONASYNCIODEBUG=1
asyncio.run(..., debug=True)
loop.set_debug(True)

debug 能更清楚地指出 never-awaited coroutine 的创建栈，并帮助发现慢回调。配合：

import logging
logging.basicConfig(level=logging.DEBUG)

6. 与多线程协作时的边界

官方 Developing with asyncio 写得很清楚：事件循环在一个线程里跑所有回调与 Task；几乎所有 asyncio 对象都不是线程安全的。从其他 OS 线程调度回调必须用 loop.call_soon_threadsafe(...)；从其他线程提交协程用 asyncio.run_coroutine_threadsafe(coro, loop)，它返回 concurrent.futures.Future。反向地，若只是要把阻塞函数丢出循环线程，优先 asyncio.to_thread，而不是自己裸开线程再回调 loop。

工程约束可以记成：

一个 loop 绑定一个线程（通常是主线程）；
跨线程只走 threadsafe API；
业务协程里不要 threading.Lock 长时间占着不 await——锁竞争会放大“假死”表象。

7. HTTP 扇出 + 首个成功取消其余

async def first_success(coros):
 tasks = [asyncio.create_task(c) for c in coros]
 try:
 while tasks:
 done, pending = await asyncio.wait(
 tasks, return_when=asyncio.FIRST_COMPLETED
 )
 for d in done:
 if d.exception() is None:
 for p in pending:
 p.cancel()
 # 收尾 pending，避免警告
 await asyncio.gather(*pending, return_exceptions=True)
 return d.result()
 tasks = list(pending)
 raise RuntimeError("all failed")
 finally:
 for t in tasks:
 if not t.done():
 t.cancel()

这是“多副本查询取最快”的常见模式：与 Go 里 fan-out + context cancel 同构，只是取消载体从 context.Context 换成了 Task.cancel / CancelledError。

五、常见坑与排查清单

症状	可能根因	排查/修复
`RuntimeWarning: coroutine 'x' was never awaited`	写了 `x()` 却未 `await`/`create_task`	打开 debug；全文搜未 await 的调用
后台任务“跑一半消失”	只 `create_task` 未保存强引用	`set` + `add_done_callback(discard)`
整体 QPS 骤降、延迟抖动	协程内同步阻塞	火焰图/`asyncio` 慢回调日志；改 `to_thread`
超时后连接仍占满	取消路径无 `finally` 清理	统一 async context manager
`TaskGroup` / `timeout` 行为怪异	`except CancelledError: pass` 吞取消	清理后 re-raise；勿滥用 `uncancel`
Jupyter/已有 loop 报错	嵌套 `asyncio.run`	用框架提供的 loop / `Runner` / `await` 直接写
取消不及时	长段纯计算无 `await`	拆分、主动 `await asyncio.sleep(0)` 让出（治标）或迁线程/进程（治本）

快速自检脚本思路：

# 1) 开发模式跑入口
PYTHONASYNCIODEBUG=1 python app.py

# 2) 确认没有 never-awaited
# 3) 压测时观察是否仅单核打满且无网络等待（疑似阻塞循环）

六、总结

asyncio 是单线程协作式并发：await 是让出点；阻塞代码会冻住所有 Task。
协程对象 ≠ 已调度任务：入口用 asyncio.run，并发用 create_task / TaskGroup。
Task 只有弱引用：fire-and-forget 必须自管强引用集合。
取消是协作语义：CancelledError 属 BaseException；清理后应继续传播，否则破坏 TaskGroup/timeout。
超时优先结构化 API：asyncio.timeout / wait_for；关键段可 shield，但不要“永远不退出”。
阻塞 IO 迁出循环：to_thread / executor；开发期打开 debug 抓 never-awaited 与慢回调。

掌握“调度模型 + 取消契约 + 结构化汇合”，比背一长串 API 更能写出可维护的异步服务。

参考资料

DrissionPage 完全指南：比 Selenium 更好用的 Python 网页自动化工具

Thu, 25 Jun 2026 19:30:00 +0000

前言

DrissionPage 是一个基于 Python 的网页自动化工具，由 g1879 开发。名称含义：Drission = Driver + Session，将浏览器控制和 HTTP 数据包收发合二为一。相比 Selenium，它无需下载驱动、速度更快、语法更简洁，是 Python 网页自动化的利器。

1. 核心特性

特性	说明
自研内核	不基于 webdriver，无需为不同浏览器下载驱动
双模式合一	浏览器模式（d）+ 数据包模式（s），可随时切换
极简定位语法	`#id`、`.class`、`text` 比 Selenium 简洁得多
跨 iframe	直接查找元素，无需 switch_to
多标签页	同时操作多个标签页，无需切换焦点
内置等待重试	无需 sleep，自动等待元素加载
整页截图	包括视口外的部分
配置持久化	ini 文件保存配置，自动调用

2. 安装

pip install DrissionPage

# 升级
pip install DrissionPage --upgrade

# 使用国内镜像
pip install -i https://pypi.tuna.tsinghua.edu.cn/simple DrissionPage

环境要求：

Python 3.6+
Chromium 内核浏览器（Chrome、Edge）

3. 核心概念

3.1 两种模式

模式	说明	优点	缺点
d 模式（Driver）	控制浏览器	可点击、填写、执行 JS	占内存，速度慢
s 模式（Session）	收发数据包	速度快几个数量级	不能操作页面

3.2 主要对象

# 浏览器控制
from DrissionPage import Chromium

# 数据包模式
from DrissionPage import SessionPage

# 配置类
from DrissionPage import ChromiumOptions

4. ChromiumPage — 浏览器自动化

4.1 基本使用

from DrissionPage import Chromium

# 创建浏览器对象
browser = Chromium()

# 获取标签页
tab = browser.latest_tab

# 访问网页
tab.get('https://www.baidu.com')

# 获取元素并交互
ele = tab.ele('#kw') # 获取搜索框
ele.input('DrissionPage') # 输入文本
tab('#su').click() # 点击搜索按钮

# 获取结果
links = tab.eles('tag:h3')
for link in links:
 print(link.text)

4.2 连接已打开的浏览器

from DrissionPage import Chromium, ChromiumOptions

co = ChromiumOptions()
co.set_address('127.0.0.1:9222')
browser = Chromium(addr_or_opts=co)
tab = browser.latest_tab

4.3 浏览器配置

from DrissionPage import Chromium, ChromiumOptions

co = ChromiumOptions()

# 常用配置（支持链式调用）
co.headless() # 无头模式
co.no_imgs(True) # 不加载图片
co.mute(True) # 静音
co.incognito() # 匿名模式
co.set_argument('--no-sandbox') # 无沙盒（Linux 常用）
co.set_argument('--window-size', '1920,1080') # 窗口大小
co.set_browser_path('/usr/bin/google-chrome') # 浏览器路径
co.auto_port(True) # 自动分配端口

# 添加插件
co.add_extension('/path/to/extension')

# 保存配置到 ini 文件
co.save('/path/to/config.ini')

# 加载配置
co = ChromiumOptions(ini_path='/path/to/config.ini')

# 启动浏览器
browser = Chromium(addr_or_opts=co)

5. SessionPage — HTTP 请求

5.1 GET 请求

from DrissionPage import SessionPage

page = SessionPage()

# 普通请求
page.get('https://example.com')

# 带参数
page.get('https://example.com', params={'page': 1})

# 带 headers 和 cookies
page.get('https://example.com',
 headers={'Referer': 'https://google.com'},
 cookies={'token': 'abc123'})

# 带代理
page.get('https://example.com',
 proxies={'http': '127.0.0.1:1080', 'https': '127.0.0.1:1080'})

# 读取本地文件
page.get('/path/to/file.html')

# 查找元素（语法与浏览器模式一致！）
items = page.eles('tag:h3')
for item in items:
 print(item.text, item.link)

5.2 POST 请求

from DrissionPage import SessionPage

page = SessionPage()

# form 表单
page.post('https://example.com/login', data={'user': 'admin', 'pass': '123'})

# JSON 数据
page.post('https://api.example.com', json={'name': '张三', 'age': 25})

5.3 SessionPage 配置

page = SessionPage()

# 重试设置
page.set.retry_times(5) # 重试次数
page.set.retry_interval(3) # 重试间隔
page.set.timeout(20) # 超时时间

# Headers
page.set.headers({'User-Agent': 'Mozilla/5.0...'})
page.set.header('Referer', 'https://example.com')

# Cookies
page.set.cookies([{'name': 'a', 'value': '1'}])
page.set.cookies.clear()

# 代理
page.set.proxies(http='127.0.0.1:1080', https='127.0.0.1:1080')

# SSL 验证
page.set.verify(False)

6. 混合模式（d/s 切换）

这是 DrissionPage 最强大的特性——浏览器模式和数据包模式可以互相切换，自动同步 cookies。

from DrissionPage import Chromium

tab = Chromium().latest_tab

# 用浏览器处理登录（d 模式）
tab.get('https://example.com/login')
tab.ele('#username').input('admin')
tab.ele('#password').input('123456\n')
tab.wait.url_change('https://example.com/dashboard')

# 切换到 s 模式爬取数据（速度快）
tab.change_mode()
items = tab.eles('.data-item')
for item in items:
 print(item.text)

# 切换回 d 模式
tab.change_mode('d')

典型场景：

登录验证严格 → 浏览器登录 → 切 s 模式爬数据
页面由 JS 渲染 → d 模式读取 → 转 s 模式分析

7. 元素定位语法（核心亮点）

DrissionPage 的定位语法比 Selenium 简洁得多：

7.1 基本定位

# ID 定位
tab.ele('#username') # id 为 username
tab.ele('#:ser') # id 包含 ser

# Class 定位
tab.ele('.login-btn') # class 为 login-btn
tab.ele('.^login') # class 以 login 开头

# 文本定位（默认模糊匹配）
tab.ele('登录') # 文本包含"登录"
tab.ele('text=登录') # 精确匹配"登录"

# 标签定位
tab.ele('tag:div') # 第一个 div
tab.ele('tag:input@class=form-control') # 配合属性

# CSS 选择器
tab.ele('css:.form-group input')

# XPath
tab.ele('xpath://div[@class="content"]')

7.2 属性定位

# 单属性 @
tab.ele('@id=one') # id 为 one
tab.ele('@name=email') # name 为 email
tab.ele('@placeholder') # 有 placeholder 属性

# 多属性与 @@
tab.ele('@@class=form@@type=text') # class=form 且 type=text

# 多属性或 @|
tab.eles('@|id=btn1@|id=btn2') # id 为 btn1 或 btn2

# 否定 @!
tab.ele('@!type=hidden') # type 不是 hidden

7.3 匹配模式

符号	含义	示例
`=`	精确匹配	`@id=row1`
`:`	包含	`@id:ow`
`^`	开头	`@id^row`
`$`	结尾	`@id$w1`

7.4 Selenium 对比

# 查找文本包含 'abc' 的元素
# DrissionPage
ele = tab('abc')
# Selenium
ele = driver.find_element(By.XPATH, '//*[contains(text(), "abc")]')

# 获取兄弟元素
# DrissionPage
ele1 = ele.next()
ele2 = ele.prev(index=2)
# Selenium
ele1 = ele.find_element(By.XPATH, './/following-sibling::*')

8. 元素操作

8.1 点击

ele.click() # 左键点击
ele.click(by_js=True) # JS 点击（无视遮挡）
ele.click(by_js=None) # 智能模式
ele.click.right() # 右键
ele.click.middle() # 中键（返回新 Tab）
ele.click.multi(times=2) # 双击
ele.click.at(50, -50) # 带偏移点击
ele.click.for_new_tab() # 点击并获取新标签页

8.2 输入

ele.input('Hello') # 输入文本
ele.input('Hello\n') # 输入并回车
ele.input('new', clear=True) # 先清空再输入
ele.clear() # 清空

# 组合键
from DrissionPage.common import Keys
ele.input(Keys.CTRL_A) # 全选
ele.input(Keys.CTRL_C) # 复制
ele.input((Keys.CTRL, 'a', Keys.DEL)) # Ctrl+A+Del

8.3 其他操作

ele.hover() # 悬停
ele.drag(50, 50) # 拖拽到相对位置
ele.drag_to(ele2) # 拖拽到另一个元素

# 修改元素
ele.set.innerHTML('<p>new</p>')
ele.set.property('value', 'new value')
ele.set.style('color', 'red')
ele.set.attr('data-id', '123')

# 获取信息
ele.text # 文本
ele.inner_html # 内部 HTML
ele.link # href/src
ele.tag # 标签名
ele.attr('href') # 属性
ele.css('color') # 样式值

9. 等待与重试

DrissionPage 内置智能等待，无需 sleep()：

# 等待元素加载
tab.wait.eles_loaded('#dynamic-div', timeout=10)

# 等待元素显示
tab.wait.ele_displayed('#modal')

# 等待元素隐藏
tab.wait.ele_hidden('#loading')

# 等待元素删除
tab.wait.ele_deleted('#temp')

# 等待 URL 变化
tab.wait.url_change('https://example.com/dashboard')

# 等待 title 变化
tab.wait.title_change('登录成功')

# 等待新标签页
browser.wait.new_tab()

# 等待下载开始
mission = tab('#download-btn').click()
mission = tab.wait.download_begin()

# 等待下载完成
browser.wait.downloads_done(timeout=60)

# ele() 自动重试（默认超时 10 秒）
ele = tab.ele('#dynamic-element', timeout=5)

10. 标签页管理

from DrissionPage import Chromium

browser = Chromium()

# 获取标签页
tab = browser.latest_tab # 最后激活的
tab1 = browser.get_tab(1) # 按序号
tab2 = browser.get_tab(url='example') # 按 URL

# 新建标签页
browser.new_tab('https://example.com')

# 点击后获取新标签页
new_tab = link.click.for_new_tab()
new_tab.wait.load_start()
print(new_tab.title)
new_tab.close()

# 多标签页协同
links = tab.eles('tag:a')
for link in links:
 new_tab = link.click.for_new_tab()
 new_tab.wait.load_start()
 print(new_tab.title)
 new_tab.close()

11. 截图与录像

# 整页截图
tab.get_screenshot(path='screenshots', name='full.png', full_page=True)

# 截取指定区域
tab.get_screenshot(path='tmp', name='part.png',
 left_top=(0, 0), right_bottom=(800, 600))

# 元素截图
header = tab.ele('tag:header')
header.get_screenshot()

# 返回字节/base64
img_bytes = tab.get_screenshot(as_bytes='png')
img_b64 = tab.get_screenshot(as_base64='png')

# 页面录像
tab.screencast.set_save_path('video')
tab.screencast.set_mode.video_mode()
tab.screencast.start()
# ... 操作 ...
path = tab.screencast.stop()

12. 实战示例

12.1 自动登录

from DrissionPage import Chromium

tab = Chromium().latest_tab
tab.get('https://gitee.com/login')

tab.ele('#user_login').input('your_account')
tab.ele('#user_password').input('your_password')
tab.ele('@value=登 录').click()

tab.wait.url_change('https://gitee.com/dashboard')
print('登录成功！')

12.2 数据采集（s 模式）

from DrissionPage import SessionPage

page = SessionPage()

for i in range(1, 4):
 page.get(f'https://example.com/list?page={i}')
 items = page.eles('.item-title')
 for item in items:
 print(item.text, item.link)

12.3 登录后切换模式爬取

from DrissionPage import Chromium

tab = Chromium().latest_tab

# 浏览器登录
tab.get('https://example.com/login')
tab.ele('#username').input('admin')
tab.ele('#password').input('123456\n')
tab.wait.url_change('https://example.com/home')

# 切换到 s 模式快速爬取
tab.change_mode()
data = tab.eles('.data-row')
for row in data:
 print(row.text)

12.4 表单填写与文件上传

from DrissionPage import Chromium

tab = Chromium().latest_tab
tab.get('https://example.com/form')

# 填写表单
tab.ele('#name').input('张三')
tab.ele('#email').input('test@example.com')

# 选择下拉框
tab.ele('#city').click()
tab.ele('text=北京').click()

# 上传文件
tab.ele('#file-input').click.to_upload('/path/to/file.pdf')

# 提交
tab.ele('@type=submit').click()

12.5 文件下载

from DrissionPage import Chromium

tab = Chromium().latest_tab
tab.get('https://example.com/download')

# 点击下载
mission = tab('#download-btn').click.to_download(save_path='downloads')

# 等待下载完成
tab.wait.downloads_done(timeout=120)

13. 与 Selenium/Playwright 对比

特性	DrissionPage	Selenium	Playwright
驱动	自研内核	基于 webdriver	自研协议
驱动安装	❌ 不需要	✅ 需要	✅ 需要
速度	⚡ 快	🐌 较慢	⚡ 快
跨 iframe	✅ 直接查找	❌ 需 switch_to	✅ 支持
多标签页	✅ 同时操作	❌ 需 switch_to	✅ 支持
数据包模式	✅ 内置 requests	❌ 不支持	❌ 不支持
模式切换	✅ d/s 互切	❌ 不支持	❌ 不支持
定位语法	✅ 极简	❌ 较繁琐	⚡ 较简洁
自动等待	✅ 内置	❌ 需 WebDriverWait	✅ 内置
整页截图	✅ 支持	❌ 只截视口	✅ 支持
shadow-root	✅ 支持	❌ 部分支持	✅ 支持
配置管理	✅ ini 文件	❌ 代码配置	❌ 代码配置
浏览器复用	✅ 支持	⚡ 需特殊配置	❌ 不支持
学习曲线	⭐ 简单	⭐⭐ 中等	⭐⭐ 中等

14. 定位语法速查表

语法	说明	示例
`#id`	匹配 id	`tab.ele('#one')`
`.class`	匹配 class	`tab.ele('.p_cls')`
`text`	模糊匹配文本	`tab.ele('登录')`
`text=xxx`	精确匹配文本	`tab.ele('text=登录')`
`tag:xxx`	匹配标签	`tab.ele('tag:div')`
`css:xxx`	CSS 选择器	`tab.ele('css:.cls')`
`xpath:xxx`	XPath	`tab.ele('xpath://div')`
`@attr=val`	单属性匹配	`tab.ele('@id=one')`
`@@a=1@@b=2`	多属性与	`tab.ele('@@class=c@@text()=x')`
`@	a=1@	b=2`
`@!attr=val`	否定匹配	`tab.ele('@!id=one')`

总结

DrissionPage 核心优势：

无需驱动 — 自研内核，不依赖 webdriver
双模式合一 — 浏览器 + 数据包，一键切换
极简语法 — #id、.class、text 比 Selenium 简洁 10 倍
内置等待 — 自动重试，无需 sleep
跨 iframe — 直接查找，无需 switch_to
配置持久化 — ini 文件保存，自动加载

如果你厌倦了 Selenium 的繁琐配置和慢速度，DrissionPage 是绝佳的替代方案。

验证来源：DrissionPage 官方文档 (https://www.drissionpage.cn)

Python 零基础入门教程：从环境搭建到实战项目

Thu, 25 Jun 2026 19:00:00 +0000

前言

Python 是当前最流行的编程语言之一，以简洁易读的语法著称。无论你是想做 Web 开发、数据分析、人工智能，还是自动化脚本，Python 都是绝佳的起点。本文从零基础出发，带你系统学习 Python。

1. Python 简介

1.1 为什么要学 Python

优势	说明
简单易学	语法接近自然语言，新手友好
应用广泛	Web/AI/数据/运维/爬虫/自动化
生态丰富	50 万+ 第三方包（PyPI）
就业面广	数据科学、后端开发、AI 工程师
社区活跃	遇到问题容易找到解决方案

1.2 应用领域

Web 开发 — Django、Flask、FastAPI
人工智能 — TensorFlow、PyTorch、scikit-learn
数据分析 — Pandas、NumPy、Matplotlib
网络爬虫 — Scrapy、BeautifulSoup、Selenium
自动化运维 — Ansible、Fabric
桌面应用 — PyQt、Tkinter

2. 环境搭建

2.1 安装 Python

# Windows：访问 python.org 下载，务必勾选 "Add Python to PATH"
# macOS：
brew install python

# Linux (Ubuntu/Debian)：
sudo apt update && sudo apt install python3 python3-pip python3-venv

# 验证安装
python3 --version

2.2 pip 包管理

# 安装包
pip install requests
pip install numpy pandas

# 指定版本
pip install requests==2.31.0

# 升级/卸载
pip install --upgrade requests
pip uninstall requests

# 查看已安装
pip list

# 导出/导入依赖
pip freeze > requirements.txt
pip install -r requirements.txt

# 使用国内镜像加速
pip install -i https://pypi.tuna.tsinghua.edu.cn/simple requests
pip config set global.index-url https://pypi.tuna.tsinghua.edu.cn/simple

2.3 虚拟环境

# 创建虚拟环境
python3 -m venv myenv

# 激活
# Windows: myenv\Scripts\activate
# macOS/Linux: source myenv/bin/activate

# 退出
deactivate

2.4 IDE 推荐

IDE	特点	推荐度
VS Code	轻量、免费、扩展丰富	⭐⭐⭐⭐⭐
PyCharm	功能强大、自带调试	⭐⭐⭐⭐⭐
Jupyter Notebook	交互式、适合数据分析	⭐⭐⭐⭐
IDLE	Python 自带、最简单	⭐⭐⭐

3. 基础语法

3.1 注释与输出

# 单行注释
print("Hello, Python!") # 行尾注释

"""
多行注释
也可以用三个双引号
"""

# 输出
print("Hello")
print("姓名:", "张三", "年龄:", 25)
print(f"我叫张三，今年{25}岁") # f-string 格式化

3.2 变量与数据类型

# 变量不需要声明类型，直接赋值
name = "张三" # str 字符串
age = 25 # int 整数
height = 175.5 # float 浮点数
is_student = True # bool 布尔值
score = None # NoneType 空值

# 查看类型
print(type(name)) # <class 'str'>
print(type(age)) # <class 'int'>

# 多重赋值
a, b, c = 1, 2, 3
x = y = z = 0

3.3 类型转换

# 转整数
int("123") # 123
int(3.9) # 3（截断小数）

# 转浮点数
float("3.14") # 3.14
float(100) # 100.0

# 转字符串
str(123) # "123"
str(3.14) # "3.14"

# 转布尔值
bool(0) # False
bool("") # False
bool(None) # False
bool(1) # True
bool("hello") # True

4. 运算符

# 算术运算符
10 + 3 # 13 加
10 - 3 # 7 减
10 * 3 # 30 乘
10 / 3 # 3.33 除
10 // 3 # 3 整除
10 % 3 # 1 取余
10 ** 3 # 1000 幂

# 比较运算符
5 == 5 # True 等于
5 != 3 # True 不等于
5 > 3 # True 大于
5 < 3 # False 小于
5 >= 5 # True 大于等于

# 逻辑运算符
True and False # False 与
True or False # True 或
not True # False 非

# 成员运算符
"hello" in "hello world" # True
3 in [1, 2, 3] # True

5. 控制流

5.1 条件判断

age = 18

if age >= 18:
 print("成年人")
elif age >= 12:
 print("青少年")
else:
 print("儿童")

# 三元表达式
status = "成年" if age >= 18 else "未成年"

5.2 match/case（Python 3.10+）

command = "start"

match command:
 case "start":
 print("启动服务")
 case "stop":
 print("停止服务")
 case "restart":
 print("重启服务")
 case _:
 print("未知命令")

5.3 for 循环

# 遍历列表
fruits = ["苹果", "香蕉", "橘子"]
for fruit in fruits:
 print(fruit)

# range 生成数字序列
for i in range(5): # 0, 1, 2, 3, 4
 print(i)

for i in range(1, 11): # 1 到 10
 print(i)

for i in range(0, 20, 3): # 0, 3, 6, 9, 12, 15, 18
 print(i)

# 带索引遍历
for i, fruit in enumerate(fruits):
 print(f"{i}: {fruit}")

5.4 while 循环

count = 0
while count < 5:
 print(count)
 count += 1

# break 跳出循环
while True:
 user_input = input("输入 quit 退出: ")
 if user_input == "quit":
 break

# continue 跳过本次
for i in range(10):
 if i % 2 == 0:
 continue # 跳过偶数
 print(i)

6. 数据结构

6.1 列表（List）

# 创建列表
fruits = ["苹果", "香蕉", "橘子"]
numbers = [1, 2, 3, 4, 5]
mixed = [1, "hello", True, 3.14]

# 访问元素
fruits[0] # "苹果"（第一个）
fruits[-1] # "橘子"（最后一个）
fruits[1:3] # ["香蕉", "橘子"]（切片）

# 常用方法
fruits.append("葡萄") # 末尾添加
fruits.insert(1, "西瓜") # 指定位置插入
fruits.remove("香蕉") # 删除指定元素
fruits.pop() # 删除末尾元素
fruits.pop(0) # 删除指定位置
fruits.sort() # 排序
fruits.reverse() # 反转
len(fruits) # 长度
"苹果" in fruits # True（是否包含）

# 列表推导式
squares = [x**2 for x in range(10)] # [0, 1, 4, 9, ...]
evens = [x for x in range(20) if x % 2 == 0] # [0, 2, 4, 6, ...]

6.2 字典（Dictionary）

# 创建字典
person = {
 "name": "张三",
 "age": 25,
 "city": "北京"
}

# 访问
person["name"] # "张三"
person.get("email", "无") # "无"（key 不存在返回默认值）

# 操作
person["email"] = "zs@example.com" # 添加/修改
del person["city"] # 删除
person.pop("age") # 删除并返回

# 遍历
for key in person:
 print(key, person[key])

for key, value in person.items():
 print(f"{key}: {value}")

# 字典推导式
squares = {x: x**2 for x in range(6)}
# {0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

6.3 元组（Tuple）

# 元组不可修改
point = (10, 20)
x, y = point # 解包
single = (1,) # 单元素元组要加逗号

6.4 集合（Set）

# 集合自动去重
nums = {1, 2, 2, 3, 3, 3} # {1, 2, 3}

# 集合运算
a = {1, 2, 3}
b = {3, 4, 5}
a | b # {1, 2, 3, 4, 5} 并集
a & b # {3} 交集
a - b # {1, 2} 差集

7. 函数

# 定义函数
def greet(name):
 """打招呼（这是文档字符串）"""
 return f"你好, {name}!"

print(greet("张三"))

# 默认参数
def power(base, exp=2):
 return base ** exp

power(3) # 9
power(3, 3) # 27

# 可变参数
def calc_sum(*args):
 return sum(args)

calc_sum(1, 2, 3, 4) # 10

# 关键字可变参数
def print_info(**kwargs):
 for key, value in kwargs.items():
 print(f"{key}: {value}")

print_info(name="张三", age=25)

# Lambda 匿名函数
add = lambda x, y: x + y
add(3, 5) # 8

# 常与 map/filter/sorted 配合
numbers = [1, 2, 3, 4, 5]
squared = list(map(lambda x: x**2, numbers)) # [1, 4, 9, 16, 25]
evens = list(filter(lambda x: x % 2 == 0, numbers)) # [2, 4]

8. 字符串操作

s = "Hello, World!"

# 常用方法
s.lower() # "hello, world!"
s.upper() # "HELLO, WORLD!"
s.strip() # 去除首尾空格
s.replace("World", "Python") # "Hello, Python!"
s.split(", ") # ["Hello", "World!"]
",".join(["a", "b"]) # "a,b"
s.find("World") # 7（位置）
s.count("l") # 3
s.startswith("Hello") # True
s.endswith("!") # True

# f-string 格式化（推荐）
name = "张三"
age = 25
print(f"我叫{name}，今年{age}岁")
print(f"圆周率: {3.14159:.2f}") # 3.14
print(f"百分比: {0.856:.1%}") # 85.6%
print(f"补零: {42:05d}") # 00042

9. 文件操作

# 读取文件（推荐用 with）
with open("data.txt", "r", encoding="utf-8") as f:
 content = f.read() # 读全部
 # lines = f.readlines() # 读所有行
 # for line in f: # 逐行读
 # print(line.strip())

# 写入文件
with open("output.txt", "w", encoding="utf-8") as f:
 f.write("第一行\n")
 f.write("第二行\n")

# 追加写入
with open("output.txt", "a", encoding="utf-8") as f:
 f.write("追加内容\n")

# JSON 操作
import json

data = {"name": "张三", "age": 25}
with open("data.json", "w", encoding="utf-8") as f:
 json.dump(data, f, ensure_ascii=False, indent=2)

with open("data.json", "r", encoding="utf-8") as f:
 loaded = json.load(f)

# CSV 操作
import csv

with open("data.csv", "w", newline="", encoding="utf-8") as f:
 writer = csv.writer(f)
 writer.writerow(["姓名", "年龄"])
 writer.writerow(["张三", 25])

with open("data.csv", "r", encoding="utf-8") as f:
 reader = csv.reader(f)
 for row in reader:
 print(row)

10. 错误处理

try:
 result = 10 / 0
except ZeroDivisionError:
 print("不能除以零")
except (ValueError, TypeError) as e:
 print(f"错误: {e}")
else:
 print("没有异常时执行")
finally:
 print("总是执行")

# 自定义异常
class MyError(Exception):
 pass

raise MyError("自定义错误")

11. 模块和包

# 导入模块
import os
import json
from datetime import datetime
from pathlib import Path as P

# 常用标准库
os.getcwd() # 当前工作目录
os.listdir(".") # 列出目录内容
os.path.exists("file.txt") # 文件是否存在
Path("data").mkdir(exist_ok=True) # 创建目录

datetime.now() # 当前时间
datetime.now().strftime("%Y-%m-%d %H:%M:%S") # 格式化时间

# 安装第三方包
# pip install requests
import requests
resp = requests.get("https://api.example.com")
print(resp.json())

12. 面向对象编程

class Dog:
 # 类变量
 species = "犬科"

 # 构造方法
 def __init__(self, name, age):
 self.name = name # 实例变量
 self.age = age

 # 实例方法
 def bark(self):
 return f"{self.name}: 汪汪！"

 # 字符串表示
 def __str__(self):
 return f"Dog(name={self.name}, age={self.age})"

# 创建对象
dog = Dog("旺财", 3)
print(dog.name) # 旺财
print(dog.bark()) # 旺财: 汪汪！
print(dog) # Dog(name=旺财, age=3)

# 继承
class Puppy(Dog):
 def __init__(self, name):
 super().__init__(name, 0)

 def play(self):
 return f"{self.name} 在玩耍"

puppy = Puppy("小白")
print(puppy.bark()) # 小白: 汪汪！（继承自 Dog）
print(puppy.play()) # 小白 在玩耍

# 属性装饰器
class Circle:
 def __init__(self, radius):
 self._radius = radius

 @property
 def radius(self):
 return self._radius

 @radius.setter
 def radius(self, value):
 if value < 0:
 raise ValueError("半径不能为负")
 self._radius = value

 @property
 def area(self):
 return 3.14159 * self._radius ** 2

13. 常用标准库

# os - 操作系统接口
import os
os.getcwd() # 当前目录
os.listdir(".") # 列出文件
os.makedirs("a/b/c", exist_ok=True) # 创建多级目录
os.environ.get("HOME") # 环境变量

# pathlib - 现代路径操作（推荐）
from pathlib import Path
Path("data").mkdir(exist_ok=True)
Path("file.txt").write_text("hello")
content = Path("file.txt").read_text()

# datetime - 日期时间
from datetime import datetime, timedelta
now = datetime.now()
tomorrow = now + timedelta(days=1)
formatted = now.strftime("%Y-%m-%d %H:%M:%S")

# re - 正则表达式
import re
text = "我的手机号是 13812345678"
phone = re.search(r"1[3-9]\d{9}", text)
if phone:
 print(phone.group()) # 13812345678

# collections - 增强数据结构
from collections import Counter, defaultdict
words = ["a", "b", "a", "c", "b", "a"]
counter = Counter(words) # Counter({'a': 3, 'b': 2, 'c': 1})
counter.most_common(2) # [('a', 3), ('b', 2)]

14. 实战项目

14.1 计算器

def calculator():
 """简单计算器"""
 while True:
 expr = input("输入表达式（如 1 + 2，输入 q 退出）: ")
 if expr.lower() == "q":
 break
 try:
 result = eval(expr)
 print(f"结果: {result}")
 except Exception as e:
 print(f"错误: {e}")

calculator()

14.2 待办事项

import json
from pathlib import Path

TODO_FILE = "todos.json"

def load_todos():
 if Path(TODO_FILE).exists():
 return json.loads(Path(TODO_FILE).read_text(encoding="utf-8"))
 return []

def save_todos(todos):
 Path(TODO_FILE).write_text(json.dumps(todos, ensure_ascii=False, indent=2), encoding="utf-8")

def main():
 todos = load_todos()
 while True:
 print("\n1.查看 2.添加 3.完成 4.退出")
 choice = input("选择: ")
 if choice == "1":
 for i, t in enumerate(todos):
 status = "✅" if t["done"] else "❌"
 print(f"{i+1}. {status} {t['task']}")
 elif choice == "2":
 task = input("输入任务: ")
 todos.append({"task": task, "done": False})
 save_todos(todos)
 elif choice == "3":
 idx = int(input("完成第几个: ")) - 1
 todos[idx]["done"] = True
 save_todos(todos)
 elif choice == "4":
 break

main()

14.3 文件整理器

import os
import shutil
from pathlib import Path

def organize_files(directory):
 """按文件类型自动整理文件"""
 file_types = {
 "图片": [".jpg", ".jpeg", ".png", ".gif", ".bmp", ".webp"],
 "文档": [".pdf", ".doc", ".docx", ".txt", ".md"],
 "视频": [".mp4", ".avi", ".mkv", ".mov"],
 "音频": [".mp3", ".wav", ".flac"],
 "压缩包": [".zip", ".rar", ".7z", ".tar", ".gz"],
 "代码": [".py", ".js", ".java", ".go", ".html", ".css"],
 }

 for filename in os.listdir(directory):
 filepath = os.path.join(directory, filename)
 if os.path.isfile(filepath):
 ext = Path(filename).suffix.lower()
 for folder, extensions in file_types.items():
 if ext in extensions:
 dest_dir = os.path.join(directory, folder)
 os.makedirs(dest_dir, exist_ok=True)
 shutil.move(filepath, os.path.join(dest_dir, filename))
 print(f"移动: {filename} -> {folder}/")
 break

organize_files("./downloads")

15. 学习路线

阶段	内容	时间
入门	基础语法、数据类型、控制流、函数	1-2 周
进阶	OOP、文件操作、异常、模块	1-2 周
实战	标准库、第三方包、小项目	2-4 周
专精	Web/数据/AI 方向深入	持续学习

总结

Python 核心知识点：

基础语法 — 变量、数据类型、运算符、控制流
数据结构 — 列表、字典、元组、集合、推导式
函数 — def、参数、lambda、作用域
文件操作 — open、with、JSON、CSV
错误处理 — try/except/finally
面向对象 — class、继承、property
标准库 — os、datetime、re、collections、pathlib

Python 入门门槛低，但功能强大。掌握基础后，选择一个方向（Web/数据/AI）深入学习，就能用 Python 解决实际问题。

验证来源：菜鸟教程(runoob.com)、Python 官方文档