Python3网络爬虫开发实战（9）代理的使用 （需补充代理池的构建）

网站为了避免爬虫采集数据可能会采取一些反爬虫的措施，例如服务器会检测某个 IP 在单位时间内的请求次数，如果这个次数超过了指定的阈值，就直接拒绝服务器，并返回一些错误信息，这种情况称为 封IP；

封IP 的流程是：开始可以正常运行，正常爬取数据，一段时间过后出现错误，比如返回 403 Forbidden，这时打开网页，可能会看到 “您的 IP 访问频率太高” 这样的提示，或者跳出一个验证码让我们识别，通过之后才可以正常访问，但是过一会儿又会变成这样；

代理通过将 IP 伪装起来，让服务器识别不出是由我们本机发起的请求，就可以成功防止封 IP了；

一、代理的设置

代理是 IP 地址和端口的组合，格式是 <ip>:<port>，如果代理需要访问认证，则还需要额外的用户名和密码两个信息；

1.1 urllib 的代理设置

首先我们以最基础的 urllib 为例，来看一下代理的设置方法，代码如下：

from urllib.error import URLError
from urllib.request import ProxyHandler, build_opener

proxy = '127.0.0.1:9743'
proxy_handler = ProxyHandler({
    'http': 'http://' + proxy,
    'https': 'https://' + proxy
})
opener = build_opener(proxy_handler)
try:
    response = opener.open('http://httpbin.org/get')
    print(response.read().decode('utf-8'))
except URLError as e:
    print(e.reason)

运行结果如下：

{"args": {}, 
  "headers": {
    "Accept-Encoding": "identity", 
    "Connection": "close", 
    "Host": "httpbin.org", 
    "User-Agent": "Python-urllib/3.6"
  }, 
  "origin": "106.185.45.153", 
  "url": "http://httpbin.org/get"
}

这里我们需要借助 ProxyHandler 设置代理，参数是字典类型，键名为协议类型，键值是代理。注意，此处代理前面需要加上协议，即 http 或者 https。当请求的链接是 http 协议的时候，ProxyHandler 会调用 http 代理。当请求的链接是 https 协议的时候，会调用 https 代理。此处生效的代理是：http://127.0.0.1:9743。

创建完 ProxyHandler 对象之后，我们需要利用 build_opener 方法传入该对象来创建一个 Opener，这样就相当于此 Opener 已经设置好代理了。接下来直接调用 Opener 对象的 open 方法，即可访问我们所想要的链接。

运行输出结果是一个 JSON，它有一个字段 origin，标明了客户端的 IP。验证一下，此处的 IP 确实为代理的 IP，并不是真实的 IP。这样我们就成功设置好代理，并可以隐藏真实 IP 了。

如果遇到需要认证的代理，我们可以用如下的方法设置：

from urllib.error import URLError
from urllib.request import ProxyHandler, build_opener

proxy = 'username:password@127.0.0.1:9743'
proxy_handler = ProxyHandler({
    'http': 'http://' + proxy,
    'https': 'https://' + proxy
})
opener = build_opener(proxy_handler)
try:
    response = opener.open('http://httpbin.org/get')
    print(response.read().decode('utf-8'))
except URLError as e:
    print(e.reason)

这里改变的只是 proxy 变量，只需要在代理前面加入代理认证的用户名密码即可，其中 username 就是用户名，password 为密码，例如 username 为 foo，密码为 bar，那么代理就是 foo:bar@127.0.0.1:9743。

如果代理是 SOCKS5 类型，那么可以用如下方式设置代理：

import socks
import socket
from urllib import request
from urllib.error import URLError

socks.set_default_proxy(socks.SOCKS5, '127.0.0.1', 9742)
socket.socket = socks.socksocket
try:
    response = request.urlopen('http://httpbin.org/get')
    print(response.read().decode('utf-8'))
except URLError as e:
    print(e.reason)

此处需要一个 socks 模块，可以通过如下命令安装：

pip3 install PySocks

本地我有一个 SOCKS5 代理，运行在 9742 端口，运行成功之后和上文 HTTP 代理输出结果是一样的：

