如何用Python编写网络爬虫

用Python编写网络爬虫主要包括以下几个步骤：定义目标、发起请求、解析响应、提取数据、存储数据。选择合适的库、处理异常、设置延时、遵守网站的robots.txt协议、避免IP封禁是编写高效稳定的爬虫的关键。下面将详细介绍如何使用Python编写一个网络爬虫。

一、选择合适的库

Python有许多库可以帮助编写网络爬虫，其中最常用的是requests和BeautifulSoup。requests库用于发送HTTP请求，而BeautifulSoup库用于解析HTML文档。

1. Requests库

Requests库是一个简单易用的HTTP库，可以用于发送GET和POST请求。它的使用非常简单，只需几行代码就能完成一个基本的HTTP请求。

import requests
response = requests.get('https://example.com')
print(response.text)

以上代码发送了一个GET请求，并输出了响应的内容。

2. BeautifulSoup库

BeautifulSoup是一个用于解析HTML和XML文档的库。它可以方便地提取HTML文档中的数据。

from bs4 import BeautifulSoup
html_doc = """
<html><head><title>The Dormouse's story</title></head>
<body>
<p class="title"><b>The Dormouse's story</b></p>
<p class="story">Once upon a time there were three little sisters; and their names were
<a href="http://example.com/elsie" class="sister" id="link1">Elsie</a>,
<a href="http://example.com/lacie" class="sister" id="link2">Lacie</a> and
<a href="http://example.com/tillie" class="sister" id="link3">Tillie</a>;
and they lived at the bottom of a well.</p>
<p class="story">...</p>
</body></html>
"""
soup = BeautifulSoup(html_doc, 'html.parser')
print(soup.prettify())

以上代码解析了一个HTML文档，并输出了格式化后的HTML内容。

二、发起请求

在编写爬虫时，首先需要发起HTTP请求以获取目标网页的内容。可以使用requests库来发起GET或POST请求。

import requests
url = 'https://example.com'
response = requests.get(url)
if response.status_code == 200:
    html_content = response.text
else:
    print(f'Failed to retrieve the page. Status code: {response.status_code}')

上面的代码发送了一个GET请求，并检查响应的状态码。如果请求成功，输出网页内容；否则，输出失败信息。

三、解析响应

获取网页内容后，需要解析HTML文档以提取所需的数据。可以使用BeautifulSoup库来解析HTML文档。

from bs4 import BeautifulSoup
soup = BeautifulSoup(html_content, 'html.parser')
提取所有链接
links = soup.find_all('a')
for link in links:
    print(link.get('href'))

上面的代码解析了HTML文档，并提取了所有链接。

四、提取数据

在解析HTML文档后，可以提取所需的数据。BeautifulSoup提供了多种方法来查找和提取HTML元素。

# 查找所有带有class属性为sister的<a>标签
sisters = soup.find_all('a', class_='sister')
for sister in sisters:
    print(sister.text, sister.get('href'))

上面的代码查找了所有带有class属性为sister的标签，并输出了它们的文本内容和链接。

五、存储数据

提取到的数据可以存储到数据库、文件或其他存储介质中。这里以将数据存储到CSV文件为例。

import csv
data = [{'name': sister.text, 'link': sister.get('href')} for sister in sisters]
with open('sisters.csv', mode='w', newline='') as file:
    writer = csv.DictWriter(file, fieldnames=['name', 'link'])
    writer.writeheader()
    writer.writerows(data)

上面的代码将提取到的数据存储到了CSV文件中。

六、处理异常

在编写爬虫时，可能会遇到各种异常情况，如网络错误、解析错误等。需要处理这些异常以保证爬虫的稳定性。

import requests
from requests.exceptions import RequestException
try:
    response = requests.get(url)
    response.raise_for_status()
except RequestException as e:
    print(f'Error: {e}')

上面的代码处理了请求过程中可能出现的异常。

七、设置延时

为了避免对目标网站造成过大压力，可以在每次请求之间设置延时。可以使用time库来实现。

import time
time.sleep(2)  # 延时2秒

上面的代码在每次请求之间延时2秒。

八、遵守网站的robots.txt协议

robots.txt文件是网站用来告诉爬虫哪些页面可以抓取，哪些页面不能抓取的协议。在编写爬虫时，需要遵守目标网站的robots.txt协议。

import requests
from urllib.robotparser import RobotFileParser
url = 'https://example.com'
robots_url = url + '/robots.txt'
rp = RobotFileParser()
rp.set_url(robots_url)
rp.read()
if rp.can_fetch('*', url):
    response = requests.get(url)
    # 继续处理响应
else:
    print('Crawling disallowed by robots.txt')

上面的代码检查了目标网站的robots.txt文件，并根据robots.txt协议决定是否抓取页面。

