1. 从“玩”到“学”：为什么我们要爬取4399小游戏

你可能还记得，小时候在电脑课上，趁着老师不注意，偷偷打开浏览器，输入“4399.com”，然后沉浸在《狂扁小朋友》、《森林冰火人》或者《黄金矿工》的快乐里。4399小游戏网站，承载了一代人的童年记忆。但今天，我们不再仅仅是玩家，而是开发者、数据分析师，或者一个对技术充满好奇的学习者。我们想看看，这个庞大的游戏库背后，到底藏着什么秘密。

用Python爬虫来爬取4399小游戏，听起来像是一个技术宅的“怀旧”项目，但它的价值远不止于此。首先，这是一个绝佳的Python网络爬虫实战案例。4399网站结构相对清晰，但又不乏反爬机制（比如动态加载、请求头校验），非常适合用来练习从基础请求到应对中等难度反爬的完整技能链。其次，通过爬取游戏数据，我们可以进行数据分析与可视化，比如分析哪些类型的游戏最受欢迎、游戏发布时间分布、甚至尝试构建一个简单的游戏推荐系统。最后，对于想学习前端或游戏开发的朋友，分析这些经典小游戏的页面结构、资源加载方式，也能获得不少启发。

无论你是刚学完Python基础语法，想找个项目练手的新手，还是有一定经验，想挑战一下数据采集完整流程的开发者，这个项目都能让你有所收获。接下来，我会带你从零开始，一步步构建一个稳定、高效、且遵守规则的4399小游戏爬虫，并分享我在这个过程中踩过的坑和总结的经验。

2. 环境准备与核心工具选型：为什么是它们？

工欲善其事，必先利其器。在开始写代码之前，我们需要搭建好开发环境并选择合适的库。这里的选择并非随意，每一个都有其背后的考量。

2.1 Python环境与必备库

我强烈建议使用Python 3.7及以上版本，因为后续用到的一些库对新版本Python的支持更好。管理Python版本和库，我推荐使用Anaconda或Miniconda来创建独立的虚拟环境，这样可以避免项目间的库版本冲突。

核心库的选择如下：

1. Requests：这是处理HTTP请求的基石库。它简单、优雅，是发起网络请求的首选。相比于Python内置的urllib，Requests的API设计对人类友好得多。
2. BeautifulSoup4 (bs4)：当我们需要从HTML或XML文档中提取数据时，BeautifulSoup是当之无愧的王者。它提供了多种解析器（如lxml,html.parser），能让我们像操作DOM树一样方便地定位和提取标签内容。对于4399这种静态内容为主的网站，它是主力。
3. lxml：这是一个高性能的HTML/XML解析库。虽然BeautifulSoup也可以使用html.parser，但lxml的解析速度要快得多。我们将它作为BeautifulSoup的解析引擎。
4. Pandas：数据处理的瑞士军刀。爬取到的数据（游戏名、链接、分类、浏览量等）通常是结构化的，用Pandas的DataFrame来清洗、整理和保存（到CSV或Excel）再合适不过。
5. Selenium（可选，但建议了解）：4399的部分页面（特别是游戏详情页或某些列表页）可能采用了JavaScript动态加载数据。当简单的Requests+BeautifulSoup组合无法获取到我们想要的内容时，就需要Selenium来模拟浏览器行为，等待JS执行完毕后再获取完整的页面源码。这是一个应对动态网页的“重型武器”。

安装这些库非常简单，在终端或命令行中使用pip即可：

pip install requests beautifulsoup4 lxml pandas # 如果需要Selenium，还需安装浏览器驱动（如ChromeDriver） pip install selenium

2.2 开发工具与辅助技能

• 代码编辑器/IDE：VS Code或PyCharm都是极好的选择。它们有强大的代码提示、调试功能和丰富的插件生态。
• 浏览器开发者工具：这是爬虫工程师的“眼睛”。我们主要使用其中的Network（网络）和Elements（元素）面板。
  • Network面板：用于观察页面加载时发送了哪些HTTP请求，找到真正包含数据的请求（可能是XHR/Fetch请求），并查看其请求头、参数和响应内容。这是破解动态加载的关键。
  • Elements面板：用于查看网页的DOM结构，帮助我们定位想要提取的数据所在的HTML标签和CSS选择器路径。

