一、前言
在 Python 爬虫开发中,我们经常会遇到这样的需求:
- 需要批量采集多个网页的数据;
- 希望同时执行多个采集任务,提高程序运行效率;
- 需要通过代理访问目标网站;
- 希望获取外部命令执行后的结果,并将结果交给 Python 程序处理。
对于这些场景,除了常见的 requests 请求库和 threading 多线程模块之外,Python 还有一个非常实用的标准库:subprocess。
其中,subprocess.Popen() 可以创建和管理子进程,而 stdout 可以帮助我们获取子进程的标准输出结果。
本文通过一个完整的实战案例,介绍如何使用:
subprocess.Popen()创建外部命令进程;stdout获取命令执行结果;threading实现多线程任务调度;- 代理 API 获取 SOCKS5 代理信息;
- 结合 curl 实现多线程网页采集。
通过这个案例,可以进一步理解 Python 如何调用外部程序,以及如何将代理集成到实际的爬虫任务中。
二、认识 subprocess.Popen()
subprocess 是 Python 自带的标准库,主要用于创建和管理子进程。
例如,我们可以通过 Python 调用系统中的 curl、ping、ffmpeg 等命令行工具。
其中,Popen() 是比较灵活的一种调用方式。
基本语法:
import subprocess
process = subprocess.Popen(
["命令", "参数"],
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
text=True
)
stdout, stderr = process.communicate()
print("标准输出:", stdout)
print("错误输出:", stderr)
几个常用参数:
| 参数 | 作用 |
|---|---|
| args | 要执行的命令及参数 |
| stdout | 设置标准输出的处理方式 |
| stderr | 设置错误输出的处理方式 |
| stdin | 设置标准输入 |
| text | 是否以文本形式读取输出 |
| shell | 是否通过系统 Shell 执行命令 |
这里重点关注两个参数:
1. stdout=subprocess.PIPE
表示将子进程的标准输出连接到一个管道,Python 可以读取命令执行后输出的内容。
2. stderr=subprocess.PIPE
表示将子进程的错误输出也连接到管道,方便我们排查命令执行失败的原因。
需要注意:
Popen() 本身不会自动等待命令执行完成。调用 communicate() 后,程序会读取标准输出和错误输出,并等待子进程结束。
因此,Popen() 适合需要更灵活地管理外部进程的场景。
三、准备代理API
在实际爬虫任务中,如果需要使用 SOCKS5 代理,可以通过 API 接口动态获取代理信息。
这里以一个代理 API 接入流程为例。
1. 获取 Token
首先调用登录接口:
https://api.sdbufeng.vip/api/login?username=USERNAME&password=PASSWORD
其中:
- username:账号
- password:密码
接口返回示例:
{
"status": 0,
"data": {
"token": "xxxxxxx"
},
"msg": null
}
判断逻辑:
status == 0:表示登录成功;data.token:获取后续接口需要使用的 Token;msg:接口返回的错误信息。
Python 实现:
import requests
LOGIN_URL = "https://api.sdbufeng.vip/api/login"
def get_token(username, password):
params = {
"username": username,
"password": password
}
response = requests.get(
LOGIN_URL,
params=params,
timeout=15
)
response.raise_for_status()
result = response.json()
if result.get("status") != 0:
raise Exception(
f"登录失败:{result.get('msg')}"
)
token = result.get("data", {
}).get("token")
if not token:
raise Exception("登录成功,但没有获取到 Token")
return token
实际项目中,不建议将账号密码直接写在公开代码里。
可以通过环境变量或配置文件读取,避免账号信息随着代码发布而泄露。
2. 获取 SOCKS5 代理
拿到 Token 后,就可以调用获取代理 的接口:
https://api.sdbufeng.vip/bf/shared/getip?token=TOKEN&proxy_type=socks5&amount=1&expire=1-3
参数说明:
| 参数 | 说明 |
|---|---|
| token | 登录接口获取的 Token |
| proxy_type | 代理类型,这里使用 socks5 |
| amount | 获取代理的数量 |
| expire | 代理有效期参数 |
Python 请求示例:
GET_IP_URL = "https://api.sdbufeng.vip/bf/shared/getip"
def get_proxy(token):
params = {
"token": token,
"proxy_type": "socks5",
"amount": 1,
"expire": "1-3"
}
response = requests.get(
GET_IP_URL,
params=params,
timeout=15
)
response.raise_for_status()
result = response.json()
print("代理接口返回:", result)
return result
这里需要特别注意:
不同代理 API 的返回结构可能不同,例如代理地址、端口、用户名和密码可能放在不同字段中。
因此,第一次接入时,建议先打印接口返回的 JSON,确认真实字段,再进行解析。
假设接口最终提供以下代理信息:
proxy = {
"ip": "127.0.0.1",
"port": 10000,
"username": "test",
"password": "123456"
}
就可以拼接 SOCKS5 代理地址:
proxy_url = (
f"socks5h://{proxy['username']}:"
f"{proxy['password']}@"
f"{proxy['ip']}:{proxy['port']}"
)
如果代理不需要用户名和密码,则可以使用:
proxy_url = f"socks5h://{proxy['ip']}:{proxy['port']}"
其中,socks5h:// 表示域名解析也交由代理端完成。
四、使用 Popen 调用 curl 访问网页
了解了代理 API 的基本调用方式,接下来进入实际采集环节。
我们可以通过 curl 发起网页请求,再利用 Popen() 获取 curl 返回的内容。
首先确保系统已经安装 curl。
可以在终端执行:
curl --version
如果需要使用 SOCKS5 代理,还需要确认当前 curl 版本支持 SOCKS5。
下面编写一个简单的网页采集函数:
import subprocess
def fetch_page(url, proxy_url):
command = [
"curl",
"-L",
"--max-time", "20",
"--proxy", proxy_url,
"-A", "Mozilla/5.0",
url
]
process = subprocess.Popen(
command,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
text=True,
encoding="utf-8",
errors="replace"
)
try:
stdout, stderr = process.communicate(timeout=25)
if process.returncode == 0:
return stdout
print("请求失败:", stderr)
return None
except subprocess.TimeoutExpired:
process.kill()
process.communicate()
print("请求超时:", url)
return None
代码说明:
1. -L
表示允许 curl 跟随 HTTP 重定向。
2. --max-time 20
表示单次请求最长等待 20 秒。
3. --proxy
指定本次请求使用的代理服务器。
4. -A
设置 User-Agent,模拟常见浏览器请求头。
5. stdout=subprocess.PIPE
将 curl 返回的网页内容传递给 Python。
6. communicate()
等待子进程执行完成,并获取标准输出和错误输出。
这里使用列表形式传递命令参数,而不是直接拼接成一整条 Shell 字符串,可以减少特殊字符导致的命令解析问题。
五、使用 stdout 提取网页内容
获取到网页源码之后,就可以交给 Python 进行处理。
例如,我们想简单提取网页的标题:
import re
def extract_title(html):
if not html:
return None
match = re.search(
r"<title[^>]*>(.*?)</title>",
html,
re.I | re.S
)
if match:
return match.group(1).strip()
return "未找到标题"
测试:
url = "https://www.example.com"
html = fetch_page(
url,
"socks5h://127.0.0.1:10000"
)
title = extract_title(html)
print("网页标题:", title)
这里使用正则表达式只是为了演示 stdout 获取网页内容后的处理过程。
如果是正式项目,建议使用 BeautifulSoup、lxml 等 HTML 解析工具,处理复杂网页结构会更加方便。
例如:
pip install beautifulsoup4
使用 BeautifulSoup 提取标题:
from bs4 import BeautifulSoup
def extract_title(html):
soup = BeautifulSoup(html, "html.parser")
if soup.title:
return soup.title.get_text(strip=True)
return "未找到标题"
六、使用 Queue 和 threading 实现多线程采集
如果只有一个网页,单线程执行完全可以满足需求。
但如果需要采集几十个、几百个网页,逐个请求就会产生大量等待时间。
这时可以使用 Python 的 threading 模块实现多线程任务调度。
同时使用 queue.Queue() 管理任务。
1. 为什么需要 Queue?
假设有 10 个网页需要采集。
如果直接使用多线程,每个线程都需要知道自己应该处理哪个网页,任务分配和结果管理会比较麻烦。
使用 Queue 后,可以把所有任务放入队列,由多个线程依次领取任务。
Queue 具有线程安全特性,适合多个线程同时读取任务。
2. 多线程采集代码
import threading
import queue
task_queue = queue.Queue()
urls = [
"https://www.example.com",
"https://www.python.org",
"https://www.wikipedia.org",
"https://www.iana.org",
"https://www.github.com"
]
for url in urls:
task_queue.put(url)
def worker(token):
while True:
try:
url = task_queue.get_nowait()
except queue.Empty:
break
try:
print(
f"[{threading.current_thread().name}] "
f"开始采集:{url}"
)
# 获取代理信息
proxy_data = get_proxy(token)
# 这里需要根据代理 API 的真实 JSON 结构,
# 提取 ip、port、username、password 等字段。
proxy = parse_proxy(proxy_data)
proxy_url = build_proxy_url(proxy)
# 使用 curl 请求网页
html = fetch_page(url, proxy_url)
# 提取网页标题
title = extract_title(html)
print(
f"[{threading.current_thread().name}] "
f"采集结果:{title}"
)
except Exception as e:
print(f"采集异常:{url},原因:{e}")
finally:
task_queue.task_done()
def main():
username = "你的账号"
password = "你的密码"
# 登录一次,获取 Token
token = get_token(username, password)
# 创建 3 个工作线程
threads = []
for i in range(3):
t = threading.Thread(
target=worker,
args=(token,),
name=f"Worker-{i + 1}"
)
threads.append(t)
t.start()
# 等待所有线程执行完成
for t in threads:
t.join()
print("全部采集任务完成!")
if __name__ == "__main__":
main()
上面的代码中,parse_proxy() 和 build_proxy_url() 需要根据实际 API 返回结构实现。
例如,如果接口返回的代理信息已经是:
{
"ip": "127.0.0.1",
"port": 10000,
"username": "test",
"password": "123456"
}
可以这样编写:
def parse_proxy(result):
# 按照实际接口返回结构调整
data = result["data"]
return {
"ip": data["ip"],
"port": data["port"],
"username": data["username"],
"password": data["password"]
}
def build_proxy_url(proxy):
username = proxy.get("username")
password = proxy.get("password")
if username and password:
return (
f"socks5h://{username}:{password}"
f"@{proxy['ip']}:{proxy['port']}"
)
return f"socks5h://{proxy['ip']}:{proxy['port']}"
注意:以上字段路径仅为示例。如果真实接口的代理信息位于其他字段,需要相应修改。
3. 多线程执行流程
整个程序的执行过程可以理解为:
Python 主程序启动
|
v
调用登录接口获取 Token
|
v
创建任务队列 Queue
|
v
将待采集网址放入队列
|
v
创建多个工作线程
|
v
线程从 Queue 获取任务
|
v
调用代理 API 获取 SOCKS5 信息
|
v
Popen 创建 curl 子进程
|
v
curl 通过代理访问目标网页
|
v
stdout 获取网页源码
|
v
Python 解析网页内容
|
v
任务完成,继续领取下一个任务
这里需要区分两个概念:
threading负责多个任务之间的并发调度;subprocess.Popen()负责创建和管理外部命令进程。
二者配合,可以让 Python 程序同时管理多个网页采集任务。
七、实际开发中需要注意的问题
上面的代码主要用于理解技术原理。如果要应用到正式项目中,还需要考虑以下几个方面。
1. 控制线程数量
线程数量并不是越多越好。
线程过多可能造成:
- CPU 和内存资源占用增加;
- 代理 API 请求频率过高;
- 目标网站请求压力增加;
- 子进程数量过多,影响系统稳定性。
建议根据 VPS 配置、代理服务能力和目标网站的访问规则,合理设置并发数量。
2. 处理代理失效问题
代理可能存在连接失败、超时或有效期结束等情况。
建议在程序中增加异常处理机制:
- 请求失败时记录错误日志;
- 对临时网络异常进行有限次数重试;
- 代理不可用时重新获取代理;
- 对连续失败的代理进行标记。
不要无限重试,否则可能造成资源浪费。
3. 注意 Token 的有效期
示例中是在主程序启动时获取一次 Token,再传递给所有工作线程。
如果 Token 存在有效期限制,需要根据接口规则增加刷新机制。
4. 及时回收子进程
使用 Popen() 创建的子进程需要合理管理。
如果程序设置了超时时间,应在超时后终止进程,并通过 communicate() 回收相关输出,避免子进程长期占用系统资源。
5. 做好日志记录
正式项目不建议只使用 print() 输出信息。
可以使用 Python 自带的 logging 模块记录:
- 任务开始时间;
- 目标网址;
- 代理地区或代理标识;
- 请求耗时;
- HTTP 状态码;
- 请求失败原因;
- 任务执行结果。
这样后续排查问题会更加方便。
6. 注意代理账号信息安全
代理账号、密码和 Token 都属于敏感配置信息。
不要直接写入公开代码仓库,也不要将包含认证信息的完整代理地址输出到日志中。
同时,使用代理访问网站时,应遵守目标网站的访问规则及相关法律法规。
八、总结
本文通过一个实际的网页采集案例,介绍了 Python 中几个比较实用的技术点:
| 技术 | 主要作用 |
|---|---|
| subprocess.Popen() | 创建和管理外部子进程 |
| stdout | 获取子进程的标准输出 |
| stderr | 获取子进程的错误输出 |
| communicate() | 读取输出并等待子进程结束 |
| threading | 实现多线程任务调度 |
| queue.Queue() | 在线程之间安全分配任务 |
| curl | 执行 HTTP/HTTPS 请求 |
| SOCKS5 | 为请求提供代理网络出口 |
对于 Python 爬虫开发来说,requests 可以满足大部分常规 HTTP 请求需求,但在需要调用外部命令、复用已有工具或管理独立进程时,subprocess.Popen() 也有很大的应用价值。
当它与多线程、任务队列以及代理 API 结合使用时,就可以构建出一个相对灵活的网页采集程序。
当然,实际开发中还需要根据业务规模,进一步完善异常处理、日志记录、代理可用性检测和并发控制等功能。
掌握这些基础知识之后,就可以根据自己的业务需求,逐步搭建更加稳定、易维护的 Python 数据采集程序。