1. 从零开始:为什么我们需要自己动手抓取百度搜索结果?
最近有个朋友找我帮忙,他的工作内容里有一项特别耗时:每天需要手动在百度上搜索某个行业的关键词,然后一个个点开搜索结果,把有用的标题、链接和简介信息复制粘贴到Excel表格里。他抱怨说,这活儿不仅枯燥,还特别容易出错,有时候复制漏了,有时候格式乱了,一上午也整理不了多少。他问我:“你不是搞技术的吗?能不能写个小程序,让它自动帮我搜,然后把结果整整齐齐地存到表格里?”
这其实就是个典型的办公自动化需求,也是很多非技术岗位同事会遇到的痛点。手动操作效率低下,重复劳动价值不高。而用Python写一个网络爬虫,就能完美解决这个问题。你可能一听“爬虫”、“抓取”就觉得是黑客干的事儿,很高深。其实不然,它更像是一个自动化的“复制粘贴小助手”,帮你从网页上批量读取公开信息,然后规整地保存下来。
这次,我们就聚焦于用Python来实现这个“小助手”。市面上解析网页的库很多,我们选择两个最主流、也最有代表性的:lxml和BeautifulSoup。我会带你从头到尾走一遍,不仅告诉你怎么做,还会对比这两个库在实际使用中的不同体验,比如哪个写起来更顺手,哪个处理某些页面结构更稳定。最终,我们会把抓取到的标题、链接、摘要、来源这四样信息,干干净净地存进一个Excel文件(.xlsx格式),让你的朋友或者你自己,能直接打开就用。
所以,无论你是想提升办公效率的职场人,还是刚入门Python想找个有趣项目练手的学习者,这篇文章都适合你。我们不讲复杂晦涩的理论,就聊怎么一步步把想法变成可运行的代码。
2. 战前准备:搭建你的Python爬虫工作台
工欲善其事,必先利其器。在开始写代码之前,我们需要把“厨房”收拾好,把必要的“食材”和“厨具”备齐。别担心,这个过程非常简单,就像安装手机APP一样。
2.1 安装Python与必备库
首先,确保你的电脑上已经安装了Python。打开命令行(Windows上是CMD或PowerShell,Mac/Linux上是终端),输入 python --version 或 python3 --version。如果能看到类似 Python 3.8.10 的版本号,那就恭喜你,第一步已经完成了。如果没有,你需要去Python官网下载并安装最新版本,记得安装时勾选“Add Python to PATH”这个选项。
接下来,我们需要安装四个核心的Python库。你可以把它们理解为四个功能各异的工具:
- requests: 这是我们的“网络信使”。它的工作就是模拟浏览器,向百度服务器发送搜索请求,并把服务器返回的网页内容(HTML代码)带回来给我们。没有它,我们连网页都拿不到。
- lxml: 这是一个解析HTML/XML文档的“瑞士军刀”,特点是速度快、功能强大。它使用XPath语法来定位和提取数据,有点像在文件系统里用路径找文件,非常精准。
- BeautifulSoup: 这是另一个解析库,我们可以叫它“温柔的解码器”。它的语法更接近自然语言,对新手非常友好,容错性也更好一些,即使网页HTML写得不太规范,它也能尽力去解析。
- xlsxwriter: 这是我们的“表格生成器”。负责把抓取到的结构化数据,写入到Excel文件中,生成整洁的.xlsx格式表格。
安装它们只需要一行命令。在命令行中,输入以下内容并回车:
pip install requests lxml beautifulsoup4 xlsxwriter
如果速度慢,可以考虑使用国内的镜像源,比如清华的源:
pip install requests lxml beautifulsoup4 xlsxwriter -i https://pypi.tuna.tsinghua.edu.cn/simple
看到“Successfully installed”的字样,就说明所有工具都备齐了。
2.2 理解我们要抓取的“战场”:百度搜索结果页结构
在写代码之前,我们得先搞清楚我们要从哪儿抓数据。打开浏览器,访问百度,随便搜索一个词,比如“Python教程”。按下F12键,打开“开发者工具”。
这个工具是爬虫工程师的“望远镜”,能让我们看到网页华丽外表下的“骨架”——HTML代码。点击开发者工具左上角那个箭头图标(或者按Ctrl+Shift+C),然后用鼠标去点击网页上的一个搜索结果条目。你会发现,代码区域会自动高亮显示对应的一段HTML。
多观察几个结果,你会发现规律:百度每一个普通的网页搜索结果,通常都被包裹在一个 <div class="c-container"> 的标签里。这个div就像一个集装箱,里面装着这个结果的所有信息:标题(在<h3>标签下的<a>链接里)、链接(就是那个<a>标签的href属性)、摘要(分散在多个<span>标签里)、来源(通常在某个特定的<span>里)。
理解这个结构至关重要。我们的爬虫逻辑就是:1. 让requests库把整个搜索结果页的HTML“搬”回来。2. 用lxml或BeautifulSoup在这个HTML里,找到所有 class="c-container" 的“集装箱”。3. 挨个打开这些集装箱,把里面的标题、链接、摘要、来源这四样东西拿出来。4. 整理好,交给xlsxwriter存进Excel。
另外,注意看搜索结果页的底部,有分页栏“1 2 3 4 5 ... 下一页”。百度搜索的翻页规律很简单:每页显示10个结果。第一页的网址参数是 pn=0,第二页是 pn=10,第三页是 pn=20,以此类推。这意味着,我们要抓取多页结果,只需要用一个循环,不断改变这个 pn 参数的值去请求就可以了。整个“战场”的地图,我们现在已经了然于胸。
3. 利剑出鞘:使用lxml与XPath进行精准抓取
lxml库配合XPath语法,就像一把锋利的手术刀,可以非常精确地从HTML文档中切取出我们需要的部分。它的效率很高,尤其适合处理大型或结构清晰的文档。我们来一步步看看怎么用它。
3.1 构建请求与获取网页
首先,我们用requests库来模拟一次百度搜索。这里有个小技巧,直接访问 https://www.baidu.com/s?wd=关键词 是可以的,但为了更像真实的浏览器,减少被网站拒绝的可能,我们最好加上一个请求头(headers),特别是 User-Agent,用来告诉服务器我们是什么类型的浏览器。
import requests
from lxml import etree
def get_page_with_lxml(keyword, page_num):
"""使用lxml方案获取百度搜索结果页"""
url = 'https://www.baidu.com/s'
# 伪装成浏览器
headers = {
'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36'
}
# 参数:wd是关键词,pn是页数偏移(第1页=0,第2页=10...)
params = {
'wd': keyword,
'pn': (page_num - 1) * 10 # 将我们习惯的页码转换为百度参数
}
# 发送GET请求
response = requests.get(url, headers=headers, params=params)
response.encoding = 'utf-8' # 确保中文正常显示
return response.text # 返回网页的HTML文本内容
这个函数接收两个参数:要搜索的关键词和想要的页码(比如第1页)。它构造一个看起来像来自Chrome浏览器的请求,发送给百度,然后返回网页的HTML代码。你可以把它想象成你手动在浏览器地址栏输入网址并回车后,看到的那个“查看网页源代码”里的全部内容。
3.2 使用XPath解析与提取数据
拿到HTML“矿藏”后,就要用lxml的etree和XPath这把“矿镐”来挖宝了。XPath是一种在XML/HTML文档中查找信息的语言,它通过路径表达式来选取节点。
def parse_page_with_lxml(html_content):
"""解析HTML,提取标题、链接、摘要、来源"""
html = etree.HTML(html_content) # 将文本转换为lxml可处理的HTML树结构
# 核心:找到所有class='c-container'的div节点,每个节点对应一个搜索结果
result_blocks = html.xpath('//div[contains(@class, "c-container")]')
data_list = []
for block in result_blocks:
# 1. 提取标题:找到当前block下的h3标签里的a标签内的所有文本,拼接起来
title = ''.join(block.xpath('.//h3/a//text()')).strip()
# 2. 提取链接:找到h3下a标签的href属性
link = block.xpath('.//h3/a/@href')
link = link[0] if link else '' # 防止没有链接的情况
# 3. 提取摘要:找到当前block下所有span标签的文本
# 注意:这里会抓到很多零碎的span,包括摘要、时间等,我们先全部拿到
abstract_parts = block.xpath('.//span//text()')
# 将它们用空格拼接成一个完整的摘要字符串
abstract = ' '.join([part.strip() for part in abstract_parts if part.strip()])
# 4. 提取来源:百度来源通常在特定span里,这里用一个更精确的定位
# 通过观察,来源经常在 class 包含 ‘c-color-gray’ 或 ‘c-font-normal’ 的span里
source = block.xpath('.//span[contains(@class, "c-color-gray") or contains(@class, "c-font-normal")]/text()')
source = source[0].strip() if source else '未知来源'
# 将提取到的一条完整数据存入列表
data_list.append([title, link, abstract, source])
# 打印出来看看,方便调试
print(f"标题:{title[:30]}... | 来源:{source}")
print(f"本页共提取到 {len(data_list)} 条结果。")
return data_list
这段代码是核心。html.xpath('//div[contains(@class, "c-container")]') 这行意思是:在整个文档中,查找所有div标签,并且这些标签的class属性值包含“c-container”字符串。contains函数很好用,因为百度的class值有时会有微小变化,比如c-container xpath-log,用contains可以一并抓到。
在循环里,对每一个找到的“集装箱”(block),我们继续用XPath在里面“挖”:
.//h3/a//text(): 在当前block节点下(开头的.很重要),寻找所有h3标签下的a标签下的所有层级的文本,用join拼接成一个字符串。.//h3/a/@href: 获取那个a标签的href属性值,即真实链接。.//span//text(): 获取当前block下所有span标签的文本,这是抓摘要的“土办法”,可能会包含一些无关信息,但能保证拿到主要摘要内容。- 最后一行关于来源的XPath,是我多次测试后总结的相对可靠的写法,它通过
class特征来定位来源信息。
实战踩坑提醒: 我一开始用更简单的//span[@aria-hidden="true"]找来源,发现有时会找不到。后来发现百度的页面结构并非一成不变,用class特征匹配更稳妥。这就是爬虫的常态,你需要根据实际情况调整你的“挖掘”路径。
4. 温柔一刀:使用BeautifulSoup进行灵活解析
如果说lxml是精准的手术刀,那BeautifulSoup就是一把灵活的瑞士军刀中的主刀。它解析语法更直观,容错能力更强,对于HTML编写不规范的情况处理得更好。我们来看看如何用BeautifulSoup实现同样的功能。
4.1 发送请求与解析入门
使用BeautifulSoup发送请求的部分和之前几乎一样,区别在于解析库的导入和使用。
import requests
from bs4 import BeautifulSoup
def get_page_with_bs4(keyword, page_num):
"""使用BeautifulSoup方案获取并解析页面"""
url = f'https://www.baidu.com/s?wd={keyword}&pn={(page_num-1)*10}'
headers = {
'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36'
}
response = requests.get(url, headers=headers)
response.encoding = 'utf-8'
# 关键步骤:使用BeautifulSoup解析返回的HTML,指定解析器为'lxml'(是的,它底层可以用lxml引擎)
soup = BeautifulSoup(response.text, 'html.parser') # 也可以用 'lxml',如果安装了lxml库的话
return soup
这里我们直接构造了完整的URL,并使用html.parser这个Python内置解析器。你也可以安装lxml后使用'lxml'作为解析器,速度会更快。soup对象就是一个已经解析好的、方便我们遍历和搜索的文档树。
4.2 使用find与find_all定位元素
BeautifulSoup主要使用find()和find_all()方法来查找元素,参数可以是标签名、属性字典等,非常直观。
def parse_page_with_bs4(soup):
"""用BeautifulSoup解析并提取数据"""
# 尝试寻找更精确的容器,过滤掉非普通网页结果(如图片、视频合集)
# 通过观察,普通搜索结果通常在 class 为 ‘result c-container new-pmd’ 或 ‘result c-container xpath-log new-pmd’ 的div中
result_blocks1 = soup.find_all('div', class_='result c-container new-pmd')
result_blocks2 = soup.find_all('div', class_='result c-container xpath-log new-pmd')
all_blocks = result_blocks1 + result_blocks2
# 如果上述精确查找没找到,则回退到查找所有‘c-container’
if not all_blocks:
print("未找到精确匹配的容器,回退到查找所有 c-container")
all_blocks = soup.find_all('div', class_='c-container')
data_list = []
for block in all_blocks:
# 1. 提取标题:找到block里的第一个h3标签,获取其文本
title_tag = block.find('h3')
title = title_tag.get_text(strip=True) if title_tag else '无标题'
# 2. 提取链接:找到h3里的a标签,获取href属性
link_tag = block.find('h3').find('a') if title_tag else None
link = link_tag.get('href', '') if link_tag else ''
# 3. 提取摘要:尝试几种常见位置
abstract = ''
# 方法A:查找class包含‘content’或‘abstract’的span
abstract_tag = block.find('span', class_=lambda c: c and ('content' in c or 'abstract' in c or 'c-abstract' in c))
if abstract_tag:
abstract = abstract_tag.get_text(strip=True)
else:
# 方法B:如果找不到特征class,则获取该block下所有span的文本(可能较杂)
all_spans = block.find_all('span')
abstract = ' '.join([span.get_text(strip=True) for span in all_spans if span.get_text(strip=True)])
# 4. 提取来源:查找包含来源信息的div或span
source = '未知来源'
# 常见位置:class包含‘c-color-gray’、‘c-gap-top-xsmall’的div内的a标签或span
source_div = block.find('div', class_=lambda c: c and ('c-color-gray' in c or 'c-gap-top-xsmall' in c))
if source_div:
source_a = source_div.find('a')
if source_a:
source = source_a.get_text(strip=True)
else:
source_span = source_div.find('span')
if source_span:
source = source_span.get_text(strip=True)
data_list.append([title, link, abstract, source])
print(f"标题:{title[:30]}... | 来源:{source}")
print(f"本页共提取到 {len(data_list)} 条结果。")
return data_list
这段代码展示了BeautifulSoup的灵活性。首先,我尝试用更精确的class_='result c-container new-pmd'来查找,这是为了过滤掉那些图片集、视频集等非标准网页结果。在实际测试中,我发现直接抓所有c-container有时会包含这些特殊结果,导致后续提取标题或链接时出错(因为它们的HTML结构不同)。用更精确的类名可以大大提高稳定性,当然代价是可能会漏掉一小部分结果。如果精确查找没找到,代码会回退到查找所有c-container,保证基础功能。
在提取摘要和来源时,我用了更复杂的查找逻辑。例如,用lambda函数对class属性进行模糊匹配(contains),这比写死一个类名更健壮。get_text(strip=True)方法能直接获取标签内所有文本并去掉首尾空白,非常方便。
BeautifulSoup的优缺点体验: 它的语法确实更易读,像block.find('h3')一看就知道是找h3标签。在处理一些“脏”HTML时,它比lxml更不容易报错。但它的查找速度通常比lxml的XPath慢一些,尤其是在处理大量数据时。另外,对于非常复杂的嵌套路径,XPath的表达式可能更简洁有力。
5. 双剑合璧:实现多页抓取与数据存储
无论是用lxml还是BeautifulSoup,单页抓取只是开始。我们还需要循环抓取多页,并把所有数据漂亮地保存起来。
5.1 循环抓取多页结果
逻辑很简单:根据用户输入的想抓取的页数,循环调用我们之前写好的单页抓取函数,并把每一页的结果合并到一个大列表里。
def fetch_multiple_pages(keyword, total_pages, parser_type='lxml'):
"""抓取多页结果
parser_type: 指定使用 'lxml' 或 'bs4' 解析器
"""
all_results = []
for page in range(1, total_pages + 1):
print(f"\n正在抓取第 {page} 页...")
try:
if parser_type == 'lxml':
html = get_page_with_lxml(keyword, page)
page_results = parse_page_with_lxml(html)
elif parser_type == 'bs4':
soup = get_page_with_bs4(keyword, page)
page_results = parse_page_with_bs4(soup)
else:
print("解析器类型错误!请选择 'lxml' 或 'bs4'")
return []
all_results.extend(page_results)
# 出于礼貌,也是为了防止请求过快被限制,每页之间暂停一小会儿
import time
time.sleep(1)
except Exception as e:
print(f"抓取第{page}页时发生错误:{e}")
continue # 跳过错误页,继续抓取下一页
print(f"\n所有页面抓取完成!共获取 {len(all_results)} 条结果。")
return all_results
这个函数增加了一个parser_type参数,让你可以自由选择使用哪套解析方案。循环中加入了try...except来捕获异常,这样即使某一页抓取出错(比如网络问题或页面结构突变),程序也不会完全崩溃,而是跳过该页继续运行。time.sleep(1)是非常重要的一个细节,它让程序在每次请求后休息1秒,这既是对目标网站的尊重,遵守基本的网络礼仪,也能显著降低因请求频率过高而被封IP的风险。
5.2 使用xlsxwriter存储为Excel文件
数据抓到手,存成文件才算大功告成。存为CSV文件虽然简单,但有个致命问题:如果标题或摘要里含有英文逗号“,”,会被错误地识别为列分隔符,导致数据错位。所以,我们选择存为更规范的Excel文件。
import xlsxwriter
def save_to_excel(data, keyword, filename_prefix):
"""将数据保存到Excel文件"""
if not data:
print("没有数据可保存!")
return
# 生成文件名,包含关键词和时间戳,避免重复
import datetime
timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
filename = f"{filename_prefix}_{keyword}_{timestamp}.xlsx"
# 创建一个Excel工作簿和工作表
workbook = xlsxwriter.Workbook(filename)
worksheet = workbook.add_worksheet('百度搜索结果')
# 定义标题行格式(加粗,居中)
header_format = workbook.add_format({'bold': True, 'align': 'center', 'valign': 'vcenter'})
# 定义数据行格式(自动换行,便于阅读长摘要)
cell_format = workbook.add_format({'text_wrap': True})
# 写入标题行
headers = ['序号', '标题', '链接', '内容摘要', '来源']
for col, header in enumerate(headers):
worksheet.write(0, col, header, header_format)
# 写入数据行
for row_idx, row_data in enumerate(data, start=1): # start=1从第2行开始写
# 写入序号
worksheet.write(row_idx, 0, row_idx)
# 写入抓取的数据(标题、链接、摘要、来源)
for col_idx, cell_data in enumerate(row_data, start=1): # 数据从第2列开始
worksheet.write(row_idx, col_idx, cell_data, cell_format)
# 调整列宽,让标题和摘要更易读
worksheet.set_column('A:A', 8) # 序号列
worksheet.set_column('B:B', 40) # 标题列
worksheet.set_column('C:C', 50) # 链接列
worksheet.set_column('D:D', 80) # 摘要列
worksheet.set_column('E:E', 20) # 来源列
workbook.close()
print(f"数据已成功保存到文件:{filename}")
print(f"共保存了 {len(data)} 条记录。")
这段代码不仅完成了基本的存储功能,还做了一些优化:
- 自动生成文件名: 包含了关键词和当前时间戳,这样每次运行都不会覆盖之前的文件。
- 设置单元格格式: 标题行加粗居中,数据行(尤其是摘要)设置自动换行,这样在Excel里打开时,长文本也能完整显示,不会挤在一行。
- 调整列宽: 根据内容预估一个合适的宽度,让表格打开时就很好看,无需手动调整。
现在,我们把所有功能整合到一个主程序里,让用户可以选择使用哪种解析方式:
def main():
print("=== 百度搜索结果抓取工具 ===")
keyword = input("请输入要搜索的关键词:").strip()
try:
pages = int(input("请输入要抓取的页数(每页约10条):").strip())
except ValueError:
print("输入错误,页数应为数字。")
return
print("\n请选择解析方式:")
print("1. 使用 lxml (XPath,速度快,精度高)")
print("2. 使用 BeautifulSoup (语法简单,容错性好)")
choice = input("请输入选项 (1 或 2):").strip()
parser_type = 'lxml' if choice == '1' else 'bs4'
print(f"\n开始使用【{parser_type}】抓取「{keyword}」的前 {pages} 页结果...")
all_data = fetch_multiple_pages(keyword, pages, parser_type)
if all_data:
save_to_excel(all_data, keyword, f'百度搜索_{parser_type}')
print("任务完成!")
else:
print("未能抓取到任何数据。")
if __name__ == '__main__':
main()
6. 实战对比与避坑指南
经过上面的步骤,我们已经拥有了两套可以工作的爬虫代码。在实际使用中,我对比了它们的一些表现,也踩过一些坑,这里分享给你。
6.1 lxml vs. BeautifulSoup:如何选择?
我们可以从几个维度来对比一下,方便你根据实际情况做选择:
| 特性维度 | lxml (with XPath) | BeautifulSoup (with html.parser/lxml) | 个人建议 |
|---|---|---|---|
| 语法与学习曲线 | 需要学习XPath语法,初期有一定门槛,但表达精准。 | 使用find/find_all,更接近自然语言,对新手友好。 | 新手可以从BeautifulSoup入手,容易获得成就感。 |
| 解析速度 | 非常快。底层是C语言实现,处理大量数据时优势明显。 | 相对较慢。特别是使用Python内置的html.parser时。 | 如果需要抓取海量页面(成千上万页),lxml是首选。 |
| 容错性 | 较差。要求HTML格式比较规范,否则解析可能出错。 | 很好。能处理一些残缺、不规范的HTML,鲁棒性强。 | 面对结构混乱或古老的网页,BeautifulSoup更能“扛事”。 |
| 功能灵活性 | XPath功能极其强大,可以进行复杂的层级和属性过滤。 | 查找方法直观,配合过滤器也能完成复杂查找,但复杂路径表达不如XPath简洁。 | 需要写非常复杂的提取规则时,XPath可能更得心应手。 |
| 本次实战体验 | 提取“来源”信息时需要更精细的XPath,但一旦写好就很稳定。 | 通过组合find和lambda函数,能灵活应对页面局部变化,但提取摘要时可能混入无关文本。 | 对于百度这个特定目标,两者都能用。lxml方案代码更简洁,BeautifulSoup方案在过滤非标准结果时逻辑更清晰。 |
我的经验是,对于像百度这样结构相对稳定、性能要求较高的生产环境任务,我会优先选择lxml。它的速度优势在批量任务中非常明显。而对于学习、快速原型搭建,或者处理一些“脏乱差”的旧网站,BeautifulSoup会让你更省心。
6.2 爬虫实践中必须注意的“坑”
写爬虫不只是技术活,更是个细致活。下面这几个坑,我几乎每个都踩过:
- 反爬虫机制: 百度等大型网站都有反爬措施。我们的代码中加了
User-Agentheaders模拟浏览器,是最基础的一步。如果频繁、高速抓取,你可能会遇到请求被拒绝、返回验证码页面,甚至IP被暂时封禁的情况。对策包括:增加请求间隔(time.sleep)、使用代理IP池、模拟更完整的浏览器行为(如携带Cookie)。我们的代码里已经加入了1秒间隔,对于轻度使用足够了。 - 网页结构变动: 这是爬虫最大的敌人。今天还能用的
class="c-container",明天百度前端工程师一改版,可能就变成了class="search-result-container"。你的爬虫就会立刻失效。对策:一是编写代码时尽量使用模糊匹配(如contains(@class, "c-container")或lambda函数),提高容错性;二是关键代码处做好异常处理(try...except),记录日志,方便出错时排查;三是定期检查你的爬虫是否还能正常工作。 - 数据清洗: 我们抓下来的摘要和来源,文本里可能包含大量空白字符(空格、换行、制表符)、不可见的特殊字符或者HTML实体(如
)。代码中我们用了.strip()和get_text(strip=True)做了初步清理。但在更严格的场景下,你可能还需要用正则表达式或者专门的清洗库(如clean-text)来做进一步处理,确保存入Excel的数据是干净、一致的。 - 法律与道德边界: 务必记住,爬虫只能抓取公开的、非敏感的数据。尊重网站的
robots.txt协议(虽然百度对搜索结果的限制相对宽松),不要对网站造成访问压力(所以加了延迟)。绝对不要尝试抓取需要登录才能访问的个人信息、受版权保护的内容,或用于任何商业牟利、恶意攻击等非法用途。技术是把双刃剑,用对地方才能创造价值。
最后,把两套方案的完整代码都运行一遍,分别用它们去抓取“Python入门”这个关键词的前3页结果。你会发现,最终生成的Excel文件内容大体相同,但可能因为两者对结果容器的筛选逻辑略有差异,导致条数有细微差别。这正体现了两种技术路线的不同哲学。你可以根据自己的偏好和项目需求,选择其中一套作为基础,进行修改和强化。爬虫的世界很大,这只是一个起点,希望这个实战案例能帮你打开这扇门,让你有能力去自动化解决更多实际工作中繁琐的信息收集问题。
337



被折叠的 条评论
为什么被折叠?



