PYTHON爬虫之urllib库学习笔记

最新推荐文章于 2024-04-23 16:42:17 发布

牧笛yo

最新推荐文章于 2024-04-23 16:42:17 发布

阅读量1k

点赞数

分类专栏： python(urllib) 文章标签： python

本文链接：https://blog.csdn.net/qq_41007358/article/details/122242295

版权

python(urllib) 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

urllib.request.urlopen

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

urllib.request模块提供了最基本的构造HTTP请求的方法，利用这个模块可以模拟浏览器的请求发起过程，同时它还具有处理授权验证（Authentication）、重定向（Redirection）、浏览器的Cookie以及其他一些功能。

示例1：
from urllib import request

response = request.urlopen('https://www.python.org')
print(response.read().decode('utf-8'))


# 利用type方法输出响应的类型：
print(type(response))

输出结果：
<!doctype html>
<!--[if lt IE 7]> <html class="no-js ie6 lt-ie7 lt-ie8 lt-ie9"> <![endif]-->
<!--[if IE 7]> <html class="no-js ie7 lt-ie8 lt-ie9"> <![endif]-->
...
...
...
</body>
</html>

<class 'http.client.HTTPResponse'>

可以看出响应是一个HTTPResponse类型的对象，主要包括read、readinfo、getheader、getheaders、fileno等方法，以及msg、version、status，reason、debuglevel、closed等属性。

例如：调用read方法可以得到响应的网页内容、调用status属性可以得到响应结果的状态码（200代表请求成功，404代表网页未找到等）

示例2：

from urllib import request

response = request.urlopen('https://www.python.org')
print(response.read().decode('utf-8'))

print(response.status)
print(response.getheaders())
print(response.getheader('Server'))



输出结果：
200
[('Connection', 'close'), ('Content-Length', '49670'), ('Server', 'nginx'), ('Content-Type', 'text/html; charset=utf-8'), ('X-Frame-Options', 'DENY'), ('Via', '1.1 vegur, 1.1 varnish, 1.1 varnish'), ('Accept-Ranges', 'bytes'), ('Date', 'Wed, 29 Dec 2021 09:31:50 GMT'), ('Age', '2676'), ('X-Served-By', 'cache-iad-kiad7000049-IAD, cache-hnd18720-HND'), ('X-Cache', 'HIT, HIT'), ('X-Cache-Hits', '3, 1891'), ('X-Timer', 'S1640770310.024764,VS0,VE0'), ('Vary', 'Cookie'), ('Strict-Transport-Security', 'max-age=63072000; includeSubDomains')]
nginx

前两个输出分别是响应的状态码和响应的头信息；最后一个输出是调用getheader方法，并传入参数“Server”，获取了响应头中的Server的值，结果为Nginx，意思是服务器是用Nginx搭建的。

示例3:

from urllib import request, parse

data = bytes(parse.urlencode({'name': 'germey'}), encoding='utf8')
response = request.urlopen('https://httpbin.org/post', data=data)
print(response.read().decode('utf8'))


输出结果：
{
"args": {},
"data": "",
"files": {},
"form": {
"name": "germey"
},
"headers": {
"Accept-Encoding": "identity",
"Content-Length": "11",
"Content-Type": "application/x-www-form-urlencoded",
"Host": "httpbin.org",
"User-Agent": "Python-urllib/3.9",
"X-Amzn-Trace-Id": "Root=1-61cc2dfc-31edc71e230839d00e55fbbd"
},
"json": null,
"origin": "111.197.252.43",
"url": "https://httpbin.org/post"
}

data参数是可选的，在添加该参数时，需要使用bytes方法将参数转化为字节流编码格式的内容，及bytes类型。另外如果传递了参数，那么他的请求方式就不再是GET，而是POST了。

bytes方法的第一个参数得是str（字符串）类型，因此用urllib.parse模块里的urlencode方法将字典参数转化为字符串；第二个参数用于指定编码格式，这里指定为utf-8.

示例4:

import socket
from urllib import request, error

try:
response = request.urlopen('https://www.python.org', timeout=0.1)
except error.URLError as e:
    if isinstance(e.reason, socket.timeout):
    print('TIME OUT')



