Comment utiliser les modules client HTTP de Python urllib et urllib3

1. urllib

Vue d'ensemble :

urllib est la bibliothèque standard officielle pour demander des connexions URL en Python, même si vous installez Python, cette bibliothèque peut être utilisée directement, couvrant essentiellement les bases de la requête réseau. fonction. En Python2, ce sont principalement urllib et urllib2, et en Python3, ils sont intégrés à urllib. urllib是Python中请求url连接的官方标准库，就是你安装了python，这个库就已经可以直接使用了，基本上涵盖了基础的网络请求功能。在Python2中主要为urllib和urllib2，在Python3中整合成了urllib。

Python3.x中将urllib2合并到了urllib

Dans Python3. Module Request, utilisé pour simuler l'envoi de requêtes

• urllib.error : Module de gestion des exceptions, si des erreurs surviennent, ces exceptions peuvent être interceptées

• urllib.parse : Un module outil qui fournit de nombreux traitements d'URL méthodes, telles que : fractionnement, analyse, fusion, etc. Module .parse
• Il prend en charge le traitement des URL des protocoles suivants : file,ftp,gopher,hdl,http,https,imap,mailto,mms,news,nntp,prospero,rsync,rtsp,rtspu,sftp,sip,sips, snews,svn,snv+ssh,telnet,wais
  1 , urlparse(), urlunparse() : analyser la chaîne d'URL en un tuple

• Syntaxe : urllib.parse.urlparse(urlstring, schéma='',allow_fragments= Vrai)

Vous pouvez transmettre 3 paramètres

urlstring : URL à analyser, chaîne

scheme : C'est le protocole par défaut, tel que http ou https Si l'URL n'a pas de protocole http, il. peut être spécifié par schéma. Si le protocole http est spécifié dans l'URL, il sera spécifié dans l'URL. Efficace

allow_fragments : s'il faut ignorer les fragments ou les points d'ancrage. S'il est défini sur False, la partie du fragment sera ignorée. , sinon il ne sera pas ignoré.

• Cette méthode peut réaliser l'identification et la segmentation d'URL, respectivement
scheme (protocole), netloc (nom de domaine), path (chemin), params (paramètres), requête (conditions de requête), fragment (anchor)

• import urllib.parse
  
  url = "http://www.baidu.com"
  parsed = urllib.parse.urlparse(url)
  print(parsed)
  # 输出：ParseResult(scheme='http', netloc='www.baidu.com', path='', params='', query='', fragment='') #返回的是一个parseresult类型的元组对象，可以通过属性或者索引来获取值

  Contrairement à urlparse(), urlunparse accepte un objet itérable sous la forme d'une liste ou d'un tuple, implémente la construction d'URL

from urllib.parse import urlunparse
data=['http','www.baidu.com','index.html','user','a=6','comment']
print(urlunparse(data)) #构造一个完整的URL

#output
#http://www.baidu.com/index.html;user?a=6#comment

• 2, urlsplit(), urlunsplit() : segmentation et combinaison d'URL
  Semblable à la méthode urlparse(), elle renverra 5 parties, mais fusionnera les paramètres dans le chemin.

from urllib.parse import urlsplit

result = urlsplit('http://www.baidu.com/index.html;user?id=5#comment')
print(result)
print(result.query)
# output
# SplitResult(scheme='http', netloc='www.baidu.com', path='/index.html;user', query='id=5', fragment='comment')
# id=5

Semblable à urlunparse(), c'est également une méthode permettant de combiner diverses parties du lien en un lien complet. Les paramètres transmis sont également des objets itérables, tels que la liste des ancêtres, etc. être 5, qui est omis Params

from urllib.parse import urlsplit,urlunsplit
data=['http','www.baidu.com','index.html','a=5','comment']
result=urlunsplit(data)
print(result)

#output
#http://www.baidu.com/index.html?a=5#comment

3, urlencode(), parse_qs() : chaîne de requête et conversion de type de dictionnaire

urlencode() divise les paires clé-valeur dans le dict avec le connecteur &.

urlencode() est utile lors de la construction de paramètres de requête GET. Il peut convertir les données de requête de type dictionnaire en codage URL