九、避免IP封禁

在频繁访问同一个网站时，可能会被网站封禁IP。可以通过使用代理、设置请求头等方式来避免IP封禁。

1. 使用代理

可以通过requests库的proxies参数来使用代理。

proxies = {
    'http': 'http://10.10.1.10:3128',
    'https': 'http://10.10.1.10:1080',
}
response = requests.get(url, proxies=proxies)

上面的代码使用了HTTP和HTTPS代理。

2. 设置请求头

可以通过requests库的headers参数来设置请求头，以模拟浏览器请求。

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)

上面的代码设置了User-Agent请求头。

十、完整示例

下面是一个完整的示例，演示如何编写一个简单的网络爬虫，爬取豆瓣电影Top250，并将数据存储到CSV文件中。

import requests
from bs4 import BeautifulSoup
import csv
import time
def fetch_page(url):
    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:
        response = requests.get(url, headers=headers)
        response.raise_for_status()
        return response.text
    except requests.RequestException as e:
        print(f'Error: {e}')
        return None
def parse_page(html):
    soup = BeautifulSoup(html, 'html.parser')
    movies = []
    for item in soup.find_all('div', class_='item'):
        rank = item.find('em').text
        title = item.find('span', class_='title').text
        rating = item.find('span', class_='rating_num').text
        movies.append({'rank': rank, 'title': title, 'rating': rating})
    return movies
def save_to_csv(data, filename):
    with open(filename, mode='w', newline='', encoding='utf-8') as file:
        writer = csv.DictWriter(file, fieldnames=['rank', 'title', 'rating'])
        writer.writeheader()
        writer.writerows(data)
def main():
    base_url = 'https://movie.douban.com/top250'
    all_movies = []
    for start in range(0, 250, 25):
        url = f'{base_url}?start={start}'
        html = fetch_page(url)
        if html:
            movies = parse_page(html)
            all_movies.extend(movies)
            time.sleep(2)  # 延时2秒
    save_to_csv(all_movies, 'douban_top250.csv')
if __name__ == '__main__':
    main()

这个示例演示了如何使用requests和BeautifulSoup库编写一个网络爬虫。爬虫首先发起HTTP请求获取网页内容，然后解析HTML文档提取数据，最后将数据存储到CSV文件中。同时，爬虫还处理了请求异常，并在每次请求之间设置了延时以避免对目标网站造成过大压力。

十一、进阶技巧

1. 使用Scrapy框架

Scrapy是一个功能强大的Python爬虫框架，适用于编写复杂的爬虫。它提供了许多高级功能，如自动处理请求、解析响应、存储数据等。

import scrapy
class QuotesSpider(scrapy.Spider):
    name = 'quotes'
    start_urls = [
        'http://quotes.toscrape.com/page/1/',
    ]
    def parse(self, response):
        for quote in response.css('div.quote'):
            yield {
                'text': quote.css('span.text::text').get(),
                'author': quote.css('span.small::text').get(),
                'tags': quote.css('div.tags a.tag::text').getall(),
            }
        next_page = response.css('li.next a::attr(href)').get()
        if next_page is not None:
            yield response.follow(next_page, self.parse)

上面的代码使用Scrapy框架编写了一个爬虫，从 http://quotes.toscrape.com/页面爬取名言并提取相关数据。

2. 使用多线程和异步IO

在编写高效的爬虫时，可以使用多线程和异步IO来提高爬取速度。Python的threading和asyncio库可以帮助实现多线程和异步IO。

多线程示例

import threading
def fetch_page(url):
    # 发起请求并处理响应
    pass
urls = ['https://example.com/page1', 'https://example.com/page2', ...]
threads = []
for url in urls:
    thread = threading.Thread(target=fetch_page, args=(url,))
    thread.start()
    threads.append(thread)
for thread in threads:
    thread.join()

异步IO示例

import aiohttp
import asyncio
async def fetch_page(session, url):
    async with session.get(url) as response:
        return await response.text()
async def main():
    async with aiohttp.ClientSession() as session:
        tasks = []
        urls = ['https://example.com/page1', 'https://example.com/page2', ...]
        for url in urls:
            tasks.append(fetch_page(session, url))
        responses = await asyncio.gather(*tasks)
asyncio.run(main())

十二、总结

通过以上步骤，可以编写一个功能完善的Python网络爬虫。选择合适的库、处理异常、设置延时、遵守网站的robots.txt协议、避免IP封禁是编写高效稳定的爬虫的关键。在实际应用中，根据具体需求和目标网站的特点，可以选择合适的技术和框架来编写爬虫。无论是简单的requests和BeautifulSoup组合，还是功能强大的Scrapy框架，都能帮助我们高效地完成爬取任务。