在开始编码前，还有一件非常重要的事：尊重网站规则。打开4399的robots.txt文件（通常在网站根目录，如https://www.4399.com/robots.txt），查看网站允许或禁止爬虫爬取哪些路径。虽然对于学习项目，我们通常以较低频率访问，但养成查看robots.txt的习惯是专业的表现。此外，我们应在代码中设置合理的请求间隔（如time.sleep(1)），避免对服务器造成压力。

3. 网站结构分析与数据定位策略

在动手写爬虫之前，我们必须像侦探一样，先仔细勘察“现场”——也就是4399网站的页面结构。盲目地写代码只会事倍功半。

3.1 导航与分类页面分析

打开4399首页，我们可以看到顶部有清晰的游戏分类导航，如“动作”、“益智”、“休闲”、“体育”等。点击任何一个分类，会进入该分类的列表页，URL模式通常是https://www.4399.com/flash/类别_数字.htm或类似的格式。列表页是我们爬虫的起点。

以“动作”类游戏为例，我们打开一个列表页，然后按下F12打开开发者工具。

第一步，在Elements面板里分析结构：滚动列表，右键点击一个游戏条目，选择“检查”。你会发现，每个游戏通常被包裹在一个<li>或<div>标签里，里面包含了游戏的缩略图（<img>）、标题（<a>标签内的文本）、以及可能的一些信息（如浏览量、作者）。我们的目标就是提取出每个游戏条目的标题和详情页链接。

第二步，在Network面板里寻找数据源：这是更关键的一步。清空Network记录，然后刷新页面或滚动到底部（如果列表是分页加载的）。观察是否有名为list、page、getGames之类的XHR（Ajax）请求。如果发现这样的请求，并且其响应内容是JSON格式，里面包含了游戏列表信息，那么恭喜你，你找到了更高效、更稳定的数据接口！直接请求这个接口，比解析整个HTML页面要快得多，也更容易。

经过我的实际测试，4399的主列表页目前（请注意，网站结构可能随时间变化）主要还是以静态HTML为主，但部分筛选或排序功能可能会触发Ajax请求。我们首先尝试用静态解析的方式。

3.2 详情页信息提取

获取到游戏详情页的链接后，下一步就是进入详情页提取更丰富的信息，比如游戏描述、玩法介绍、发布日期、浏览量、大小等。

同样，打开一个游戏详情页，使用开发者工具。

• 游戏标题：通常在<h1>标签里。
• 游戏描述：可能在<meta name=”description”>标签的content属性里，也可能在某个<div class=”desc”>里。
• 其他信息：如“游戏大小”、“游戏类型”、“人气”，这些信息通常以键值对的形式排列在一个<ul>或<div>里，我们需要找到包裹它们的公共父元素，然后逐个提取。

这里有一个重要的技巧：使用多种选择器组合。BeautifulSoup支持CSS选择器和类似XPath的方法。对于结构清晰的页面，CSS选择器更直观。例如，如果游戏标题的HTML是<h1 class=”game-title”>黄金矿工</h1>，我们可以用soup.select_one(‘h1.game-title’)来定位。如果结构复杂，可能需要组合使用标签名、类名、ID甚至属性来精确定位。不要害怕在开发者工具里多尝试不同的选择器路径。

3.3 应对动态加载内容

如果我们发现列表是滚动到底部自动加载更多（即“瀑布流”），或者详情页的某些信息（如评论）是点击后才加载的，那么这部分内容很可能通过JavaScript动态加载。

应对策略：

1. 寻找隐藏的API接口：如前所述，在Network面板的XHR/Fetch标签下仔细寻找。找到后，分析其请求URL、参数（Query String Parameters或Form Data）和请求头（Request Headers），特别是Cookie和User-Agent。然后，我们可以用Requests库模拟这个请求来直接获取JSON数据。
2. 使用Selenium：如果找不到清晰的接口，或者接口参数加密复杂，那么使用Selenium是更直接（但更慢）的方法。用Selenium打开页面，等待页面完全加载（可能需要用WebDriverWait等待特定元素出现），然后获取driver.page_source，再交给BeautifulSoup解析。