import urllib.parse
dic = {'name':'melon','age':18}
data = urllib.parse.urlencode(dic)

print(data)     #age=18&name=melon

parse_qs() est exactement le contraire de urlencode(). Il est utilisé pour la désérialisation, comme GET Convertir les paramètres. retour au format du dictionnaire

from urllib.parse import urlencode,parse_qs,urlsplit
params = {'username':'zs','password':'123'}
base_url='http://www.baidu.com'
url=base_url+'?'+urlencode(params) #将字典转化为get参数

query=urlsplit(url).query  #获去URL的query参数条件
print(parse_qs(query))  #根据获取的GET参数转换为字典格式

#output
#{'username': ['zs'], 'password': ['123']}

4. quote(), unquote() : encodage et décodage d'URL

quote : traitement d'encodage d'URL, cette méthode peut convertir le contenu au format codé d'URL.

Si les paramètres contiennent du chinois et d'autres codes non-ASCII, cela entraînera parfois des caractères tronqués. Dans ce cas, utilisez cette méthode pour convertir les caractères chinois en codage d'URL

from urllib.parse import quote
key='中文'
url='https://www.baidu.com/s?key='+quote(key)
print(url)

#output
#https://www.baidu.com/s?key=%E4%B8%AD%E6%96%87

unquote(url) : traitement de décodage d'URL, à l'opposé de quote. () , Restaurez les caractères spéciaux sur l'URL

from urllib.parse import quote, urlsplit, unquote

key = '中文'
url = 'https://www.baidu.com/s?key=' + quote(key)
print(url)
unq = urlsplit(url).query.split('=')[1]  # 获取参数值

print(unquote(unq))  # 解码参数

5. urljoin() : Combinez le nom de domaine racine de l'URL et la nouvelle URL en une URL complète

Format : urljoin (baseurl, newurl,allowFrag=None)

En combinant l'URL de base (base) est combinée avec une autre URL (url) pour créer une URL complète, elle utilisera les composants d'URL de base, le protocole (schemm), le nom de domaine (netloc), le chemin (chemin), pour fournir les parties manquantes. de l'URL, et enfin renvoyer les résultats.

base_url fournit trois éléments : schéma, netloc et chemin. Si ces trois éléments n'existent pas dans le nouveau lien, ils seront complétés si le nouveau lien existe, la nouvelle partie lien sera utilisée. et le fragment dans base_url ne fonctionne pas.

L'analyse, l'épissage et la génération de liens peuvent être réalisés via la méthode urljoin().

import urllib.parse

url = "http://www.baidu.com"
new_path = urllib.parse.urljoin(url, "index.html")
print(new_path)
# 输出：<a href="http://www.baidu.com/index.html" rel="external nofollow"   target="_blank">http://www.baidu.com/index.html</a>

3. module urllib.request

1. urlretrieve() : Téléchargez l'URL dans un fichier HTML.

urlretrieve(url,filename,reporthook,data)

Si vous n'écrivez pas le nom du chemin, il sera enregistré en tant que fichier temporaire. Vous pouvez utiliser urllib.urlcleanup() pour nettoyer le cache

file_name = urllib.request.urlretrieve('http://www.baidu.com','%s/baidu.html'%BASE_DIR)

2. urlopen() : méthode pour ouvrir une URL, renvoyer un. objet fichier, puis des fichiers similaires peuvent être traités. La fonction la plus couramment utilisée dans le module opération d'objet

est urlopen():

urllib.request.urlopen(url, data=None, [timeout, ]*, cafile=None, capath=None, cadefault=False, context=None)

Les paramètres sont les suivants :

url : URL de la requête, type str, ou il peut s'agir d'un objet de requête

data : Pour envoyer des données au serveur, le paramètre data est facultatif et le contenu est au format de codage de flux d'octets, c'est-à-dire de type octets. Si le paramètre data est transmis, urlopen. utilisera la méthode Post pour demander.

timeout : définissez le délai d'attente d'accès au site Web en secondes. Si la requête dépasse le délai défini et n'a pas reçu de réponse, une exception sera levée. Les requêtes HTTP, HTTPS et FTP sont prises en charge.