{"args": {}, 
  "headers": {
    "Accept-Encoding": "identity", 
    "Connection": "close", 
    "Host": "httpbin.org", 
    "User-Agent": "Python-urllib/3.6"
  }, 
  "origin": "106.185.45.153", 
  "url": "http://httpbin.org/get"
}

结果的 origin 字段同样为代理的 IP。现在，代理设置成功。

1.2 requests 的代理设置

对于 requests 来说，代理设置更加简单，我们只需要传入 proxies 参数即可。

还是以上例中的代理为例，我们来看下 requests 的代理的设置：

import requests

proxy = '127.0.0.1:9743'
proxies = {
    'http': 'http://' + proxy,
    'https': 'https://' + proxy,
}
try:
    response = requests.get('http://httpbin.org/get', proxies=proxies)
    print(response.text)
except requests.exceptions.ConnectionError as e:
    print('Error', e.args)

运行结果：

{"args": {}, 
  "headers": {
    "Accept": "*/*", 
    "Accept-Encoding": "gzip, deflate", 
    "Connection": "close", 
    "Host": "httpbin.org", 
    "User-Agent": "python-requests/2.18.1"
  }, 
  "origin": "106.185.45.153", 
  "url": "http://httpbin.org/get"
}

可以发现，requests 的代理设置比 urllib 简单很多，它只需要构造代理字典，然后通过 proxies 参数即可，而不需要重新构建 Opener。

其运行结果的 origin 也是代理的 IP，这证明代理已经设置成功。

如果代理需要认证，同样在代理的前面加上用户名密码即可，代理的写法就变成如下所示：

proxy = 'username:password@127.0.0.1:9743'

和 urllib 一样，这里只需要将 username 和 password 替换即可。

如果需要使用 SOCKS5 代理，则可以使用如下方式来设置：

import requests

proxy = '127.0.0.1:9742'
proxies = {
    'http': 'socks5://' + proxy,
    'https': 'socks5://' + proxy
}
try:
    response = requests.get('http://httpbin.org/get', proxies=proxies)
    print(response.text)
except requests.exceptions.ConnectionError as e:
    print('Error', e.args)

在这里，我们需要额外安装一个模块，这个模块叫作requests[socks]，命令如下所示：

pip3 install "requests[socks]"

运行结果是完全相同的：

{"args": {}, 
  "headers": {
    "Accept": "*/*", 
    "Accept-Encoding": "gzip, deflate", 
    "Connection": "close", 
    "Host": "httpbin.org", 
    "User-Agent": "python-requests/2.18.1"
  }, 
  "origin": "106.185.45.153", 
  "url": "http://httpbin.org/get"
}

另外，还有一种设置方式，和 urllib 中的方法相同，使用 socks 模块，也需要像上文一样安装 socks 库。这种设置方法如下所示：

import requests
import socks
import socket

socks.set_default_proxy(socks.SOCKS5, '127.0.0.1', 9742)
socket.socket = socks.socksocket
try:
    response = requests.get('http://httpbin.org/get')
    print(response.text)
except requests.exceptions.ConnectionError as e:
    print('Error', e.args)

使用这种方法也可以设置 SOCKS5 代理，运行结果完全相同。相比第一种方法，此方法是全局设置。我们可以在不同情况下选用不同的方法。

1.3 httpx 的代理设置

httpx 的用法本身就与 requests 的非常相似，所以也是通过 proxies 参数设置的代理，不同之处在于 proxies 参数的键名不能再是 http 和 https，需要改为 \http:// 和 \https://；

设置 HTTP 代理的方式如下

import httpx

proxy = '127.0.0.1:7890'
proxies = {
	"http://": 'http://' + proxy,
	"https://": 'http://' + proxy,
}

with httpx.Client(proxies=proxies) as client:
	response = client.get('https://www.httpbin.org/get')
	print(response.text)

对于需要认证的代理，也是在代理地址的前面加上用户名和密码，在使用的使用替换 usename 和 password 字段；

proxy = 'username:password@127.0.0.1:7890'

对于 SOCKS 代理，需要安装 httpx-socks[asyncio] 库，安装方法如下

pip3 install "httpx-socks[asyncio]"

与此同时，我们需要设置同步模式和异步模式，同步模式的设置方法如下：

import httpx
from httpx_socks import SyncProxyTransport