注意：对于4399这样的网站，优先尝试方法1。Selenium资源消耗大，速度慢，只应作为最后的手段。在我的爬取过程中，主要游戏列表和基本信息通过静态分析即可获得，因此本教程核心将围绕Requests+BeautifulSoup展开，但我会指出哪些环节可能需要考虑动态加载。

4. 爬虫核心代码实现与分步拆解

理论分析完毕，现在进入实战编码环节。我们将把爬虫拆解成几个功能模块，逐个击破。我会详细解释每一行关键代码的意图。

4.1 第一步：构建基础请求与页面解析函数

这是所有爬虫的基石。我们需要一个健壮的函数来发送请求并返回可解析的HTML内容。

import requests from bs4 import BeautifulSoup import time import random def get_page_html(url, headers=None): """ 发送HTTP请求，获取页面HTML内容。 参数: url (str): 目标网页的URL。 headers (dict): 可选的请求头字典。如果为None，使用默认头。 返回: BeautifulSoup对象: 如果请求成功。 None: 如果请求失败。 """ if headers is None: # 一个基本的请求头，模仿浏览器访问。User-Agent是关键。 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' } try: # 添加随机延时，模拟人类操作，避免请求过快 time.sleep(random.uniform(1, 2)) response = requests.get(url, headers=headers, timeout=10) # 检查HTTP状态码，200表示成功 response.raise_for_status() # 通常使用’utf-8‘编码，但有些页面可能是’gbk‘或’gb2312‘，这里先尝试utf-8 response.encoding = 'utf-8' # 使用lxml作为解析器，速度更快 soup = BeautifulSoup(response.text, 'lxml') return soup except requests.exceptions.RequestException as e: print(f"请求失败: {url}, 错误信息: {e}") return None except Exception as e: print(f"解析页面时发生未知错误: {e}") return None # 测试函数 if __name__ == '__main__': test_url = "https://www.4399.com/flash/" soup = get_page_html(test_url) if soup: print("页面标题:", soup.title.string)

代码解释与心得：

• 请求头（Headers）：User-Agent是必须的，它告诉服务器我们是一个“浏览器”在访问。没有它，很可能被直接拒绝。其他如Referer、Accept-Language等，在遇到更严格的反爬时可能需要添加。
• 异常处理：网络请求充满不确定性，必须用try...except包裹。requests.exceptions.RequestException能捕获大多数网络相关错误（超时、连接错误、HTTP错误等）。
• 编码设置：中文网站常见的编码有utf-8和gbk。如果发现爬下来的中文是乱码，可以尝试response.encoding = ‘gbk’或通过response.apparent_encoding让Requests自动判断。
• 延时（time.sleep）：这是最基本的“礼貌爬虫”准则。在循环请求中，一定要加入随机延时，random.uniform(a, b)可以生成一个[a, b)之间的随机浮点数，让请求间隔不那么规律。

4.2 第二步：解析列表页，获取游戏链接与基本信息

假设我们确定了列表页中，每个游戏项的结构。例如，每个游戏在一个<li class=”game-item”>标签内。

def parse_game_list(list_url): """ 解析游戏列表页，提取所有游戏的基本信息（名称、详情页链接）。 参数: list_url (str): 列表页的URL。 返回: list of dict: 包含游戏信息的字典列表。 """ soup = get_page_html(list_url) if not soup: return [] game_list = [] # 这里的选择器需要根据实际网页结构调整！以下是示例。 # 使用开发者工具，找到包裹每个游戏项的公共选择器。 game_items = soup.select('ul.game-list > li') # 示例选择器 for item in game_items: try: # 提取游戏名称和链接 # 假设标题在<a>标签内，并且这个<a>标签是游戏详情页的入口 link_tag = item.select_one('a') if not link_tag: continue game_url = link_tag.get('href') game_name = link_tag.get('title') or link_tag.text.strip() # 确保URL是完整的。如果遇到相对路径，需要补全。 if game_url and not game_url.startswith('http'): # 4399内部链接可能是相对路径或绝对路径，需要根据情况处理 # 例如，如果是‘/flash/12345.htm’，需要加上域名 if game_url.startswith('/'): game_url = 'https://www.4399.com' + game_url else: # 其他情况，可能需要更复杂的处理，这里简单拼接 game_url = 'https://www.4399.com/flash/' + game_url # 可能还有其他信息，比如缩略图、简介、浏览量等 # 假设浏览量在一个<span class=”play-count”>里 play_count_tag = item.select_one(‘span.play-count’) play_count = play_count_tag.text.strip() if play_count_tag else ‘N/A’ game_info = { ‘name’: game_name, ‘url’: game_url, ‘play_count’: play_count, # 可以继续添加其他字段 } game_list.append(game_info) print(f”已提取游戏: {game_name}”) except Exception as e: print(f”解析单个游戏项时出错: {e}”) continue # 跳过此项，继续下一个 return game_list # 测试解析一个分类列表页 if __name__ == ‘__main__’: action_list_url = “https://www.4399.com/flash/类别_1.htm” # 请替换为真实URL games = parse_game_list(action_list_url) print(f”共提取到 {len(games)} 个游戏”) for g in games[:3]: # 打印前三个看看 print(g)