输出结果：
TIME OUT

timeout参数用于设置超时时间，单位为妙。这里设置超时时间为0.1秒，然后捕获到URLError这个异常，并判断异常类型是socket.timeout，意思是超时异常，最后打印超时。

除了data参数和timeout参数，urlopen方法还有context参数，改参数必须是ssl.SSLContext类型，用来指定SSL的设置。

此外，cafile和差capath这两个参数分别用来指定CA证书和其他路径，这两个在请求HTTPS连接时会有用。

cadefault参数现在已经弃用了，其默认值为False。

urllib.request.Request

class urllib.request.Request(url, data=None, headers={}, origin_req_host=None, unverifiable=False, method=None)

利用urlopen方法可以发起最基本的请求，但他那几个简单的参数并不足以构建一个完整的请求，如果需要往请求中加入Headers等信息，就得利用更强大的Request类来构建请求了。

第一个参数url用于请求URL，这是必传参数，其他都是可选。

示例1：

import urllib.request

request = urllib.request.Request('https://www.python.org') 
response = urllib.request.urlopen(request)

print(response.read().decode('utf-8'))

依然用urlopen方法来发送请求，只不过这次该方法的参数不再是URL，而是一个Request类型的对象。通过构造这个数据结构，一方面可以将请求独立成一个对象，另一方面可更加丰富和灵活地配置参数。

示例2：

from fake_useragent import UserAgent
from urllib import request, parse


url = 'https://httpbin.org/post'
headers = {
'User-Agent': UserAgent().chrome
}

dict = {'name': 'germey'}
data = bytes(parse.urlencode(dict), encoding='utf8')
req = request.Request(url=url, data=data, headers=headers, method='POST')
response = request.urlopen(req)

print(response.read().decode('utf-8'))



输出结果：
{
"args": {},
"data": "",
"files": {},
"form": {
"name": "germey"
},
"headers": {
"Accept-Encoding": "identity",
"Content-Length": "11",
"Content-Type": "application/x-www-form-urlencoded",
"Host": "httpbin.org",
"User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_7_5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/27.0.1453.93 Safari/537.36",
"X-Amzn-Trace-Id": "Root=1-61cc3d86-3a80cb3728a01f9938f689c3"
},
"json": null,
"origin": "111.197.252.43",
"url": "https://httpbin.org/post"
}

高级用法（Handler）

Handler可以理解为各种处理器，有专门处理登录验证的、处理Cookie的、处理代理设置的。利用这些Handler，我们几乎可以实现HTTP请求中所有功能。首先介绍urllib.request模块里的BaseHandler类，这是其他所有Handler类的父类。它提供了最基本的方法，例如 default_open、protocol_request等。

HTTPDefaultErrorHandler 为 HTTP 错误响应定义的默认 handler，所有出错响应都会转为 HTTPError 异常。
HTTPRedirectHandler 一个用于处理重定向的类。
HTTPCookieProcessor 一个用于处理 HTTP Cookies 的类。
ProxyHandler 用于设置代理，代理默认为空。
HTTPPasswordMgr 用于管理密码，它维护着用户名密码对照表。
HTTPBasicAuthHandler 用于管理认证，如果一个链接在打开时需要认证，那么可以用这个类来解决认证。

另一个比较重要的类是OpenerDirector，我们可以称之为Opener，我们之前用过的urlopen方法，实际上就是urllib库为我们提供的一个Opener。

opener用来实现更高级的功能，之前使用的Request类和urlopen类相当于类库已经封装好的极其常用的请求，利用这两个类可以完成基本的请求，但是现在我们需要实现更高级的功能，就需要深入一层进行配置，使用更底层的实例来完成操作，所以这里就用到了Opener。

pener类可以提供open方法，该方法返回的响应类型和urlopen方法如出一辙。

Opener类和Handler类关系：利用Handler类来构建Opener类。

示例1（登录验证①）

基本 HTTP 认证示例（python官网示例）：


import urllib.request

