代理的设置
我们在第 2 章和第 7 章介绍了很多请求库，例如 urllib、requests、Selenium、Pyppeteer、Playwright 等，但是没有统一梳理过代理的设置方法，本节我们就针对这些库梳理一下代理的设置方法。
准备工作
请先了解一下代理的基本原理，参考本书 1.5 节即可，这有助于更好地理解和学习本节内容。另外，需要先获取一个可用代理，代理就是IP地址和端口的组合，格式是 <ip>:<port>。如果代理需要访问认证，则还需要额外的用户名和密码两个信息。
那怎么获取一个可用代理呢？
使用搜索引擎搜索 “代理” 关键字，会返回许多代理服务网站，网站上有很多免费代理或付费代理，例如快代理的免费 HTTP 代理 https://www.kuaidaili.com/free/ 就提供了很多免费代理，但在大多数情况下这些免费代理并不一定稳定，所以比较靠谱的方法是购买付费代理。付费代理的各大代理商家都有套餐，数量不多，稳定可用，可以自行选购。
除了购买付费代理，也可以在本机配置一些代理软件，具体的配置方法可以参考 https://setup.scrape.center/proxy-client ，运行代理软件后会在本机创建 HTTP 或 SOCKS 代理服务，所以代理地址一般是 127.0.0.1:<port> 这样的格式，不同代理软件使用的端口可能不同。
我的本机上安装着一个代理软件，它会在 7890 端口上创建 HTTP 代理服务，在 7891 端口上创建 SOCKS 代理服务，因此 HTTP 代理地址为 127.0.0.1:7890，SOCKS 代理地址为 127.0.0.1:7891，只要设置了这个代理，就可以成功将本机 IP 切换到代理软件连接的服务器的IP。在本章之后的示例里，我将使用这个代理软件演示设置方法，大家可以替换成自已的可用代理。
设置代理后的测试网址是 http://www.httpbin.org/get ，访问该链接可以得到请求相关的信息，返回结果中的 origin 字段就是客户端的 IP，我们可以根据它判断代理是否设置成功，即是否成功伪装了 IP。
接下来就看一下各个请求库是如何设置代理的吧。
urllib的代理设置
先介绍最基础的 urllib. 代码如下:
from urllib.error import URLError
from urllib.request import ProxyHandler, build_opener
proxy = '127.0.0.1:7890'
proxy_handler = ProxyHandler({
'http': 'http://' + proxy,
'https': 'http://' + proxy
})
opener = build_opener(proxy_handler)
try:
response = opener.open('https://www.httpbin.org/get')
print(response.read().decode('utf-8'))
except URLError as e:
print(e.reason)这里需要借助 ProxyHandler 对象设置代理，参数是字典类型的数据，键名是协议类型，键值是代理地址 (注意，此处的代理地址前面需要加上协议，即 http:// 或者 https://), 当请求链接使用的是 HTTP 协议时，使用 http 键名对应的代理地址，当请求链接使用的是 HTTPS 协议时，使用 https 键名对应的代理地址。这里我们把代理本身设置为使用 HTTP 协议，即代理地址前统一加 http://。
创建完 ProxyHandler 对象之后，调用 build_opener 方法并传入该对象，创建了一个 Opener 对象，赋值为 opener 变量，这样相当于对此对象已经设置好代理了。接着调用 opener 变量的 open 方法，就访问到目标链接。
运行结果如下:
{
"args": {},
"headers": {
"Accept-Encoding": "identity",
"Host": "www.httpbin.org",
"User-Agent": "Python-urllib/3.7",
"X-Amzn-Trace-Id": "Root=1-60e9a1b6-0a20b8a678844a0b2ab4e889"
},
"origin": "210.173.1.204",
"url": "https://www.httpbin.org/get"
}可以看到结果是 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:7890'
proxy_handler = ProxyHandler({
'http': 'http://' + proxy,
'https': 'http://' + proxy
})
opener = build_opener(proxy_handler)
try:
response = opener.open('https://www.httpbin.org/get')
print(response.read().decode('utf-8'))
except URLError as e:
print(e.reason)跟上面的代码相比，这里只是改变了 proxy 变量的值，只需要在原来的值前面加入代理认证的用户名和密码即可，其中 username 是用户名，password 是密码。例如用户名是 foo，密码是 bar，那么代理地址就是 foo:bar@127.0.0.1:7890。
如果代理是 SOCKS 类型，那么可以用如下方式设置代理，注意需要在本机 7891 端口运行一个 SOCKS 代理：
import socks
import socket
from urllib.request import request
from urllib.error import URLError
socks.set_default_proxy(socks.SOCKS5, '127.0.0.1', 7891)
socket.socket = socks.socket
try:
response = request.urlopen('https://www.httpbin.org/get')
print(response.read().decode('utf-8'))
except URLError as e:
print(e.reason)此处需要用到一个 socks 模块，可以执行如下命令安装：
pip3 install PySocks
运行成功后的结果和使用 HTTP 代理的结果一样：
{
"args": {},
"headers": {
"Accept-Encoding": "identity",
"Host": "www.httpbin.org",
"User-Agent": "Python-urllib/3.7",
"X-Amzn-Trace-Id": "Root=1-60e9a1b6-0a20b8a678844a0b2ab4e889"
},
"origin": "210.173.1.204",
"url": "https://www.httpbin.org/get"
}结果中的 origin 字段同样为客户端的 IP，证明 SOCKS 代理设置成功。
requests的代理设置
对于 requests 来说，代理设置非常简单，只需要传入 proxies 参数即可。这里以我本机的代理为例，看一下 requests 的 HTTP 代理设置，代码如下：
import requests
proxy = '127.0.0.1:7890'
proxies = {
'http': 'http://' + proxy,
'https': 'http://' + proxy,
}
try:
response = requests.get('https://www.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",
"Host": "www.httpbin.org",
"User-Agent": "python-requests/2.22.0",
"X-Amzn-Trace-Id": "Root=1-5e8f358d-87913f68a192fb9f87aa0323"
},
"origin": "210.173.1.204",
"url": "https://www.httpbin.org/get"
}和 urllib 一样，当请求链接使用的是 HTTP 协议时，使用 http 键名对应的代理地址，当请求链接使用的是 HTTPS 协议时，使用 https 键名对应的代理地址，不过这里的代理同样统一使用 HTTP 协议。
运行结果中的 origin 字段若是代理服务器的 IP，则证明代理已经设置成功。
如果代理需要认证，那么在代理地址的前面加上用户名和密码即可，写法如下：
proxy = 'username:password@127.0.0.1:7890'
大家在使用时，根据自己的情况替换 username 和 password 字段即可。
如果代理类型是 SOCKS，可以使用如下方式设置代理：
import requests
proxy = '127.0.0.1:7891'
proxies = {
'http': 'socks5://' + proxy,
'https': 'socks5://' + proxy
}
try:
response = requests.get('https://www.httpbin.org/get', proxies=proxies)
print(response.text)
except requests.exceptions.ConnectionError as e:
print('Error', e.args)这里我们需要额外安装一个包 requests[socks]，相关命令如下：
pip3 install "requests[socks]"
运行结果和使用 HTTP 代理的结果完全相同：
{
"args": {},
"headers": {
"Accept": "*/*",
"Accept-Encoding": "gzip, deflate",
"Host": "www.httpbin.org",
"User-Agent": "python-requests/2.22.0",
"X-Amzn-Trace-Id": "Root=1-5e8f364a-589d3cf2500fafd47b5560f2"
},
"origin": "210.173.1.204",
"url": "https://www.httpbin.org/get"
}另外，还有一种设置 SOCKS 代理的方法，即使用 socks 模块，需要安装 socks 库，这种设置方法如下：
import requests
import socks
import socket
socks.set_default_proxy(socks.SOCKS5, '127.0.0.1', 7891)
socket.socket = socks.socksocket
try:
response = requests.get('https://www.httpbin.org/get')
print(response.text)
except requests.exceptions.ConnectionError as e:
print('Error', e.args)运行结果和上面是完全相同的。相比第一种方法，此方法属于全局设置。大家可以在不同情况下选用不同的方法。
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)对于需要认证的代理，也是在代理地址的前面加上用户名和密码，在使用的时候替换 username 和 password 字段：
proxy = 'username:password@127.0.0.1:7890'
运行结果如下：
{
"args": {},
"headers": {
"Accept": "*/*",
"Accept-Encoding": "gzip, deflate",
"Host": "www.httpbin.org",
"User-Agent": "python-httpx/0.18.1",
"X-Amzn-Trace-Id": "Root-1-60e9a3ef-5527ff6320484f8e46d39834"
},
"origin": "210.173.1.204",
"url": "https://www.httpbin.org/get"
}对于 SOCKS 代理，需要安装 httpx-socks[asyncio] 库。安装方法如下：
pip3 install "httpx-socks[asyncio]"
与此同时，需要设置同步模式或异步模式。同步模式的设置方法如下：
import httpx
from httpx_socks import SyncProxyTransport
transport = SyncProxyTransport.from_url('socks5://127.0.0.1:7891')
with httpx.Client(transport=transport) as client:
response = client.get('https://www.httpbin.org/get')
print(response.text)这里设置了一个 Transport 对象，并在其中配置了 SOCKS 代理的地址，同时在声明 httpx 的 Client 对象时将此对象传给 transport 参数，运行结果和刚才一样。
异步模式的设置方法如下：
import httpx
import asyncio
from httpx_socks import AsyncProxyTransport
transport = AsyncProxyTransport.from_url(
'socks5://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 对象，其他的和同步模式一样，运行结果也是一样的。
Selenium的代理设置
Selenium 同样也可以设置代理，这里以 Chrome 浏览器为例介绍设置方法。对于无认证的代理，设置方法如下：
from selenium import webdriver
proxy = '127.0.0.1:7890'
options = webdriver.ChromeOptions()
options.add_argument('--proxy-server=http://' + proxy)
browser = webdriver.Chrome(options=options)
browser.get('https://www.httpbin.org/get')
print(browser.page_source)
browser.close()运行结果如下：
{
"args": {},
"headers": {
"Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8",
"application/signed-exchange;v=b3;q=0.9",
"Accept-Encoding": "gzip, deflate",
"Accept-Language": "zh-CN,zh;q=0.9",
"Host": "www.httpbin.org",
"Upgrade-Insecure-Requests": "1",
"User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_4) AppleWebKit/537.36 (KHTML, like Gecko)
Chrome/80.0.3987.149 Safari/537.36",
"X-Amzn-Trace-Id": "Root=1-5e8f39cd-60930018205fd154a9af39cc"
},
"origin": "210.173.1.204",
"url": "http://www.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)
options = Options()
options.add_argument("--start-maximized")
options.add_extension(plugin_file)
browser = webdriver.Chrome(options=options)
browser.get('https://www.httpbin.org/get')
print(browser.page_source)
browser.close()这里在本地创建了一个 manifest.json 配置文件和 background.js 脚本来设置认证代理。运行代码后，本地会生成一个 proxy_auth_plugin.zip 文件来保存当前的配置。
运行结果和上面一样，origin 字段为客户端的 IP，证明代理设置成功。
SOCKS 代理的设置方式也比较简单，把对应的协议修改为 socks5 即可，如无密码认证的代理设置方法为：
from selenium import webdriver
proxy = '127.0.0.1:7891'
options = webdriver.ChromeOptions()
options.add_argument('--proxy-server=socks5://' + proxy)
browser = webdriver.Chrome(options=options)
browser.get('https://www.httpbin.org/get')
print(browser.page_source)
browser.close()运行结果和上面一样。
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_socks import ProxyConnector
connector = ProxyConnector.from_url('socks5://127.0.0.1:7891')
async def main():
async with aiohttp.ClientSession(connector=connector) as session:
async with session.get('https://www.httpbin.org/get') as response:
print(await response.text())
if __name__ == '__main__':
asyncio.get_event_loop().run_until_complete(main())运行结果依然和之前一样。
另外，aiohttp-socks 库还支持设置 SOCKS4 代理、HTTP 代理以及需要认证的代理，详情可以参考官方介绍。
Pyppeteer的代理设置
对于 Pyppeteer，由于其默认使用的是类似 Chrome 的 Chromium 浏览器，因此设置代理的方法和使用 Chrome 浏览器的 Selenium 一样，例如都是通过 args 参数设置 HTTP 代理的，代码如下：
import asyncio
from pyppeteer import launch
proxy = '127.0.0.1:7890'
async def main():
browser = await launch({'args': ['--proxy-server=http://' + proxy], 'headless': False})
page = await browser.newPage()
await page.goto('https://www.httpbin.org/get')
print(await page.content())
await browser.close()
if __name__ == '__main__':
asyncio.get_event_loop().run_until_complete(main())运行结果如下：
{
"args": {},
"headers": {
"Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,/;q=0.8",
"Accept-Encoding": "gzip, deflate, br",
"Accept-Language": "zh-CN,zh;q=0.9",
"Host": "www.httpbin.org",
"Upgrade-Insecure-Requests": "1",
"User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_4) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/69.0.3494.0 Safari/537.36",
"X-Amzn-Trace-Id": "Root=1-5e8f442c-12b1ed7865b049007267a66c"
},
"origin": "210.173.1.204",
"url": "https://www.httpbin.org/get"
}同样可以通过 origin 字段证明代理设置成功。
SOCKS 代理也一样，只需要将协议修改为 socks5 即可，代码如下：
import asyncio
from pyppeteer import launch
proxy = '127.0.0.1:7891'
async def main():
browser = await launch({'args': ['--proxy-server=socks5://' + proxy], 'headless': False})
page = await browser.newPage()
await page.goto('https://www.httpbin.org/get')
print(await page.content())
await browser.close()
if __name__ == '__main__':
asyncio.get_event_loop().run_until_complete(main())运行结果也是一样的。
Playwright的代理设置
相对 Selenium 和 Pyppeteer，Playwright 的代理设置更加方便，因为其预留了一个 proxy 参数，在启动的时候就可以设置。
对于 HTTP 代理来说，可以这样设置：
from playwright.sync_api import sync_playwright
with sync_playwright() as p:
browser = p.chromium.launch(proxy={
'server': 'http://127.0.0.1:7890'
})
page = browser.new_page()
page.goto('https://www.httpbin.org/get')
print(page.content())
browser.close()在调用 launch 方法的时候，可以传入 proxy 参数，它是一个字典，其中有一个必填的字段叫作 server，这里我们直接填人 HTTP 代理的地址即可。
运行结果如下：
{
"args": {},
"headers": {
"Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/;q=0.8,application/signed-exchange;v=b3;q=0.9",
"Accept-Encoding": "gzip, deflate, br",
"Accept-Language": "zh-CN,zh;q=0.9",
"Host": "www.httpbin.org",
"Sec-Ch-Ua": "\" Not A;Brand\";v=\"99\\\", \"Chromium\";v=\"92\\\"",
"Sec-Ch-Ua-Mobile": "?0",
"Sec-Fetch-Dest": "document",
"Sec-Fetch-Mode": "navigate",
"Sec-Fetch-Site": "none",
"Sec-Fetch-User": "?1",
"Upgrade-Insecure-Requests": "1",
"User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/92.0.4498.0 Safari/537.36",
"X-Amzn-Trace-Id": "Root=1-60e99eef-4fa746a01a38abd469ecb467"
},
"origin": "210.173.1.204",
"url": "https://www.httpbin.org/get"
}对于 SOCKS 代理，设置方法也完全一样，只需要把 server 字段的值换成 SOCKS 代理的地址即可：
from playwright.sync_api import sync_playwright
with sync_playwright() as p:
browser = p.chromium.launch(proxy={
'server': 'socks5://127.0.0.1:7891'
})
page = browser.new_page()
page.goto('https://www.httpbin.org/get')
print(page.content())
browser.close()运行结果和刚才也完全一样。
对于需要认证的代理，只需要在 proxy 参数中额外设置 username 和 password 字段即可，假设用户名和密码分别是 foo 和 bar，则设置方法如下：
from playwright.sync_api import sync_playwright
with sync_playwright() as p:
browser = p.chromium.launch(proxy={
'server': '[可疑链接已删除]',
'username': 'foo',
'password': 'bar'
})
page = browser.new_page()
page.goto('https://www.httpbin.org/get')
print(page.content())
browser.close()