• Autres paramètres : paramètre de contexte, elle doit être de type ssl.SSLContext, utilisée pour spécifier les paramètres SSL. De plus, les deux paramètres cafile et capath précisent respectivement le certificat CA et son chemin, qui sera utilisé lors des liens https. .

1、urlopen的方法：

urlopen返回http.client.HTTPResponse对象，提供方法：

• read()：获取响应返回的数据，只能使用一次。

• readline()：返回得是二进制格式得页面中得第一行

• readlines() ：以二进制格式 返回所有得数据 以列表格式保存

• fileno()：

• close() ：

• info()：返回一个httplib.HTTPMessage 对象，表示远程服务器返回的头信息。

• getcode()：返回Http状态码，如果是http请求，200表示请求成功完成;404表示网址未找到。

• getheaders()：获取返回响应的响应报头。

• geturl()：返回请求的url。

在urlopen()方法中，直接写入要访问的url地址字符串，该方法就会主动的访问目标网址，然后返回访问结果。

返回的访问结果是一个http.client.HTTPResponse对象，使用该对象的read()方法即可获取访问网页获取的数据，这个数据是二进制格式的，所以我们还需要使用decode()方法来将获取的二进制数据进行解码，转换成我们可以看的懂得字符串。

import urllib.request

req = urllib.request.urlopen('http://www.baidu.com')
print(req.read().decode())
print(req.getheaders())  # 以列表元祖对的形式返回响应头信息
print(req.getheader('Content-Type'))  # 返回响应头中的Content-Type值
print(req.info())  # 返回网页的头信息
print(req.info()['Content-Type'])  # 返回响应头中的Content-Type值

2、for循环读取

不需要使用read()方法 。

for line in urlopen('https://。。.html'):
    line = line.decode('utf-8')  # Decoding the binary data to text.
    if 'EST' in line or 'EDT' in line:  # look for Eastern Time
        print(line)

3、GET请求

GET请求和我们平常get访问方式一样,直接把参数写到网址上面就好了。

import urllib.request
import urllib.parse

dic = {'name':'melon','age':18}
data = urllib.parse.urlencode(dic)

req = urllib.request.urlopen('http://127.0.0.1:8000/index?%s'%data) #通过urlopen方法访问拼接好的url

content = req.read()

4、POST请求

在urlopen()方法中，urlopen()默认的访问方式是GET，当在urlopen()方法中传入data参数时，则会发起POST请求。

注意：传递的data数据需要为bytes格式,如data=b'word=hello'。

import urllib.request
import urllib.parse
import json

dic = {'name':'melon','age':18}
data = urllib.parse.urlencode(dic)

req = urllib.request.Request('http://127.0.0.1:8000/index', data.encode()) #encode：将url编码类型的请求数据转变为bytes类型

opener = urllib.request.urlopen(req)
content = json.loads(opener.read().decode()) #read()方法是读取返回bytes数据内容，decode转换后为str

5、请求头参数模拟

当我们需要模拟一些其他的参数的时候，简单的urlopen() 方法已经无法满足我们的需求了，这个时候我们就需要使用下面的urllib.request中的Request对象来帮助我们实现一些其它参数的模拟，比如请求头。

Request对象如下所示：

# Request对象实例化
req   = urllib.request.Request(url, data=None, headers={},origin_req_host=None,unverifiable=False, method=None)

• url：请求的URL，必须传递的参数，其他都是可选参数

• data：上传的数据，必须传bytes字节流类型的数据，如果它是字典，可以先用urllib.parse模块里的urlencode()编码

• headers：它是一个字典，传递的是请求头数据，可以通过它构造请求头，也可以通过调用请求实例的方法add_header()来添加 
  例如：修改User_Agent头的值来伪装浏览器，比如火狐浏览器可以这样设置： 
  {'User-Agent':'Mozilla/5.0 (compatible; MSIE 5.5; Windows NT)'}

• origin_req_host：指请求方的host名称或者IP地址

