HOOOS

Python并发爬虫进阶：asyncio实战与反爬策略详解

0 2 爬虫小能手 Python爬虫asyncio并发爬虫
Apple

还在用requests苦苦挣扎？想让你的爬虫像闪电一样快吗？asyncio就是你的秘密武器！本文将带你深入asyncio的世界，教你如何用它来并发抓取网页，并优雅地应对各种反爬机制，让你的爬虫效率提升N个数量级！

1. asyncio：异步并发的利器

asyncio是Python 3.4+版本引入的标准库，它提供了一种编写单线程并发代码的方式。简单来说，你可以把它想象成一个超级调度员，能够高效地管理多个任务，让它们看似同时运行，但实际上是在一个线程内交替执行。这种方式避免了多线程的锁竞争和资源消耗，非常适合IO密集型任务，比如网络请求。

asyncio的优势：

  • 高效并发： 通过事件循环机制实现并发，避免了多线程的开销。
  • 代码简洁： 使用async和await关键字，让异步代码更易读易写。
  • 资源节省： 单线程运行，减少了资源占用。

2. asyncio + aiohttp：并发抓取网页

要进行并发网页抓取，我们需要asyncio和aiohttp这两个好搭档。aiohttp是基于asyncio的异步HTTP客户端，可以让我们以非阻塞的方式发送HTTP请求。

代码示例：

import asyncio
import aiohttp
import random

# 模拟User-Agent
USER_AGENTS = [
    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36",
    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/14.0 Safari/605.1.15",
    "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:89.0) Gecko/20100101 Firefox/89.0",
]

async def fetch_page(session, url):
    """异步抓取网页"""
    try:
        async with session.get(url, headers={'User-Agent': random.choice(USER_AGENTS)}) as response:
            return await response.text()
    except Exception as e:
        print(f"Error fetching {url}: {e}")
        return None

async def main(urls):
    """主函数，并发抓取多个网页"""
    async with aiohttp.ClientSession() as session:
        tasks = [fetch_page(session, url) for url in urls]
        results = await asyncio.gather(*tasks)
        return results

if __name__ == "__main__":
    urls = [
        "https://www.example.com",
        "https://www.baidu.com",
        "https://www.qq.com"
    ]
    results = asyncio.run(main(urls))
    for i, result in enumerate(results):
        if result:
            print(f"抓取 {urls[i]} 成功，内容长度：{len(result)}")
        else:
            print(f"抓取 {urls[i]} 失败")

代码解释：

  1. fetch_page函数： 这是一个异步函数，负责抓取单个网页。它使用aiohttp.ClientSession发送GET请求，并使用await关键字等待响应。random.choice(USER_AGENTS)用于随机选择User-Agent，模拟不同的浏览器。
  2. main函数： 这是主函数，负责创建任务列表并并发执行。它使用asyncio.gather函数并发执行多个fetch_page任务，并等待所有任务完成。
  3. asyncio.run： 用于运行asyncio程序。

3. 反爬策略：见招拆招

很多网站都有反爬机制，防止被恶意抓取。我们需要采取一些策略来应对这些机制，才能顺利地抓取到数据。

3.1 IP限制：使用代理IP池

如果网站检测到来自同一个IP的请求过于频繁，可能会封禁该IP。为了解决这个问题，我们可以使用代理IP池，每次请求都使用不同的IP。

实现步骤：

  1. 获取代理IP： 可以从一些免费的代理IP网站获取，或者购买付费的代理IP服务。注意：免费代理IP的质量通常不高，可能不稳定或速度慢。

  2. 验证代理IP： 获取到的代理IP可能无效，需要进行验证。可以使用aiohttp发送请求，如果能够正常访问，则说明代理IP有效。

    async def validate_proxy(proxy):
    """验证代理IP是否有效"""
    try:
        async with aiohttp.ClientSession() as session:
            async with session.get("https://www.baidu.com", proxy=f"http://{proxy}", timeout=5) as response:
                if response.status == 200:
                    return True
                else:
                    return False
    except:
        return False

  3. 维护代理IP池： 将验证过的有效代理IP存储到列表中，并定期进行验证，移除无效的IP。

  4. 使用代理IP： 在发送请求时，从代理IP池中随机选择一个IP，并将其添加到请求中。

    import random

async def fetch_page(session, url, proxy_pool):
    """使用代理IP抓取网页"""
    proxy = random.choice(proxy_pool)
    try:
        async with session.get(url, proxy=f"http://{proxy}", headers={'User-Agent': random.choice(USER_AGENTS)}) as response:
            return await response.text()
    except Exception as e:
        print(f"Error fetching {url} with proxy {proxy}: {e}")
        return None