transport = SyncProxyTransport.from_url('sock5://127.0.0.1:7891')

with httpx.Client(transport=transport) as client:
	response = client.get('https://www.httpbin.org/get')
	print(response.text)

异步模式的设置方法如下：

import httpx
import asyncio
from httpx_socks import AsyncProxyTransport

transport = AsyncProxyTransport.from_url('sock5://127.0.0.1:7891')

async def main():
	async with httpx.AsyncClient(transport=transport) as client:
		response = await client.get('https://www.httpbin.org/get')
		print(response.text)

if __name__ == '__main__':
	asyncio.get_event_loop().run_until_complete(main())

和同步模式不同，此时我们用的 Transport 对象是 AsyncProxyTransport 而不是 SyncProxyTransport，同时需要将 Client 对象更改为 AsyncClient 对象，其他的和同步模式一样，运行结果也是一样的；

1.4 aiohttp 的代理设置

对于 aiohttp，可以通过 proxy 参数直接设置代理，http 代理的设置方式如下：

import asyncio
import aiohttp

proxy = 'http://127.0.0.1:7890'

async def main():
	async with aiohttp.ClientSession() as session:
		async with session.get('https://www.httpbin.org/get', proxy=proxy) as response:
			print(await response.text())

if __name__ == '__main__':
	asyncio.get_event_loop().run_until_complete(main())

如果需要代理认证，就把代理地址改一下

proxy = 'http://username:password@127.0.0.1:7890'

对于 SOCKS 代理，需要安装一个支持库 aiohttp-socks ，安装命令如下

pip3 install aiohttp-socks

可以借助这个库的 ProxyConnector 方法来设置 SOCKS 代理，代码如下：

import asyncio
import aiohttp
from aiohttp_sock5 import ProxyConnector

connector = ProxyConnector.from_url('socks5://127.0.0.1:7890')
async def main():
	async with aiohttp.ClientSession(connector=connector) as session:
		async with session.get('http://www.httpbin.org/get') as response:
			print(await response.text())

if __name__ == '__main__':
	asyncio.get_event_loop().run_until_complete(main())

运行结果和之前一样；

1.4 Selenium 的代理设置

Selenium 同样也可以设置代理，对于 Chrome 来说，用 Selenium 设置代理的方法也非常简单，对于无认证的代理，设置方法如下所示：

from selenium import webdriver

proxy = '127.0.0.1:9743'
chrome_options = webdriver.ChromeOptions()
chrome_options.add_argument('--proxy-server=http://' + proxy)
browser = webdriver.Chrome(chrome_options=chrome_options)
browser.get('http://httpbin.org/get')

在这里我们通过 ChromeOptions 来设置代理，在创建 Chrome 对象的时候用 chrome_options 参数传递即可。

运行代码之后便会弹出一个 Chrome 浏览器，我们访问目标链接之后输出结果如下所示：

{"args": {}, 
  "headers": {
    "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8", 
    "Accept-Encoding": "gzip, deflate", 
    "Accept-Language": "zh-CN,zh;q=0.8", 
    "Connection": "close", 
    "Host": "httpbin.org", 
    "Upgrade-Insecure-Requests": "1", 
    "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_3) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/59.0.3071.115 Safari/537.36"
  }, 
  "origin": "106.185.45.153", 
  "url": "http://httpbin.org/get"
}

代理设置成功，origin 同样为代理 IP 的地址。如果代理是认证代理，则设置方法相对比较麻烦，设置方法如下所示：

from selenium import webdriver
from selenium.webdriver.chrome.options import Options
import zipfile

ip = '127.0.0.1'
port = 7890
username = 'foo'
password = 'bar'

manifest_json = """{"version":"1.0.0","manifest_version": 2,"name":"Chrome Proxy","permissions": ["proxy","tabs","unlimitedStorage","storage","<all_urls>","webRequest","webRequestBlocking"],"background": {"scripts": ["background.js"]
    }
}
"""background_js ="""
var config = {
        mode: "fixed_servers",
        rules: {
          singleProxy: {
            scheme: "http",
            host: "%(ip) s",
            port: %(port) s
          }
        }
      }

chrome.proxy.settings.set({value: config, scope: "regular"}, function() {});

function callbackFn(details) {
    return {
        authCredentials: {username: "%(username) s",
            password: "%(password) s"
        }
    }
}

chrome.webRequest.onAuthRequired.addListener(
            callbackFn,
            {urls: ["<all_urls>"]},
            ['blocking']
)
""" % {'ip': ip, 'port': port, 'username': username, 'password': password}