• unverifiable：表示这个请求是否是无法验证的，默认为False，如我们请求一张图片如果没有权限获取图片那它的值就是true

• method：是一个字符串，用来指示请求使用的方法，如：GET,POST,PUT等

from urllib import request

url='http://httpbin.org/post'
headers={
     'User-Agent':'Mozilla/5.0 (compatible; MSIE 5.5; Windows NT)',
     'Host':'httpbin.org'
 }  #定义头信息

dict={'name':'germey'}

data = bytes(parse.urlencode(dict),encoding='utf-8')
req = request.Request(url=url,data=data,headers=headers,method='POST')
#req.add_header('User-Agent','Mozilla/5.0 (compatible; MSIE 8.4; Windows NT') #也可以request的方法来添加
resp = request.urlopen(req) 
print(resp.read().decode())

3、urllib.request的高级类

BaseHandler类：

在urllib.request模块里的BaseHandler类，他是所有其他Handler的父类，他是一个处理器，比如用它来处理登录验证，处理cookies，代理设置，重定向等

BaseHandler的子类包括：

• HTTPDefaultErrorHandler：用来处理http响应错误，错误会抛出HTTPError类的异常

• HTTPRedirectHandler：用于处理重定向

• HTTPCookieProcessor：用于处理cookies

• ProxyHandler：用于设置代理，默认代理为空

• HTTPPasswordMgr：永远管理密码，它维护用户名和密码表

• HTTPBasicAuthHandler：用户管理认证，如果一个链接打开时需要认证，可以使用它来实现验证功能

build_opener(*handlers)方法用于构建一个自定义的OpenerDirector对象。

build.opener(handler1,handler2…)

之前的urlopen()方法就是urllib提供的一个Opener，通过Handler处理器来构建Opener实现Cookies处理,代理设置，密码设置等

Opener的方法包括：

• add_handler(handler)：添加处理程序到链接中

• open(url,data=None[,timeout])：打开给定的URL与urlopen()方法相同

• error(proto,*args)：处理给定协议的错误

设置全局后既可以用urlopen()方法， 也可以用opener.open() ，不安装的话只能用opener.open()方法

# 将这个opener设置为全局的opener，之后所有的，不管是opener.open()还是urlopen() 发送请求，都将使用自定义
request.install_opener(opener)
resp = request.urlopen(url)

1、密码验证：HTTPBasicAuthHandler和ProxyBasicAuthHandler

HTTPPasswordMgrWithDefaultRealm()类创建一个密码管理对象，用来保存HTTP请求相关的用户名和密码，主要应用两个场景：

• 验证代理授权的用户名和密码(ProxyBasicAuthHandler())

• 验证web客户端的用户名和密码(HTTPBasicAuthHandler())

在下面的方法中我们还用到了一个新的东西，即request.build_opener()方法，其实urlopen()就是通过构造好了的opener对象发送请求，在这里我们使用request.build_opener()方法重构了一个opener()对象，我们可以通过这个对象实现urlopen()实现的任何东西。

from urllib.request import HTTPPasswordMgrWithDefaultRealm,HTTPBasicAuthHandler,build_opener
from urllib.error import URLError

username='username'
passowrd='password'
url='http://localhost'
p=HTTPPasswordMgrWithDefaultRealm() #构造密码管理实例
p.add_password(None,url,username,passowrd) #添加用户名和密码到实例中
auth_handler=HTTPBasicAuthHandler(p) #传递密码管理实例构建一个验证实例
opener=build_opener(auth_handler)  #构建一个Opener
try:
    result=opener.open(url)  #打开链接，完成验证，返回的结果是验证后的页面内容
    html=result.read().decode('utf-8')
    print(html)
except URLError as e:
    print(e.reason)

2、设置Proxy代理：ProxyHandler

使用爬虫来爬取数据的时候，如果过于频繁的访问，而且网站还设有限制的话，很有可能会禁封我们的ip地址，这个时候就需要设置代理，来隐藏我们的真实IP。