关键点与避坑指南：

• 选择器的稳定性：网页结构可能会改版。今天有效的‘ul.game-list > li’选择器，明天可能就变了。因此，选择器要尽量简洁且具有唯一性。不要使用过于复杂或依赖具体样式类名（如class=”game-item-2023”）的选择器，它们很容易变化。多观察几个游戏项，找到它们共有的、结构性的父标签。
• URL补全：从网页中提取的链接很可能是相对路径（如/flash/12345.htm）。我们必须将其转换为绝对URL，否则requests无法直接访问。补全逻辑需要根据网站实际情况编写。
• 健壮性：在循环解析每个游戏项时，用try...except包裹。因为页面中可能存在结构不一致的项（比如广告位），一个项的解析失败不应该导致整个程序崩溃。continue语句能让我们跳过当前项，继续处理下一个。
• 信息验证：在将数据存入字典前，最好做一下简单的清洗和验证，比如用.strip()去除字符串两端的空白字符。

4.3 第三步：深入详情页，抓取完整数据

有了详情页链接，我们就可以深入获取更丰富的信息了。

def parse_game_detail(detail_url): """ 解析游戏详情页，提取游戏的详细信息。 参数: detail_url (str): 游戏详情页的URL。 返回: dict: 包含游戏详细信息的字典。 """ soup = get_page_html(detail_url) if not soup: return {} detail_info = {} try: # 1. 游戏标题 title_tag = soup.select_one(‘h1.game-title, div.game-title h1’) # 备用选择器 detail_info[‘title’] = title_tag.text.strip() if title_tag else ‘N/A’ # 2. 游戏描述 - 通常从meta标签获取，更标准 meta_desc = soup.find(‘meta’, attrs={‘name’: ‘description’}) detail_info[‘description’] = meta_desc.get(‘content’, ‘N/A’) if meta_desc else ‘N/A’ # 3. 游戏信息块 - 假设在一个class为’game-info’的div里 info_div = soup.select_one(‘div.game-info’) if info_div: # 信息可能以列表项<li>形式呈现 for li in info_div.select(‘li’): text = li.text.strip() if ‘：’ in text: # 中文冒号分隔 key, value = text.split(‘：’, 1) detail_info[key.strip()] = value.strip() elif ‘:’ in text: # 英文冒号分隔 key, value = text.split(‘:’, 1) detail_info[key.strip()] = value.strip() # 如果没有找到信息块，可以尝试其他选择器 # 4. 游戏大小、类型、人气等可能单独存在 size_tag = soup.select_one(‘span.size’) detail_info[‘size’] = size_tag.text.strip() if size_tag else ‘N/A’ # 5. 游戏主图或SWF文件链接（如果需要） # 有些小游戏是Flash(.swf)文件，链接可能藏在某个<script>变量或<embed>标签里 # 这需要更深入的分析，此处仅作提示 # flash_link = soup.find(‘embed’, {‘type’: ‘application/x-shockwave-flash’}) # if flash_link: # detail_info[‘flash_url’] = flash_link.get(‘src’) print(f”详情页解析完成: {detail_info.get(‘title’, detail_url)}”) except Exception as e: print(f”解析详情页 {detail_url} 时出错: {e}”) return detail_info

详情页解析的复杂性：详情页的结构千变万化，是爬虫中最容易出问题的部分。上述代码只是一个示例框架，你需要根据实际页面的HTML结构来调整选择器。