3.2 User-Agent轮换：伪装成不同的浏览器

网站可以通过User-Agent来识别客户端，如果所有请求都来自同一个User-Agent，很容易被识别为爬虫。为了避免这个问题，我们可以维护一个User-Agent列表，并在每次请求时随机选择一个User-Agent。

常见的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
  • Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/14.0 Safari/605.1.15
  • Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:89.0) Gecko/20100101 Firefox/89.0
  • Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:89.0) Gecko/20100101 Firefox/89.0
  • Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Edge/91.0.864.59

代码示例：

import random

USER_AGENTS = [
    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36",
    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/14.0 Safari/605.1.15",
    "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:89.0) Gecko/20100101 Firefox/89.0",
]

async def fetch_page(session, url):
    """抓取网页，并使用随机User-Agent"""
    headers = {"User-Agent": random.choice(USER_AGENTS)}
    async with session.get(url, headers=headers) as response:
        return await response.text()

3.3 请求频率限制：放慢你的脚步

如果请求频率过高，网站可能会认为你是爬虫，并限制你的访问。为了避免这个问题，我们可以使用asyncio.sleep函数来控制请求频率，放慢我们的脚步。

代码示例：

import asyncio

async def fetch_page(session, url):
    """抓取网页，并控制请求频率"""
    await asyncio.sleep(random.uniform(0.5, 1.5))  # 随机休眠0.5-1.5秒
    async with session.get(url) as response:
        return await response.text()

3.4 验证码识别：最后的防线

有些网站会使用验证码来防止爬虫。如果遇到验证码，我们可以尝试使用第三方库或人工识别。

  • 第三方库： 可以使用一些OCR（Optical Character Recognition，光学字符识别）库来识别验证码，例如pytesseract。但是，对于复杂的验证码，识别率可能不高。
  • 人工识别： 可以将验证码发送到人工打码平台，让人工来识别。这种方式的识别率较高，但需要付费。

4. 完整代码示例：并发抓取 + 反爬策略

import asyncio
import aiohttp
import random

# 代理IP池（需要自己维护）
PROXY_POOL = [
    "123.123.123.123:8080",
    "456.456.456.456:8080",
]

# 模拟User-Agent
USER_AGENTS = [
    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36",
    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/14.0 Safari/605.1.15",
    "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:89.0) Gecko/20100101 Firefox/89.0",
]

async def fetch_page(session, url, proxy_pool):
    """使用代理IP抓取网页"""
    proxy = random.choice(proxy_pool)
    try:
        await asyncio.sleep(random.uniform(0.5, 1.5))  # 随机休眠0.5-1.5秒
        async with session.get(url, proxy=f"http://{proxy}", headers={'User-Agent': random.choice(USER_AGENTS)}, timeout=10) as response:
            return await response.text()
    except Exception as e:
        print(f"Error fetching {url} with proxy {proxy}: {e}")
        return None

async def main(urls):
    """主函数，并发抓取多个网页"""
    async with aiohttp.ClientSession() as session:
        tasks = [fetch_page(session, url, PROXY_POOL) for url in urls]
        results = await asyncio.gather(*tasks)
        return results

if __name__ == "__main__":
    urls = [
        "https://www.example.com",
        "https://www.baidu.com",
        "https://www.qq.com"
    ]
    results = asyncio.run(main(urls))
    for i, result in enumerate(results):
        if result:
            print(f"抓取 {urls[i]} 成功，内容长度：{len(result)}")
        else:
            print(f"抓取 {urls[i]} 失败")

代码解释：

  • 该代码结合了代理IP池、User-Agent轮换和请求频率限制等多种反爬策略。
  • PROXY_POOL需要自己维护，可以从免费代理IP网站获取，并定期验证。
  • USER_AGENTS列表包含了常见的User-Agent，可以根据需要进行修改。
  • asyncio.sleep函数用于控制请求频率，避免过于频繁的请求。

5. 总结

本文介绍了如何使用Python的asyncio库进行并发网页抓取，并详细讲解了如何处理常见的反爬机制。通过结合代理IP池、User-Agent轮换和请求频率限制等策略，我们可以有效地应对反爬机制，提高爬虫的效率和稳定性。希望本文能够帮助你更好地掌握asyncio并发编程和网络爬虫技术！

温馨提示： 请遵守网站的robots.txt协议，并合理使用爬虫技术，不要对网站造成过大的负担。

点评评价

captcha
健康