urllib提供了urllib.request.ProxyHandler()方法可动态的设置代理IP池。将代理IP以字典形式传入该方法，然后通过urllib.reques.build_opener(）创建opener对象，用该对象的open()方法向服务器发送请求。

from urllib import request
  
url = 'http://httpbin.org/ip'
proxy = {'http': '218.18.232.26:80', 'https': '218.18.232.26:80'}
proxies = request.ProxyHandler(proxy)  # 创建代理处理器
opener = request.build_opener(proxies)  # 创建opener对象
  
resp = opener.open(url)
print(resp.read().decode())

3、添加Cookie：HTTPCookieProcessor

有时候当我们访问一些网站的时候需要进行翻页或者跳转等其它操作，为了防止无法访问我们想要的数据，需要让网站识别我们是同一个用户。这个时候我们就需要带上cookie进行访问。

在设置cookie的时候由于urllib并没有很好的处理cookie的对象，所以在这里我们需要用到一个别的库，即http库，并使用里面的cookiejar来进行cookie的管理：

CookieJar类关系：CookieJar —-派生—->FileCookieJar —-派生—–>MozillaCookieJar和LWPCookieJar

from http import cookiejar
from urllib import request
  
cookie = cookiejar.CookieJar() # 创建一个cookiejar对象
cookies = request.HTTPCookieProcessor(cookie) # 使用HTTPCookieProcessor创建cookie处理器
opener = request.build_opener(cookies) # 并以它为参数创建Opener对象
resp = opener.open('https://www.baidu.com') # 使用这个opener来发起请求
  
# 查看之前的cookie对象，则可以看到访问百度获得的cookie
for i in cookie:
    print(i)

cookies保存到文件：

1、以Mozilla型浏览器的cookies格式：

cookie=http.cookiejar.MozillaCookieJar(filename=fielname)

import http.cookiejar,urllib.request
fielname='cookies.txt'
cookie=http.cookiejar.MozillaCookieJar(filename=fielname) #创建保存cookie的实例，保存浏览器类型的Mozilla的cookie格式
handler=urllib.request.HTTPCookieProcessor(cookie) #构建一个handler
opener=urllib.request.build_opener(handler) #构建Opener
response=opener.open('http://www.baidu.com') #请求
cookie.save(ignore_discard=True,ignore_expires=True)

从文件中读取cookies：

2、也可以保存为libwww-perl(LWP)格式的Cookies文件

cookie=http.cookiejar.LWPCookieJar(filename=fielname)

import http.cookiejar,urllib.request
#fielname='cookiesLWP.txt'
#cookie=http.cookiejar.LWPCookieJar(filename=fielname) #LWP格式的cookies
cookie=http.cookiejar.LWPCookieJar()
cookie.load('cookiesLWP.txt',ignore_discard=True,ignore_expires=True)

handler=urllib.request.HTTPCookieProcessor(cookie) #构建一个handler
opener=urllib.request.build_opener(handler) #构建Opener
response=opener.open('http://www.baidu.com') #请求
print(response.read().decode('utf-8'))

当然，如果把上面这个生成的opener对象使用install_opener方法来设置为全局的，opener对象之后的每次访问都会带上这个cookie。

4、证书验证

通过添加忽略ssl证书验证关闭证书验证,由于urllib并没有很好的处理ssl的对象，所以在这里我们需要用到一个别的库，即ssl库，如下：

import ssl
from urllib import request
 
context = ssl._create_unverified_context()
res = urllib.request.urlopen(request, context=context)

当你 urllib.urlopen一个 https 的时候会验证一次 SSL 证书，当目标使用的是自签名的证书时就会出现一个URLError，如果是这样可以在开头加上

import ssl
ssl._create_default_https_context = ssl._create_unverified_context

四、urllib.error模块

urllib的error模块定义了由request模块产生的异常，如果出现问题，request模块便会抛出error模块中定义的异常。

在urllib中主要设置了两个异常，一个是URLError，一个是HTTPError，HTTPError是URLError的子类。

1、URLError基类

URLError类来自urllib库的error模块，它继承自OSError类，是error异常模块的基类，由request模块产生的异常都可以通过捕获这个类来处理

它只有一个属性reason，即返回错误的原因

from urllib import request,error

try:
    response=request.urlopen('https://hehe,com/index')
except error.URLError as e:
    print(e.reason)  #如果网页不存在不会抛出异常，而是返回捕获的异常错误的原因(Not Found)

reason如超时则返回一个对象

import socket
import urllib.request
import urllib.error
try:
    response=urllib.request.urlopen('https://www.baidu.com',timeout=0.001)
except urllib.error.URLError as e:
    print(e.reason)
    if isinstance(e.reason,socket.timeout):
        print('time out')

2、HTTPError

它是URLError的子类，专门用来处理HTTP请求错误，比如认证请求失败，它有3个属性：

• code：返回HTTP的状态码，如404页面不存在，500服务器错误等

• reason：同父类，返回错误的原因

• headers：返回请求头

举例：

from urllib import request,error

try:
    response=request.urlopen('http://cuiqingcai.com/index.htm')
except error.HTTPError as e:  #先捕获子类异常
    print(e.reason,e.code,e.headers,sep='\n')
except error.URLError as e:  #再捕获父类异常

    print(e.reason)
else:
    print('request successfully')

五、urllib.robotparser模块

利用urllib的robotparser模块，我们可以实现网站Robots协议的分析

1、Robots协议

也称为爬虫协议、机器人协议，它的全名叫做网络爬虫排除标准(Robots Exclusion Protocol)，用来告诉爬虫和搜索引擎哪些网页可以抓取，哪些不可以抓取，它通常是一个robots.txt的文本文件，一般放在网站的根目录下。

当搜索爬虫访问一个站点时，它首先会检查这个站点根目录下是否存在robots.txt文件，如果存在，搜索爬虫会根据其中定义的爬去范围来爬取，如果没有找到，搜索爬虫会访问所有可直接访问的页面

我们来看下robots.txt的样例：

User-agent: *
Disallow: /
Allow: /public/

它实现了对所有搜索爬虫只允许爬取public目录的功能，将上述内容保存为robots.txt文件放在网站根目录下，和网站的入口文件（index.html）放在一起

1、User-agent描述了搜索爬虫的名称，将其设置为*则代表协议对任何爬虫有效，如设置为Baiduspider则代表规则对百度爬虫有效，如果有多条则对多个爬虫受到限制，但至少需要指定一条

一些常见的搜索爬虫名称：

• BaiduSpider 百度爬虫 www.baidu.com

• Googlebot Google爬虫 www.google.com

• 360Spider 360爬虫 www.so.com

• YodaoBot 有道爬虫 www.youdao.com

• ia_archiver Alexa爬虫 www.alexa.cn

• Scooter altavista爬虫 www.altavista.com

2、Disallow指定了不允许抓取的目录，如上例中设置的/则代表不允许抓取所有的页面

3、Allow一般和Disallow一起使用，用来排除单独的某些限制，如上例中设置为/public/则表示所有页面不允许抓取，但可以抓取public目录

设置示例：

#禁止所有爬虫
User-agent: *
Disallow: /

#允许所有爬虫访问任何目录,另外把文件留空也可以
User-agent: *
Disallow:

#禁止所有爬虫访问某那些目录
User-agent: *
Disallow: /home/
Disallow: /tmp/

#只允许某一个爬虫访问
User-agent: BaiduSpider
Disallow:
User-agent: *
Disallow: /

2、rebotparser模块

用来解析robots.txt，该模块提供了一个类RobotFileParser，它可以根据某网站的robots.txt文件来判断一个抓取爬虫时都有权限来抓取这个网页

urllib.robotparser.RobotFileParser(url='')

robotparser类常用的方法：

• set_url()：用来设置robots.txt文件的连接，如果在创建RobotFileParser对象是传入了连接，就不需要在使用这个方法设置了

• read()：读取reobts.txt文件并进行分析，它不会返回任何内容，但执行那个了读取和分析操作

• parse()：用来解析robots.txt文件，传入的参数是robots.txt某些行的内容，并安装语法规则来分析内容

• can_fetch()：该方法传入两个参数，第一个是User-agent，第二个是要抓取的URL，返回的内容是该搜索引擎是否可以抓取这个url,结果为True或False

• mtime()：返回上次抓取和分析robots.txt的时间

• modified()：将当前时间设置为上次抓取和分析robots.txt的时间

from urllib.robotparser import RobotFileParser

rp = RobotFileParser()  #创建对象
rp.set_url('https://www.cnblogs.com/robots.txt') #设置robots.txt连接，也可以在创建对象时指定
rp.read()  #读取和解析文件
print(rp.can_fetch('*','https://i.cnblogs.com/EditPosts.aspx?postid=9170312&update=1')) #判断链接是否可以被抓取

六、urllib3库

urllib3增加了连接池等功能，两者互相都有补充的部分。许多Python的原生系统已经开始使用urllib3。

urllib3提供了很多python标准库urllib里所没有的重要特性：

• 线程安全

• 连接池

• 客户端SSL/TLS验证

• 文件分部编码上传

• 协助处理重复请求和HTTP重定位

• 支持gzip和deflate压缩编码

• 支持HTTP和SOCKS代理

• 100%测试覆盖率

urllib3是一个第三方库，pip安装：

pip install urllib3

通过urllib3访问一个网页，那么必须首先构造一个PoolManager对象，然后通过PoolMagent中的request方法或者 urlopen()方法来访问一个网页，两者几乎没有任何区别。

class urllib3.poolmanager.PoolManager（num_pools = 10，headers = None，** connection_pool_kw ）

生成一个PoolManager所需要的参数：

• num_pools 代表了缓存的池的个数，如果访问的个数大于num_pools，将按顺序丢弃最初始的缓存，将缓存的个数维持在池的大小。

• headers 代表了请求头的信息，如果在初始化PoolManager的时候指定了headers，那么之后每次使用PoolManager来进行访问的时候，都将使用该headers来进行访问。

• ** connection_pool_kw 是基于connection_pool 来生成的其它设置

当访问网页完成之后，将会返回一个HTTPResponse对象。

使用request()或者urlopen()，获取GET请求的响应内容：

import urllib3

data = json.dumps({'abc': '123'})
http = urllib3.PoolManager(num_pools=5, headers={'User-Agent': 'ABCDE'})
  
resp1 = http.request('GET', 'http://www.baidu.com', body=data)
resp2 = http.urlopen('GET', 'http://www.baidu.com', body=data)
  
print(resp2.data.decode())

使用request()或者urlopen()，进行 POST 请求：

import urllib3
import json
  
data = json.dumps({'abc': '123'})
http = urllib3.PoolManager(num_pools=5, headers={'User-Agent': 'ABCDE'})
  
resp1 = http.request('POST', 'http://www.httpbin.org/post', body=data,timeout=5,retries=5)
#resp2 = http.urlopen('POST', 'http://www.httpbin.org/post', body=data,timeout=5,retries=5)
  
print(resp1.data.decode())

注意事项：urllib3 并没有办法单独设置cookie，所以如果你想使用cookie的话，可以将cookie放入到headers中

1、request()和urlopen()方法的区别：

urlopen()比request()有三个参数是不一样的，你会发现request()具有fields，headers两个参数。所以更多的也就使用 request() 方法了。

推荐使用request()来进行访问的，因为使用request()来进行访问有两点好处，

• 可以直接进行post请求，不需要将 data参数转换成JSON格式

• 直接进行GET请求，不需要自己拼接url参数

语法：

• request(self, method, url, fields=None, headers=None, **urlopen_kw)

• urlopen(self, method, url, redirect=True, **kw):

2、设置代理：ProxyManager

如果你需要使用代理来访问某个网站的话, 那么你可以使用 ProxyManager 对象来进行设置

def __init__(self, proxy_url, num_pools=10, headers=None,proxy_headers=None, **connection_pool_kw):

ProxyManager和PoolManager的方法基本完全相同。

import urllib3
import json
 
data = {'abc': '123'}
proxy = urllib3.ProxyManager('http://50.233.137.33:80', headers={'connection': 'keep-alive'})
resp1 = proxy.request('POST', 'http://www.httpbin.org/post', fields=data)
print(resp1.data.decode())

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!