• 多套选择器备用：像提取标题那样，我写了两个可能的选择器（h1.game-title和div.game-title h1），用逗号隔开，select_one会返回第一个匹配的。这是一种提高代码容错率的方法。
• 信息提取的灵活性：游戏信息（大小、类型、人气）的排版方式可能每次改版都不同。可能是<li>列表，可能是<div>加<span>，也可能是<table>。你需要灵活运用find和select方法，并结合字符串处理（如split）来提取键值对。
• 动态加载内容：如果详情页的“评论”、“排行榜”等内容是动态加载的，用BeautifulSoup在初始HTML里是找不到的。此时需要回到Network面板，寻找加载这些数据的API，或者考虑使用Selenium。

4.4 第四步：数据存储与流程整合

爬取到的数据需要持久化保存。这里我们使用最通用的CSV格式，方便用Excel打开或导入数据库。

import pandas as pd import os def save_to_csv(game_data_list, filename=’4399_games.csv’): """ 将游戏数据列表保存到CSV文件。 参数: game_data_list (list of dict): 游戏数据字典的列表。 filename (str): 输出的CSV文件名。 """ if not game_data_list: print(“没有数据可保存。”) return # 使用pandas的DataFrame来保存，非常方便 df = pd.DataFrame(game_data_list) # 确保输出目录存在 os.makedirs(‘./data’, exist_ok=True) filepath = os.path.join(‘./data’, filename) # 保存到CSV，index=False表示不保存行索引，encoding=‘utf-8-sig’确保Excel打开中文不乱码 df.to_csv(filepath, index=False, encoding=‘utf-8-sig’) print(f”数据已保存至 {filepath}, 共 {len(df)} 条记录。”) def main(): """ 主函数：整合整个爬取流程。 """ all_games_data = [] # 示例：爬取多个分类页面 # 你需要先分析出分类页的URL规律 base_url = “https://www.4399.com/flash/类别_{}.htm” categories = [‘1’, ‘2’, ‘3’] # 假设1,2,3代表不同分类 for cat in categories: list_url = base_url.format(cat) print(f”正在爬取分类列表页: {list_url}”) # 1. 获取列表页游戏链接 basic_game_list = parse_game_list(list_url) if not basic_game_list: print(f”分类 {cat} 列表页解析失败或无数据，跳过。”) continue # 2. 遍历每个游戏，获取详情 for game_basic in basic_game_list: detail_url = game_basic[‘url’] print(f”正在爬取详情页: {detail_url}”) detail_info = parse_game_detail(detail_url) # 3. 合并基础信息和详情信息 full_game_info = {**game_basic, **detail_info} all_games_data.append(full_game_info) # 4. 每处理完一个游戏，可以短暂休息，也可以每N个保存一次 time.sleep(random.uniform(0.5, 1.5)) # 详情页请求间隔 # 5. 所有数据爬取完成后，保存到文件 save_to_csv(all_games_data, ‘4399_games_full.csv’) if __name__ == ‘__main__’: main()

流程整合要点：

• 错误处理与日志：在main函数中，每一步都应有打印日志，方便跟踪进度和定位错误。
• 增量爬取：对于大规模爬取，你可能需要记录已经爬取过的URL，避免重复爬取。可以将已爬取的URL存入一个set或文件，每次爬取前检查。
• 断点续传：更健壮的做法是将爬取状态（如当前爬到的页码、分类）定期保存到文件。如果程序意外中断，重启后可以从断点继续，而不是从头开始。
• 数据去重：在保存前，可以根据游戏ID或URL对all_games_data进行去重。

5. 高级话题：反爬策略应对与性能优化

一个只能运行一次的爬虫是脆弱的。我们需要让它更智能、更稳定、更快。

5.1 常见的反爬机制与应对方案

4399作为大型网站，很可能部署了一些基本的反爬措施。