plugin_file = 'proxy_auth_plugin.zip'
with zipfile.ZipFile(plugin_file, 'w') as zp:
    zp.writestr("manifest.json", manifest_json)
    zp.writestr("background.js", background_js)
chrome_options = Options()
chrome_options.add_argument("--start-maximized")
chrome_options.add_extension(plugin_file)
browser = webdriver.Chrome(chrome_options=chrome_options)
browser.get('http://httpbin.org/get')

这里需要在本地创建一个 manifest.json 配置文件和 background.js 脚本来设置认证代理。运行代码之后本地会生成一个 proxy_auth_plugin.zip 文件来保存当前配置。

得到运行结果和上面一样，origin 字段为客户端的 IP，证明代理设置成功；SOCKS 代理的设置方式也比较简单，把对应的协议修改为 socks5 即可，如无密码认证的代理设置方法为：

from selenium import webdriver

proxy = '127.0.0.1:7890'
chrome_options = webdriver.ChromeOptions()
chrome_options.add_argument('--proxy-server=socks5://' + proxy)
browser = webdriver.Chrome(chrome_options=chrome_options)
browser.get('http://httpbin.org/get')

运行结果和上面一样；

1.6 Playwright 的代理设置

相对 Selenium 和 Pyppeteer，Playwright 的代理设置更加的方便，因为其预留了一个 proxy 参数，在启动的时候就可以设置。

对于 HTTP / SOCKS 代理来说，可以这样设置

from playwright.sync_api import sync_playwright

with sync_playwright() as p:
	browser = p.Chromium.launch(proxy:{
		'server': 'http://127.0.0.1:7890',	
		# 'server': 'socks5://127.0.0.1:7890',	
	})
	page = browser.new_page()
	page.goto('http://www.httpbin.org/get')
	print(page.content())
	browser.close()

二、代理池的构建和维护

2.1 代理池的模块构成

基本模块分为 4 块：存储模块、获取模块、检测模块、接口模块。

![[9-1.jpg]]

• 存储模块：负责存储抓取下来的代理。首先要保证代理不重复，要标识代理的可用情况，还要动态实时处理每个代理，所以一种比较高效和方便的存储方式就是使用 Redis 的 Sorted Set，即有序集合。

• 获取模块：需要定时在各大代理网站抓取代理。代理可以是免费公开代理也可以是付费代理，代理的形式都是 IP 加端口，此模块尽量从不同来源获取，尽量抓取高匿代理，抓取成功之后将可用代理保存到数据库中。

• 检测模块：需要定时检测数据库中的代理。这里需要设置一个检测链接，最好是爬取哪个网站就检测哪个网站，这样更加有针对性，如果要做一个通用型的代理，那可以设置百度等链接来检测。另外，我们需要标识每一个代理的状态，如设置分数标识，100 分代表可用，分数越少代表越不可用。检测一次，如果代理可用，我们可以将分数标识立即设置为 100 满分，也可以在原基础上加 1 分；如果代理不可用，可以将分数标识减 1 分，当分数减到一定阈值后，代理就直接从数据库移除。通过这样的标识分数，我们就可以辨别代理的可用情况，选用的时候会更有针对性。

• 接口模块：需要用 API 来提供对外服务的接口。其实我们可以直接连接数据库来取对应的数据，但是这样就需要知道数据库的连接信息，并且要配置连接，而比较安全和方便的方式就是提供一个 Web API 接口，我们通过访问接口即可拿到可用代理。另外，由于可用代理可能有多个，那么我们可以设置一个随机返回某个可用代理的接口，这样就能保证每个可用代理都可以取到，实现负载均衡。

2.2 代理池的实现

文章中的实现在 Github 上创建了项目：Python3WebSpider/ProxyPool: An Efficient ProxyPool with Getter, Tester and Server (github.com)

其主要项目在 ProxyPool 中的 proxypool 文件夹中，

TodoList