# Create an OpenerDirector with support for Basic HTTP Authentication...
auth_handler = urllib.request.HTTPBasicAuthHandler()
auth_handler.add_password(realm='PDQ Application',
uri='https://mahler:8092/site-updates.py',
user='klem',
passwd='kadidd!ehopper')
opener = urllib.request.build_opener(auth_handler)

# ...and install it globally so it can be used with urlopen.
urllib.request.install_opener(opener)
urllib.request.urlopen('http://www.example.com/login.html')

这个示例有问题，执行报401错误，即认证失败。

示例2（登录验证②）

基本 HTTP 认证示例（python教材）：

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

ssl._create_default_https_context = ssl._create_unverified_context



username = 'admin'
password = 'admin'
url = 'https://ssr3.scrape.center/'



p = HTTPPasswordMgrWithDefaultRealm() # 实例化
p.add_password(None, url, username, password) # 添加url及用户和密码
auth_handler = HTTPBasicAuthHandler(p)
opener = build_opener(auth_handler)



try:
    result = opener.open(url)
    html = result.read().decode('utf-8')
    print(html)
except URLError as e:
    print(e.reason)

上面代码执行多次会产生（http.client.RemoteDisconnected: Remote end closed connection without response）报错，应该是有反爬机制，加个header应该可以解决。

这个网站启用了基本的身份认证，英文叫做HTTP Basic Access Authentication，这是一种登录验证方式，允许网页浏览器或其他客户端程序在请求网站时提供用户名和口令形式的身份凭证。

爬虫可以借助HTTPBasicAuthHandler模块可以完成登录：

示例3（登录验证③）

基本 HTTP 认证示例（自写）：

import ssl
from urllib import request
from fake_useragent import UserAgent

# 利用非认证上下文环境替换认证的上下文环境
ssl._create_default_https_context = ssl._create_unverified_context

username = 'admin'
password = 'admin'
url = 'https://ssr3.scrape.center'

headers = {
'User-Agent': UserAgent().chrome
}

# 构建一个密码管理对象，用来保存需要处理的用户名和密码
auth_handler = request.HTTPPasswordMgrWithDefaultRealm()


# 添加账户信息，第一个参数realm是与远程服务器相关的域信息，一般没人管它都是写None，后面三个参数分别是 代理服务器、用户名、密码
auth_handler.add_password(None,url,username,password)

# 构建一个HTTP基础用户名/密码验证的HTTPBasicAuthHandler处理器对象，参数是创建的密码管理对象
auth_handler = request.HTTPBasicAuthHandler(auth_handler) # Web客户端授权验证

# 通过 build_opener()方法使用这些代理Handler对象，创建自定义opener对象
opener = request.build_opener(auth_handler)

# 可以选择通过install_opener()方法定义opener为全局opener
request.install_opener(opener)

# 构建 Request对象
req = request.Request('https://ssr3.scrape.center/detail/1', headers=headers)

# 定义opener为全局opener后，可直接使用urlopen()发送请求
html = request.urlopen(req)

# 打印响应内容
print(html.read().decode('utf-8'))

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

验证代理授权的用户名和密码 (ProxyBasicAuthHandler())
验证Web客户端的的用户名和密码 (HTTPBasicAuthHandler())

HTTPBasicAuthHandler()

HTTPBasicAuthHandler处理器（Web客户端授权验证）

有些Web服务器（包括HTTP/FTP等）访问时，需要进行用户身份验证，爬虫直接访问会报HTTP 401 错误，表示访问身份未经授权：

urllib2.HTTPError: HTTP Error 401: Unauthorized

示例4（代理①）：


通过代理访问指定域名

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

# 地址来自互联网https://www.kuaidaili.com/free/ 免费代理
proxy_handler = ProxyHandler({
'http': 'http://122.234.169.7:8060',
})

opener = build_opener(proxy_handler)

try:

    response = opener.open('https://www.python.org')
    print(response.read().decode('utf8'))
except URLError as e:
    print(e.reason)

上面使用了ProxyHandler，其参数是一个字典，键名是协议类型（例如HTTP或者HTTPS等）、键值是代理链接，可以添加多个代理。

然后利用这个Handler和build_opener方法构建一个Opener，之后发送请求即可。