1. User-Agent检测：我们已经做了，使用常见的浏览器UA。
2. 请求频率限制：这是我们一直强调的，通过time.sleep控制速度。更进阶的做法是使用随机延时，并模拟人类浏览的不规律性（如先快后慢，浏览几个页面后休息一下）。
3. IP封禁：如果短时间内从一个IP地址发出大量请求，服务器可能会暂时或永久封禁该IP。
   • 解决方案：使用代理IP池。你可以购买付费代理服务，或者使用一些免费的代理IP（但免费代理通常不稳定）。在requests.get()中通过proxies参数设置代理。
   • 示例：proxies = {‘http’: ‘http://10.10.1.10:3128’, ‘https’: ‘https://10.10.1.10:1080’}
4. Cookie/Session验证：有些页面需要登录后才能访问，或者通过Cookie来跟踪会话。
   • 解决方案：使用requests.Session()对象。它会在多次请求间自动保持Cookie，模拟一个浏览器会话。对于需要登录的网站，可以先post登录接口获取Cookie，然后用这个Session去访问其他页面。
5. JavaScript动态渲染：如前所述，用Selenium或找到Ajax接口。
6. 验证码：如果触发了验证码，处理起来就比较麻烦。对于简单图形验证码，可以使用OCR库（如pytesseract）尝试识别，但成功率有限。对于复杂验证码（如滑块、点选），通常需要接入第三方打码平台，或者考虑是否爬取行为过于激进触发了风控，应降低频率。

给新手的建议：对于学习项目，做到前三点（UA、延时、处理异常）就已经很好了。代理IP和Session可以在遇到实际问题时再深入研究。

5.2 提升爬虫效率：异步与并发

当需要爬取成千上万个页面时，顺序请求（一个接一个）会非常慢。我们可以使用并发技术。

• 多线程/多进程：Python的concurrent.futures模块提供了高级的线程池和进程池接口，可以方便地实现并发请求。但需要注意，线程数不是越多越好，过多的并发请求会加重目标服务器负担，也更容易被屏蔽。
• 异步IO（asyncio + aiohttp）：这是目前Python爬虫进行高并发IO操作的主流方案。asyncio提供了单线程下的并发能力，通过事件循环处理大量网络请求，效率非常高。但异步编程有一定学习曲线。

这里给出一个使用concurrent.futures.ThreadPoolExecutor（线程池）来并发爬取详情页的简单示例：

from concurrent.futures import ThreadPoolExecutor, as_completed def fetch_game_detail_concurrently(game_basic_list, max_workers=5): """ 使用线程池并发爬取游戏详情页。 参数: game_basic_list (list): 包含游戏基本信息的字典列表，每个字典需有‘url’键。 max_workers (int): 线程池最大工作线程数。 返回: list: 包含完整游戏信息的字典列表。 """ all_full_info = [] def fetch_one(game_basic): """单个游戏详情爬取任务""" detail_url = game_basic[‘url’] detail_info = parse_game_detail(detail_url) return {**game_basic, **detail_info} with ThreadPoolExecutor(max_workers=max_workers) as executor: # 提交所有任务 future_to_game = {executor.submit(fetch_one, game): game for game in game_basic_list} for future in as_completed(future_to_game): game_basic = future_to_game[future] try: full_info = future.result() all_full_info.append(full_info) print(f”已完成: {full_info.get(‘name’, ‘Unknown’)}”) except Exception as exc: print(f”游戏 {game_basic.get(‘name’)} 爬取过程中产生异常: {exc}”) return all_full_info # 在主函数中，可以将 parse_game_detail 的循环替换为调用此函数 # all_games_data = fetch_game_detail_concurrently(basic_game_list, max_workers=3)

使用并发的重要警告：

• 控制并发数：max_workers不要设置太大（比如超过10），否则极易被服务器封IP。建议从3-5开始测试。
• 礼貌爬取：即使使用并发，也应在每个线程的任务函数内部保留适当的延时(time.sleep)，或者使用更高级的速率限制器。
• 共享数据：多线程/进程修改共享数据（如all_full_info列表）时，需要注意线程安全。上述示例中，每个线程处理自己的数据，最后在主线程中收集结果，是安全的。

5.3 数据清洗与初步分析示例

数据爬下来后，我们可能得到一些杂乱的信息。比如“人气”字段可能是“123万次播放”，我们需要将其转换为数字1230000以便分析。

import re def clean_game_data(df): """ 清洗游戏数据DataFrame。 """ df_clean = df.copy() # 1. 处理‘人气/播放量’字段，将其转换为整数 if ‘play_count’ in df_clean.columns: def parse_play_count(text): if pd.isna(text) or text == ‘N/A’: return 0 # 匹配数字和‘万’字 match = re.search(r’([\d\.]+)\s*万?’, str(text)) if match: num = float(match.group(1)) if ‘万’ in str(text): return int(num * 10000) else: return int(num) return 0 df_clean[‘play_count_num’] = df_clean[‘play_count’].apply(parse_play_count) # 2. 处理‘游戏大小’字段，转换为以MB为单位的浮点数 if ‘size’ in df_clean.columns: def parse_size(text): if pd.isna(text) or text == ‘N/A’: return 0.0 text = str(text).upper() match = re.search(r’([\d\.]+)\s*(M|MB|G|GB)’, text) if match: num = float(match.group(1)) unit = match.group(2) if unit.startswith(‘G’): return num * 1024 # GB转MB else: return num return 0.0 df_clean[‘size_mb’] = df_clean[‘size’].apply(parse_size) # 3. 去除完全重复的行（基于所有列） df_clean = df_clean.drop_duplicates() # 4. 填充或删除缺失值 # df_clean = df_clean.fillna(‘Unknown’) # 用特定值填充 # df_clean = df_clean.dropna(subset=[‘title’]) # 删除标题为空的行 return df_clean # 使用示例 df_raw = pd.read_csv(‘./data/4399_games_full.csv’) df_clean = clean_game_data(df_raw) print(df_clean[[‘name’, ‘play_count’, ‘play_count_num’, ‘size’, ‘size_mb’]].head())

清洗之后，我们就可以用Pandas进行一些简单的分析了，比如：

• 哪个分类的游戏最多？ (df_clean[‘category’].value_counts())
• 播放量最高的前十名游戏是哪些？ (df_clean.nlargest(10, ‘play_count_num’)[[‘name’, ‘play_count_num’]])
• 游戏大小的分布情况如何？ (df_clean[‘size_mb’].describe())

6. 项目总结与扩展思考

走到这里，你已经完成了一个功能相对完整的4399小游戏爬虫。它能够从分类列表页开始，遍历游戏链接，深入详情页抓取多维数据，并保存为结构化的CSV文件，过程中还考虑了基本的反爬策略和错误处理。

回顾一下核心流程：

1. 分析：使用浏览器开发者工具，摸清网站的数据结构和加载方式。
2. 请求：用Requests库模拟浏览器发送HTTP请求，并设置合理的请求头和延时。
3. 解析：用BeautifulSoup配合lxml解析器，根据HTML标签和属性提取所需数据。
4. 存储：用Pandas将数据整理成DataFrame并保存为CSV文件。
5. 优化：通过并发、代理、会话保持等技术提升爬虫的效率和稳定性。

可能遇到的挑战与解决思路：

• 网站改版：这是爬虫的“天敌”。你的选择器可能突然失效。应对方法是：编写更健壮的选择器（不依赖易变的类名），将关键的选择器路径作为配置参数，方便修改；定期运行爬虫，及时发现失败。
• 数据量巨大：如果想爬取全站游戏，需要考虑分布式爬虫（如Scrapy框架结合Scrapy-Redis）、更强大的代理IP池和任务调度系统。这已经超出了入门项目的范畴。
• 法律与道德风险：务必遵守网站的robots.txt协议，控制爬取速度，不要对服务器造成负担。爬取的数据仅用于个人学习和分析，不要用于商业用途或侵犯他人权益。

这个项目可以如何扩展？

• 数据分析与可视化：用Matplotlib或Seaborn绘制游戏分类饼图、播放量排行榜柱状图、游戏大小分布直方图等。
• 构建游戏搜索引擎：将爬取的游戏描述、标题等信息建立简单的倒排索引，实现一个站内游戏搜索功能。
• 自动化监测：定期爬取某个分类或热门游戏，监控其播放量变化，分析游戏热度趋势。
• 深入Flash游戏资源：尝试解析并下载游戏的SWF文件（如果还有的话），但这涉及更复杂的二进制文件处理和可能的法律问题，需谨慎。

爬虫技术是一把双刃剑，它在帮助我们高效获取公开信息的同时，也要求我们具备良好的技术伦理和法律意识。从这个项目出发，希望你不仅能掌握Python爬虫的核心技能，更能理解数据获取背后的逻辑与边界。