淘宝指数批量查询工具开发：5个致命坑与完整示例
别再盯着语法书发呆，代码能跑通不代表能上线。很多人卡在“学会语法却不知怎么搭项目”这一步，看着零散的爬虫教程，心里没底。想搞定一个稳定的淘宝指数批量查询工具，光会写 requests 远远不够。你需要的是能落地的完整示例，以及踩过的坑填平的实战经验。
今天不整虚的，直接上干货。我把自己开发过程中遇到的5个高频报错和逻辑陷阱，拆解成“现象-原因-对策”的结构。不管你是前端转后端，还是纯Python新手，跟着这篇避坑指南走，至少能省下两周的Debug时间。
坑一：反爬机制下的请求频率失控
现象
刚跑起来的前10分钟，数据拿得飞起。突然之间，接口全部返回 403 Forbidden，或者 HTML 页面变成了一堆乱码。再一看，IP 直接被淘宝风控屏蔽了，连验证码都懒得给你弹，直接封禁。
根本原因
很多新手写批量查询，习惯用一个线程疯狂发请求，或者多线程并发数开得太高。淘宝的风控系统非常灵敏，它监控的不只是你的 User-Agent，更是你的请求频率和行为模式。如果短时间内同一 IP 发起大量相似请求，会被判定为机器流量。更隐蔽的是，淘宝的接口有时不会立刻返回错误码，而是返回一个空的 JSON 或者过期的数据，导致你误以为程序正常，实际数据全是脏数据。
正确写法对比
错误写法：无脑高并发
import requests
import threadingdef fetch_data(keyword):url = fhttps://www.taobao.com/markets/market-3131751/{keyword}headers = {User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36}try:r = requests.get(url, headers=headers, timeout=5)# 这里没有频率控制，线程池一开，瞬间打爆return r.textexcept Exception as e:return str(e)# 假设开启50个线程并发
threads = []
for kw in keyword_list[:50]:t = threading.Thread(target=fetch_data, args=(kw,))threads.append(t)t.start()这种写法，IP 存活时间通常不超过 30 秒。
正确写法：令牌桶限速 + 随机休眠
import requests
import time
import random
from queue import Queue
import threadingclass RateLimiter:def __init__(self, rate=1, capacity=5):self.rate = rateself.capacity = capacityself.tokens = capacityself.last_time = time.time()self.lock = threading.Lock()def acquire(self):with self.lock:now = time.time()self.tokens += (now - self.last_time) * self.rateself.tokens = min(self.tokens, self.capacity)self.last_time = nowif self.tokens = 1:self.tokens -= 1return Truereturn Falselimiter = RateLimiter(rate=2, capacity=5) # 每秒最多2个请求，突发容量5def safe_fetch(keyword):while not limiter.acquire():time.sleep(0.1)# 增加随机休眠，模拟人类操作time.sleep(random.uniform(1, 3))url = fhttps://www.taobao.com/markets/market-3131751/{keyword}headers = {User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36,Referer: https://www.taobao.com/}try:r = requests.get(url, headers=headers, timeout=10)if r.status_code != 200:raise Exception(fStatus: {r.status_code})return r.textexcept Exception as e:print(fFetch failed for {keyword}: {e})return None核心改动：引入了令牌桶算法控制全局速率，并加入随机休眠。这符合 Python 官方文档 中关于线程安全队列的最佳实践，避免了竞态条件。
复现与修复
在测试环境中，先跑 10 个关键词。使用错误写法，观察日志，你会看到大量 403。切换到正确写法后，将 rate 调低到 1，观察 10 分钟，确保没有异常中断。如果依然被封，检查是否泄露了 IP 池，或者 Cookie 是否过期。
规避建议IP 代理池是必须的：不要依赖单一家庭宽带 IP。准备一批高质量住宅代理，每个 IP 使用次数限制在 10-20 次以内。
监控响应内容：不要只判断状态码。解析 HTML，如果页面中出现“亲，请稍后再试”等风控提示，立即切换 IP 并休眠 30 秒以上。坑二：数据解析中的空值与结构变更
现象
程序跑了一半，突然抛出 KeyError 或 IndexError。查看日志，发现某些关键词返回的数据结构和其他的不一样。比如，正常数据里 data.list 有 20 条，但某个冷门词只返回了 0 条，或者字段名从 title 变成了 name。
根本原因
淘宝的前端代码是动态加载的，接口返回的 JSON 结构并不稳定。有时候为了前端适配，后端会悄悄改字段名，或者在数据为空时直接省略整个节点。新手习惯用 json['data']['list'][0]['title'] 这种硬编码方式取值，一旦中间某层为空或键不存在，程序直接崩溃。
正确写法对比
错误写法：硬编码取值
import jsondef parse_data(html_content):data = json.loads(html_content)# 如果 data 里没有 'list' 键，这里直接报错items = data['data']['list'] for item in items:title = item['title'] # 如果某条数据没有 title 键，报错price = item['price']print(title, price)正确写法：防御性编程
import jsondef parse_data_safe(html_content):try:data = json.loads(html_content)except json.JSONDecodeError:print(JSON decode failed)return []# 使用 .get() 方法，提供默认值if not data.get('success', False):return []list_data = data.get('data', {}).get('list', [])if not isinstance(list_data, list):return []results = []for item in list_data:# 逐层获取，确保每一步都安全title = item.get('title', 'N/A')price = item.get('price', 'N/A')shop_name = item.get('shop', {}).get('name', 'Unknown')# 过滤无效数据if title != 'N/A' and price != 'N/A':results.append({'title': title,'price': float(price) if price.isdigit() else 0.0,'shop': shop_name})return results核心改动：全程使用 .get() 方法，并检查类型。这比 try-except 捕获所有异常更精准，因为 try-except 会掩盖真正的逻辑错误。
复现与修复
构造几个边界测试用例：空 JSON {}
缺少 data 字段的 JSON {success: true}
list 为 null 的 JSON {data: {list: null}}
运行 parse_data_safe，确保返回空列表 [] 而不是抛出异常。规避建议日志记录原始数据：当解析失败时，将原始 HTML 或 JSON 保存到本地文件，方便事后分析结构变更。
版本控制：给解析器加个版本号。如果淘宝改版，你可以快速回退到上一个稳定的解析逻辑，而不是整个程序瘫痪。坑三：数据库连接池耗尽与死锁
现象
程序运行几小时后，响应速度越来越慢，最终卡死。查看数据库日志，发现大量 Too many connections 错误，或者部分查询语句长时间处于 Waiting for lock 状态。
根本原因
批量查询工具通常需要将结果存入数据库（如 MySQL 或 SQLite）。新手往往在每个线程或每次请求中都新建一个数据库连接，用完不关闭，或者关闭时机不对。在高并发下，连接数迅速耗尽。此外，如果在事务中长时间持有行锁，而其他线程试图更新同一行数据，就会形成死锁。
正确写法对比
错误写法：每次新建连接
import sqlite3def save_to_db(data):# 每次调用都新建连接，且没有明确关闭conn = sqlite3.connect('data.db')cursor = conn.cursor()for item in data:cursor.execute(INSERT INTO products (title, price) VALUES (?, ?), (item['title'], item['price']))conn.commit()# 忘记 conn.close()，导致连接泄漏正确写法：使用连接池
import sqlite3
from contextlib import contextmanager
import threadingclass DBPool:def __init__(self, db_name, max_connections=5):self.db_name = db_nameself.max_connections = max_connectionsself.pool = []self.lock = threading.Lock()self.in_use = 0def get_connection(self):with self.lock:if self.pool:return self.pool.pop()if self.in_use self.max_connections:self.in_use += 1return sqlite3.connect(self.db_name)raise Exception(Connection pool exhausted)def return_connection(self, conn):with self.lock:self.pool.append(conn)self.in_use -= 1db_pool = DBPool('data.db')@contextmanager
def get_db_connection():conn = db_pool.get_connection()try:yield connfinally:db_pool.return_connection(conn)def save_to_db_safe(data):with get_db_connection() as conn:cursor = conn.cursor()# 使用 executemany 提高批量插入效率cursor.executemany(INSERT OR IGNORE INTO products (title, price, updated_at) VALUES (?, ?, datetime('now')),[(item['title'], item['price']) for item in data])conn.commit()核心改动：实现了简单的线程安全连接池，并使用 contextmanager 确保连接一定被归还。同时，使用 executemany 减少网络/IO 往返次数。
复现与修复
使用 top 或 htop 监控进程的文件描述符数量（lsof -p pid）。如果连接数持续上升不下降，说明有泄漏。修复后，连接数应稳定在 max_connections 附近波动。
规避建议使用成熟 ORM：如果项目规模较大，建议使用 SQLAlchemy 等 ORM 框架，它们内置了优秀的连接池管理。
定期清理：对于 SQLite，定期执行 VACUUM 命令，防止数据库文件碎片化导致性能下降。坑四：异常处理导致的静默失败
现象
程序日志显示“任务完成”，但数据库里的数据量远低于预期。检查发现，有很多关键词其实查询失败了，但程序没有报错，而是默默跳过了。
根本原因
新手写 try-except 时，习惯捕获 Exception 这个基类，并且 pass 或者只打印一行 print(Error)。这种写法会吞掉所有异常，包括网络超时、解析错误、数据库错误等。你根本不知道是哪个环节出了问题，也无法进行重试。
正确写法对比
错误写法：吞掉异常
def process_keyword(kw):try:html = fetch_data(kw)data = parse_data(html)save_to_db(data)except Exception as e:pass # 危险！异常被忽略，程序继续运行，但数据缺失正确写法：分级异常处理与重试
import logging
from tenacity import retry, stop_after_attempt, wait_exponentiallogging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)@retry(stop=stop_after_attempt(3), wait=wait_exponential(multiplier=1, min=4, max=10))
def fetch_with_retry(keyword):# 这里的异常会触发重试html = safe_fetch(keyword)if not html:raise Exception(Fetch returned None)return htmldef process_keyword_robust(kw):try:html = fetch_with_retry(kw)data = parse_data_safe(html)if not data:logger.warning(fNo data parsed for {kw})return 0count = save_to_db_safe(data)logger.info(fSaved {count} items for {kw})return countexcept requests.exceptions.Timeout:logger.error(fTimeout for {kw}, skipping after retries)except json.JSONDecodeError:logger.error(fJSON parse error for {kw}, skipping)except Exception as e:logger.exception(fUnexpected error for {kw}: {e})return 0核心改动：使用 tenacity 库进行自动重试，针对网络波动。
细分异常类型，分别记录日志。
使用 logger.exception 记录完整堆栈，便于排查。复现与修复
人为制造网络故障（如断开 WiFi 几秒），观察程序是否能自动重试并恢复。检查日志文件，确保每条失败记录都有明确的错误类型和时间戳。
规避建议不要捕获 BaseException：这会导致 KeyboardInterrupt 也被吞掉，你按 Ctrl+C 都关不掉程序。
告警机制：如果连续 10 个关键词都失败，应该触发邮件或钉钉告警，而不是让程序继续空转。坑五：内存泄漏与大数据量处理
现象
随着运行时间增加，程序占用的内存越来越大，最终被操作系统强制杀死（OOM）。
根本原因
批量查询通常涉及大量数据。如果将所有数据都加载到内存中再处理，或者在循环中不断创建大对象而不释放，就会导致内存泄漏。特别是在 Python 中，虽然 GC 机制强大，但长时间运行的程序仍需注意引用计数。
正确写法对比
错误写法：全量加载
def process_all(keywords):all_data = []for kw in keywords:data = fetch_and_parse(kw)all_data.extend(data) # 所有数据堆在内存里save_to_db(all_data) # 一次性插入，内存峰值极高正确写法：流式处理
def process_all_streaming(keywords):BATCH_SIZE = 100batch_buffer = []for kw in keywords:data = fetch_and_parse(kw)batch_buffer.extend(data)# 达到批量大小，立即写入并清空缓冲区if len(batch_buffer) = BATCH_SIZE:save_to_db_safe(batch_buffer)batch_buffer.clear()# 强制垃圾回收（谨慎使用，通常不需要，但在内存紧张时有帮助）# import gc; gc.collect()# 处理剩余数据if batch_buffer:save_to_db_safe(batch_buffer)复现与修复
使用 memory_profiler 库监控内存使用情况。对比两种写法的内存峰值，流式处理的内存占用应稳定在较低水平。
规避建议使用生成器：如果数据源是文件，使用 yield 逐行读取，而不是 readlines()。
定期重启：对于长期运行的脚本，可以考虑每处理 1000 个关键词后，重启进程，彻底释放内存。总结与互动
开发淘宝指数批量查询工具，技术栈并不复杂，难在细节和对非稳定环境的应对。上述五个坑，涵盖了网络、解析、数据库、异常和内存五个核心维度。记住，稳定比速度更重要。一个每天能稳定跑 8 小时的工具，远胜过一个快但经常崩溃的工具。
最后，想请教大家一个问题：在处理这类非结构化或半结构化数据时，你更常用正则表达式、XPath 还是 BeautifulSoup？各自的适用场景和性能瓶颈在哪里？评论区交流一下你的实战经验。
淘宝指数批量查询工具开发：5个致命坑与完整示例
淘宝指数批量查询工具开发：5个致命坑与完整示例
别再盯着语法书发呆，代码能跑通不代表能上线。很多人卡在“学会语法却不知怎么搭项目”这一步，看着零散的爬虫教程，心里没底。想搞定一个稳定的淘宝指数批量查询工具，光会写 requests 远远不够。你需要的是能落地的完整示例，以及踩过的坑填平的实战经验。
今天不整虚的，直接上干货。我把自己开发过程中遇到的5个高频报错和逻辑陷阱，拆解成“现象-原因-对策”的结构。不管你是前端转后端，还是纯Python新手，跟着这篇避坑指南走，至少能省下两周的Debug时间。
坑一：反爬机制下的请求频率失控
现象
刚跑起来的前10分钟，数据拿得飞起。突然之间，接口全部返回 403 Forbidden，或者 HTML 页面变成了一堆乱码。再一看，IP 直接被淘宝风控屏蔽了，连验证码都懒得给你弹，直接封禁。
根本原因
很多新手写批量查询，习惯用一个线程疯狂发请求，或者多线程并发数开得太高。淘宝的风控系统非常灵敏，它监控的不只是你的 User-Agent，更是你的请求频率和行为模式。如果短时间内同一 IP 发起大量相似请求，会被判定为机器流量。更隐蔽的是，淘宝的接口有时不会立刻返回错误码，而是返回一个空的 JSON 或者过期的数据，导致你误以为程序正常，实际数据全是脏数据。
正确写法对比
错误写法：无脑高并发
import requests
import threadingdef fetch_data(keyword):url = fhttps://www.taobao.com/markets/market-3131751/{keyword}headers = {User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36}try:r = requests.get(url, headers=headers, timeout=5)# 这里没有频率控制，线程池一开，瞬间打爆return r.textexcept Exception as e:return str(e)# 假设开启50个线程并发
threads = []
for kw in keyword_list[:50]:t = threading.Thread(target=fetch_data, args=(kw,))threads.append(t)t.start()这种写法，IP 存活时间通常不超过 30 秒。
正确写法：令牌桶限速 + 随机休眠
import requests
import time
import random
from queue import Queue
import threadingclass RateLimiter:def __init__(self, rate=1, capacity=5):self.rate = rateself.capacity = capacityself.tokens = capacityself.last_time = time.time()self.lock = threading.Lock()def acquire(self):with self.lock:now = time.time()self.tokens += (now - self.last_time) * self.rateself.tokens = min(self.tokens, self.capacity)self.last_time = nowif self.tokens = 1:self.tokens -= 1return Truereturn Falselimiter = RateLimiter(rate=2, capacity=5) # 每秒最多2个请求，突发容量5def safe_fetch(keyword):while not limiter.acquire():time.sleep(0.1)# 增加随机休眠，模拟人类操作time.sleep(random.uniform(1, 3))url = fhttps://www.taobao.com/markets/market-3131751/{keyword}headers = {User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36,Referer: https://www.taobao.com/}try:r = requests.get(url, headers=headers, timeout=10)if r.status_code != 200:raise Exception(fStatus: {r.status_code})return r.textexcept Exception as e:print(fFetch failed for {keyword}: {e})return None核心改动：引入了令牌桶算法控制全局速率，并加入随机休眠。这符合 Python 官方文档 中关于线程安全队列的最佳实践，避免了竞态条件。
复现与修复
在测试环境中，先跑 10 个关键词。使用错误写法，观察日志，你会看到大量 403。切换到正确写法后，将 rate 调低到 1，观察 10 分钟，确保没有异常中断。如果依然被封，检查是否泄露了 IP 池，或者 Cookie 是否过期。
规避建议IP 代理池是必须的：不要依赖单一家庭宽带 IP。准备一批高质量住宅代理，每个 IP 使用次数限制在 10-20 次以内。
监控响应内容：不要只判断状态码。解析 HTML，如果页面中出现“亲，请稍后再试”等风控提示，立即切换 IP 并休眠 30 秒以上。坑二：数据解析中的空值与结构变更
现象
程序跑了一半，突然抛出 KeyError 或 IndexError。查看日志，发现某些关键词返回的数据结构和其他的不一样。比如，正常数据里 data.list 有 20 条，但某个冷门词只返回了 0 条，或者字段名从 title 变成了 name。
根本原因
淘宝的前端代码是动态加载的，接口返回的 JSON 结构并不稳定。有时候为了前端适配，后端会悄悄改字段名，或者在数据为空时直接省略整个节点。新手习惯用 json['data']['list'][0]['title'] 这种硬编码方式取值，一旦中间某层为空或键不存在，程序直接崩溃。
正确写法对比
错误写法：硬编码取值
import jsondef parse_data(html_content):data = json.loads(html_content)# 如果 data 里没有 'list' 键，这里直接报错items = data['data']['list'] for item in items:title = item['title'] # 如果某条数据没有 title 键，报错price = item['price']print(title, price)正确写法：防御性编程
import jsondef parse_data_safe(html_content):try:data = json.loads(html_content)except json.JSONDecodeError:print(JSON decode failed)return []# 使用 .get() 方法，提供默认值if not data.get('success', False):return []list_data = data.get('data', {}).get('list', [])if not isinstance(list_data, list):return []results = []for item in list_data:# 逐层获取，确保每一步都安全title = item.get('title', 'N/A')price = item.get('price', 'N/A')shop_name = item.get('shop', {}).get('name', 'Unknown')# 过滤无效数据if title != 'N/A' and price != 'N/A':results.append({'title': title,'price': float(price) if price.isdigit() else 0.0,'shop': shop_name})return results核心改动：全程使用 .get() 方法，并检查类型。这比 try-except 捕获所有异常更精准，因为 try-except 会掩盖真正的逻辑错误。
复现与修复
构造几个边界测试用例：空 JSON {}
缺少 data 字段的 JSON {success: true}
list 为 null 的 JSON {data: {list: null}}
运行 parse_data_safe，确保返回空列表 [] 而不是抛出异常。规避建议日志记录原始数据：当解析失败时，将原始 HTML 或 JSON 保存到本地文件，方便事后分析结构变更。
版本控制：给解析器加个版本号。如果淘宝改版，你可以快速回退到上一个稳定的解析逻辑，而不是整个程序瘫痪。坑三：数据库连接池耗尽与死锁
现象
程序运行几小时后，响应速度越来越慢，最终卡死。查看数据库日志，发现大量 Too many connections 错误，或者部分查询语句长时间处于 Waiting for lock 状态。
根本原因
批量查询工具通常需要将结果存入数据库（如 MySQL 或 SQLite）。新手往往在每个线程或每次请求中都新建一个数据库连接，用完不关闭，或者关闭时机不对。在高并发下，连接数迅速耗尽。此外，如果在事务中长时间持有行锁，而其他线程试图更新同一行数据，就会形成死锁。
正确写法对比
错误写法：每次新建连接
import sqlite3def save_to_db(data):# 每次调用都新建连接，且没有明确关闭conn = sqlite3.connect('data.db')cursor = conn.cursor()for item in data:cursor.execute(INSERT INTO products (title, price) VALUES (?, ?), (item['title'], item['price']))conn.commit()# 忘记 conn.close()，导致连接泄漏正确写法：使用连接池
import sqlite3
from contextlib import contextmanager
import threadingclass DBPool:def __init__(self, db_name, max_connections=5):self.db_name = db_nameself.max_connections = max_connectionsself.pool = []self.lock = threading.Lock()self.in_use = 0def get_connection(self):with self.lock:if self.pool:return self.pool.pop()if self.in_use self.max_connections:self.in_use += 1return sqlite3.connect(self.db_name)raise Exception(Connection pool exhausted)def return_connection(self, conn):with self.lock:self.pool.append(conn)self.in_use -= 1db_pool = DBPool('data.db')@contextmanager
def get_db_connection():conn = db_pool.get_connection()try:yield connfinally:db_pool.return_connection(conn)def save_to_db_safe(data):with get_db_connection() as conn:cursor = conn.cursor()# 使用 executemany 提高批量插入效率cursor.executemany(INSERT OR IGNORE INTO products (title, price, updated_at) VALUES (?, ?, datetime('now')),[(item['title'], item['price']) for item in data])conn.commit()核心改动：实现了简单的线程安全连接池，并使用 contextmanager 确保连接一定被归还。同时，使用 executemany 减少网络/IO 往返次数。
复现与修复
使用 top 或 htop 监控进程的文件描述符数量（lsof -p pid）。如果连接数持续上升不下降，说明有泄漏。修复后，连接数应稳定在 max_connections 附近波动。
规避建议使用成熟 ORM：如果项目规模较大，建议使用 SQLAlchemy 等 ORM 框架，它们内置了优秀的连接池管理。
定期清理：对于 SQLite，定期执行 VACUUM 命令，防止数据库文件碎片化导致性能下降。坑四：异常处理导致的静默失败
现象
程序日志显示“任务完成”，但数据库里的数据量远低于预期。检查发现，有很多关键词其实查询失败了，但程序没有报错，而是默默跳过了。
根本原因
新手写 try-except 时，习惯捕获 Exception 这个基类，并且 pass 或者只打印一行 print(Error)。这种写法会吞掉所有异常，包括网络超时、解析错误、数据库错误等。你根本不知道是哪个环节出了问题，也无法进行重试。
正确写法对比
错误写法：吞掉异常
def process_keyword(kw):try:html = fetch_data(kw)data = parse_data(html)save_to_db(data)except Exception as e:pass # 危险！异常被忽略，程序继续运行，但数据缺失正确写法：分级异常处理与重试
import logging
from tenacity import retry, stop_after_attempt, wait_exponentiallogging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)@retry(stop=stop_after_attempt(3), wait=wait_exponential(multiplier=1, min=4, max=10))
def fetch_with_retry(keyword):# 这里的异常会触发重试html = safe_fetch(keyword)if not html:raise Exception(Fetch returned None)return htmldef process_keyword_robust(kw):try:html = fetch_with_retry(kw)data = parse_data_safe(html)if not data:logger.warning(fNo data parsed for {kw})return 0count = save_to_db_safe(data)logger.info(fSaved {count} items for {kw})return countexcept requests.exceptions.Timeout:logger.error(fTimeout for {kw}, skipping after retries)except json.JSONDecodeError:logger.error(fJSON parse error for {kw}, skipping)except Exception as e:logger.exception(fUnexpected error for {kw}: {e})return 0核心改动：使用 tenacity 库进行自动重试，针对网络波动。
细分异常类型，分别记录日志。
使用 logger.exception 记录完整堆栈，便于排查。复现与修复
人为制造网络故障（如断开 WiFi 几秒），观察程序是否能自动重试并恢复。检查日志文件，确保每条失败记录都有明确的错误类型和时间戳。
规避建议不要捕获 BaseException：这会导致 KeyboardInterrupt 也被吞掉，你按 Ctrl+C 都关不掉程序。
告警机制：如果连续 10 个关键词都失败，应该触发邮件或钉钉告警，而不是让程序继续空转。坑五：内存泄漏与大数据量处理
现象
随着运行时间增加，程序占用的内存越来越大，最终被操作系统强制杀死（OOM）。
根本原因
批量查询通常涉及大量数据。如果将所有数据都加载到内存中再处理，或者在循环中不断创建大对象而不释放，就会导致内存泄漏。特别是在 Python 中，虽然 GC 机制强大，但长时间运行的程序仍需注意引用计数。
正确写法对比
错误写法：全量加载
def process_all(keywords):all_data = []for kw in keywords:data = fetch_and_parse(kw)all_data.extend(data) # 所有数据堆在内存里save_to_db(all_data) # 一次性插入，内存峰值极高正确写法：流式处理
def process_all_streaming(keywords):BATCH_SIZE = 100batch_buffer = []for kw in keywords:data = fetch_and_parse(kw)batch_buffer.extend(data)# 达到批量大小，立即写入并清空缓冲区if len(batch_buffer) = BATCH_SIZE:save_to_db_safe(batch_buffer)batch_buffer.clear()# 强制垃圾回收（谨慎使用，通常不需要，但在内存紧张时有帮助）# import gc; gc.collect()# 处理剩余数据if batch_buffer:save_to_db_safe(batch_buffer)复现与修复
使用 memory_profiler 库监控内存使用情况。对比两种写法的内存峰值，流式处理的内存占用应稳定在较低水平。
规避建议使用生成器：如果数据源是文件，使用 yield 逐行读取，而不是 readlines()。
定期重启：对于长期运行的脚本，可以考虑每处理 1000 个关键词后，重启进程，彻底释放内存。总结与互动
开发淘宝指数批量查询工具，技术栈并不复杂，难在细节和对非稳定环境的应对。上述五个坑，涵盖了网络、解析、数据库、异常和内存五个核心维度。记住，稳定比速度更重要。一个每天能稳定跑 8 小时的工具，远胜过一个快但经常崩溃的工具。
最后，想请教大家一个问题：在处理这类非结构化或半结构化数据时，你更常用正则表达式、XPath 还是 BeautifulSoup？各自的适用场景和性能瓶颈在哪里？评论区交流一下你的实战经验。