示例5（Cookie）：

import http.cookiejar
import urllib.request

cookie = http.cookiejar.CookieJar()
handler = urllib.request.HTTPCookieProcessor(cookie)
opener = urllib.request.build_opener(handler)
response = opener.open('http://www.baidu.com')
for item in cookie:
print(item.name + "=" + item.value)


输出结果：
BAIDUID=9E184E082886B15B00092354EC64327E:FG=1
BIDUPSID=9E184E082886B15BF00CC7B70C8D41FD
H_PS_PSSID=35104_31254_35629_35488_35457_34584_35491_35245_35541_35644_35323_26350_35649_35599_22159
PSTM=1640838850
BDSVRTM=0
BD_HOME=1

利用http.cookiejar.CookieJar()创建一个CookieJar对象
然后利用HTTPCookieProcessor来创建一个Handler
最后再利用build_opener()方法构造出Opener
执行open函数即可获得对应网站的cookie

可以看到，这里分别输出了每个Cookie条目的名称和值。

示例6（保存Cookie到文件）：

import http.cookiejar
import urllib.request

filename = 'cookies.txt'
cookie = http.cookiejar.MozillaCookieJar(filename)
handler = urllib.request.HTTPCookieProcessor(cookie)
opener = urllib.request.build_opener(handler)
response = opener.open('http://www.baidu.com')
cookie.save(ignore_discard=True, ignore_expires=True)



文件内容：

# Netscape HTTP Cookie File
# http://curl.haxx.se/rfc/cookie_spec.html
# This is a generated file! Do not edit.


.baidu.com TRUE / FALSE 1672375197 BAIDUID 94CC55FB0377C5488F7088AC21CF80D0:FG=1
.baidu.com TRUE / FALSE 3788322844 BIDUPSID 94CC55FB0377C548BBFC425E5B3D759E
.baidu.com TRUE / FALSE H_PS_PSSID 35638_34445_35106_31253_35457_34584_35491_35245_35644_35318_26350_35478_35599_35562
.baidu.com TRUE / FALSE 3788322844 PSTM 1640839198
www.baidu.com FALSE / FALSE BDSVRTM 0
www.baidu.com FALSE / FALSE BD_HOME 1

保存Cookie需要将CookieJar换成MozillaCookieJar，它会在生成文件时用到，是CookieJar的子类，可以用来处理跟Cookie和文件相关的事件。另外，LWPCookieJar同样可以读取和保存Cookie，只是Cookie文件的保存格式和MozillaCookieJar不一样，他保存成LWP（libwww-perl）格式。

代码如：

cookie = http.cookiejar.LWPCookieJar(filename)




生成内容如下：

#LWP-Cookies-2.0
Set-Cookie3: BAIDUID="1888EA4AEB12F1B2E1D38313C256FB69:FG=1"; path="/"; domain=".baidu.com"; path_spec; domain_dot; expires="2022-12-30 04:46:54Z"; comment=bd; version=0
Set-Cookie3: BIDUPSID=1888EA4AEB12F1B2BF2AE33477A076D3; path="/"; domain=".baidu.com"; path_spec; domain_dot; expires="2090-01-17 08:01:01Z"; version=0
Set-Cookie3: H_PS_PSSID=35638_35105_31660_35626_35456_34584_35491_35580_35541_35234_35644_35318_26350_35475_35599_35562; path="/"; domain=".baidu.com"; path_spec; domain_dot; discard; version=0
Set-Cookie3: PSTM=1640839615; path="/"; domain=".baidu.com"; path_spec; domain_dot; expires="2090-01-17 08:01:01Z"; version=0
Set-Cookie3: BDSVRTM=0; path="/"; domain="www.baidu.com"; path_spec; discard; version=0
Set-Cookie3: BD_HOME=1; path="/"; domain="www.baidu.com"; path_spec; discard; version=0

示例7（加载本地Cookile）

import http.cookiejar
import urllib.request



cookie = http.cookiejar.LWPCookieJar()
cookie.load('cookies.txt', ignore_discard=True, ignore_expires=True)
handler = urllib.request.HTTPCookieProcessor(cookie)
opener = urllib.request.build_opener(handler)
response = opener.open('http://www.baidu.com')
print(response.read().decode('utf8'))

调用load方法来读取本地已经生成的LWPCookieJar格式的Cookie文件。

处理异常（URLError、HTTPError）

URLError

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

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

示例1（处理异常①）


代码：
from urllib import request, error

try:
    response = request.urlopen('https://cuiqingcai.com/404')
except error.URLError as e:
    print(e.reason)



输出结果:
Not Found

捕获异常，可以避免程序异常终止，同事异常得到了有效的处理.

HTTPError

HTTPError是URLError的子类,专门用来处理HTTP请求错误,如:认证请求失败等,有三个属性:

示例2（处理异常②）

代码：
from urllib import request, error


try:
    response = request.urlopen('https://cuiqingcai.com/404')
except error.HTTPError as e:
    print(e.reason, e.code, e.headers, sep='\n')



输出结果：
Not Found
404
Server: GitHub.com
...
...
...
Connection: close
X-Cache-Lookup: Cache Miss

code:返回HTTP状态码，例如404表示网页不存在，500表示服务器内部错误等。
reason:同父类一样，返回错误的原因。
headers:返回请求头。

这里捕获了HTTPError异常，输出了reason、code、headers属性。

示例3（处理异常③）

from urllib import request, error

try:
    response = request.urlopen('https://cuiqingcai.com/404')
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 Succcessfully')

因为URLError是HTTPError的父类，所以可以先选择捕获子类的错误，再捕获父类的错误。

示例4（reason属性）

import socket
from urllib import request, error

try:
    response = request.urlopen('https://www.baidu.com', timeout=0.01)
except error.URLError as e:
    print(type(e.reason))
    if isinstance(e.reason, socket.timeout):
        print('TIME OUT')


输出结果：
<class 'socket.timeout'>
TIME OUT

reason属性，反悔的不一定是字符串，也可能是一个对象

解析链接（parse）

urllib还提供了一个parse模块，这个模块定义了处理URL的标准接口，例如实现URL各部分的抽取、合并以及链接转换。它支持如协议的URL处理：file、ftp、gopher、hdl、http、https、imap、mailto、mms、news、nntp、prospero、rsync、rtsp、rtspu....

parse模块中的常用方法：

方法说明

urlparse() 实现URL的识别和分段,返回六部分

urlunparse() urlparse的对立方法,参数必须可迭代,且长度必须为6,否则会发生异常

urlsplit() 不单独解析params(合并到path),返回5部分

urlunsplit() 与urlunparse类似,参数必须可迭代,但长度必须为5,否则会发生异常

urljoin() 第一个参数为基础链,第二个参数为新的链接,该方法会分析基础链的scheme,netloc和path,并然后对新链接缺失部分进行补充,最后返回结果

urlencode() 先声明一个字典表示参数,然后调用urlencode()方法将其序列化为GET请求参数

parse_qs() 反序列化,将GET请求参数转换回字典

parse_qsl() 与parse_qs功能相似,但是转换回类别形式的列表

quote() 将内容转化为URL编码的格式.URL中带有中文参数时,可能导致乱码的问题,这个时候可使用quote将中文转换为URL编码

unquote() 进行URL解码

示例1（urlparse）：

from urllib.parse import urlparse

result = urlparse('http://www.baidu.com/index.html;user?id=5#comment')
print(type(result))

print(result)



输出结果：
<class 'urllib.parse.ParseResult'>
ParseResult(scheme='http', netloc='www.baidu.com', path='/index.html', params='user', query='id=5', fragment='comment')

可以发现，urlparse方法在解析URL时有特定的分隔符。如下：

://前面的是scheme代表协议

第一个/前面的是netloc,即域名

后面的是path,即访问路径

分号;前面的是params,代表参数

问号?后面的是查询条件query,一般用作GET类型的URL

井字#后面的是锚点

示例2（urlunparse）：

urlunparse和urlparse相反，用于构造URL，这个方法接收的参数是一个可迭代对象，其长度必须是6。



代码：
from urllib.parse import urlunparse

data = ['https', 'www.baidu.com', '/index.html', 'user', 'id=5', 'comment']
print(urlunparse(data))


输出结果：
https://www.baidu.com/index.html;user?id=5#comment

这里参数data用了列表类型，当然，也可以用其他类型，例如元组或者特定的数据结构。

示例3（urlsplit）：

urlsplit方法和urlparse方法非常相似，只不过它不再单独解析params这一部分（params会合并到path中），只返回5个结果。



from urllib.parse import urlsplit


result = urlsplit('https://www.baidu.com/index.html;user?id=5#comment')

print(result)
print(result.scheme, result[0])


输出结果：
SplitResult(scheme='https', netloc='www.baidu.com', path='/index.html;user', query='id=5', fragment='comment')
https https

返回结果是SplitResult，这也是一个元组，即可以用属性名获取其值，也可以用索引获取。

示例4（urlunsplit）：

from urllib.parse import urlunsplit


data = ['https', 'www.baidu.com', 'index.html', 'a=6', 'comment']
print(urlunsplit(data))


输出结果：
https://www.baidu.com/index.html?a=6#comment

与urlunparse方法类似，唯一区别是这里面参数长度必须为5.

示例4（urljoin）：

除了urlunplist（）方法和urlunparse（）方法



还有就是生成链接的urljoin方法，我们可以提供一个base_url(基础链接)作为第一个参数，将新的链接作为第二参数，该方法会分析base_url的scheme，netloc，path这三个内容并对新链接缺失的部分进行补充，最后返回结果



from urllib.parse import urljoin



print(urljoin('http://www.baidu.com','FAQ.html'))
print(urljoin('http://www.baidu.com','https://cuiqingcai.com/FAQ.html'))



运行结果：
http://www.baidu.com/FAQ.html
https://cuiqingcai.com/FAQ.html

示例5（urlencode）：

urllib库里面有个urlencode函数，可以把key-value这样的键值对转换成我们想要的格式，返回的是a=1&b=2这样的字符串。



代码：
from urllib.parse import urlencode

params = {
    'name': 'germey',
    'age': '25'
}


base_url = 'https://www.baidu.com'
url = base_url + urlencode(params)
print(url)


输出结果：
https://www.baidu.comname=germey&age=25

非常常用，为了更方便的构造参数，我们会事先用字典将参数表示出来，然后将字典转化为URL的参数时，只需要调用该方法即可。

示例6（parse_qs）：



有了序列化，必然有反序列化，利用parse_qs方法，可以将一串GET请求参数转回字典



代码：
from urllib.parse import parse_qs


query = 'name=germey&age=25'
print(parse_qs(query))


输出结果：
{'name': ['germey'], 'age': ['25']}

URL参数成功转回字典类型

示例7（parse_qsl）：



parse_qsl方法用于将参数转化为由元组组成的列表。



代码：
from urllib.parse import parse_qsl


query = 'name=germey&age=25'
print(parse_qsl(query))



输出结果：
[('name', 'germey'), ('age', '25')]

可以看到，运行结果是一个列表，该列表中每一个元素都是一个元组，元组的第一个内容是参数名，第二内容是参数值。

示例8（quote）：



该方法可以将内容转化为URL编码的格式，当URL中带有中文参数时，有可能导致乱码问题，此时用quote方法可以将中文字符串转化为URL编码。



代码：
from urllib.parse import quote


keyword = '壁纸'
url = 'https://www.baidu.com/s?wd=' + quote(keyword)
print(url)



输出结果：
https://www.baidu.com/s?wd=%E5%A3%81%E7%BA%B8

示例9（unquote）：

和quote相反，可以进行URL解码。



代码：
from urllib.parse import unquote


url = 'https://www.baidu.com/s?wd=%E5%A3%81%E7%BA%B8'
print(unquote(url))



输出结果：
https://www.baidu.com/s?wd=壁纸

牧笛yo

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
PYTHON爬虫之urllib库学习笔记

PYTHON爬虫之urllib库学习笔记urllib.request.urlopenurllib.request.urlopen(url, data=None, [timeout, ]*, cafile=None, capath=None, cadefault=False, context=None)
复制链接

扫一扫