urllib的使用
urllib时python的一个内置库，一共包含四个模块
1. request-请求
这是最基本的HTTP请求模块，可以模拟请求的发送。就像在浏览器输入URL，按下回车一样，只需要给库方法传入URL以及额外的参数，就可以模拟实现发送请求的过程了
urlopen
发送请求。
urllib.request模块提供了最基本的构造HTTP请求的方法，利用这个模块可以模拟浏览器请求的发起过程，同时它还具有处理授权验证，重定向， 浏览器Cookie以及其他的一些功能
这里以百度为例
说明： 这里只是单纯的使用一下 `urlopen` 所以获取的网页内容并不重要
import urllib.request
response = urllib.request.urlopen('https://www.baidu.com')
print(response.read().decode('utf-8'))
查看返回的响应
import urllib.request
response = urllib.request.urlopen('https://www.baidu.com')
print(type(response))输出：
<class 'http.client.HTTPResponse'>
响应式一个 HTTPResponse 对象，主要包含： read, readinto, getheader, getheaders, fileno,
等方法， 以及 msg, version, status, reason, debuglevel, closed等属性
可以通过上述方法和属性来对网页进行具体操作
import urllib.request
response = urllib.request.urlopen('https://baidu.com')
print(response.status) # 查看状态码
print(response.getheaders()) # 查看相应头信息
print(response.getheader('Server')) # 获取响应头中的 Server 的值
输出：
200
[('Bdpagetype', '1'), ('Bdqid', '0x89f2326c001257e1'), ('Content-Length', 省略一大堆
BWS/1.1
urllib.request.urlopen(url, data=None, [timeout, ]*, cafile=None, capath=None, cadefault=False, context=None )
参数说明：
url: 为必传， 网页地址
data: 可选参数。在添加该参数时，需要使用bytes方法将参数转化为字节流编码格式的内容，即bytes类型。另外如果传递了该内容，那么请求方式就不再时 GET 而是 POST 了
import urllib.parse
import urllib.request
data = bytes(urllib.parse.urlencode({'name': 'germey'}), encoding='utf-8')
response = urllib.request.urlopen('https://www.httpbin.org/post', data=data)
print(response.read().decode())
输出：
{
"args": {},
"data": "",
"files": {},
下面是我们传递的参数：
"form": {
"name": "germey"
},
"headers": {
"Accept-Encoding": "identity",
"Content-Length": "11",
"Content-Type": "application/x-www-form-urlencoded",
"Host": "www.httpbin.org",
"User-Agent": "Python-urllib/3.11",
"X-Amzn-Trace-Id": "Root=1-66934f46-661cf2f9337c4b704676c9d8"
},
"json": null,
"origin": "117.152.24.63",
"url": "https://www.httpbin.org/post"
}
timeout: 可选参数，设置超时时间，单位为秒，这个参数设置的是请求和响应的总时间。如果需要分别设置可以以元组的形式 例如 （3,2），如果不设置，则使用全局默认时间，这个参数支持HTTP , HTTPS, FTP请求
import urllib.request
response = urllib.request.urlopen('https://httpbin.org/get', timeout=0.1)
print(response.read())
超时报错，输出：
URLError: <urlopen error timed out>
也可以使用try except 来捕获异常实现当网页长时间未响应时，跳过或继续等待
import urllib.request
import socket
import urllib.error
try:
response = urllib.request.urlopen('https://httpbin.org/get', timeout=0.1)
except urllib.error.URLError as e:
if isinstance(e.reason, socket.timeout):
print('TIME OUT')
输出：
TIME OUT
context: 可选参数，该参数必须是ssl.SSLContext类型， 用来指定SSL的设置
cafile和capath：可选参数， 分别来指定CA证书和其路径
cadefault: 可选参数， 貌似已经弃用了，默认为False
Request
urlopen 只能发送简单的请求，如果要加如 Headers 就需要使用Request来构建请求了
简单使用：
import urllib.request
request = urllib.request.Request('https://www.baidu.com')
response = urllib.request.urlopen(request)
print(response.read().decode())
构造方法：
class urllib.request.Request(url, data=None, headers={}, origin_req_host=None, unverifiable=False, method=None)
url: 除了 url 是必传参数外， 其余都是可选参数
data: 要传的数据， 必须是bytes类型，如果是字典，可以先用urllib.parse模块中的urlencode方法进行编码
headers: 是一个字典，这就是请求头，在我们构造请求时，可以通过headers参数直接构造此项，也可以通过调用请求实例的add_header方法添加
添加请求头常见的方法是通过修改 User-Agent 来伪装浏览器，默认的 User-Agent 是 Python-urllib
origin_req_host: 是指请求方的host名称 或者 IP地址
unverifiable: 表示请求是否是无法验证的，默认值是False, 意思是用户没有足够的权限来接收这个请求的结果
method: 是一个字符串， 用来指定请求时使用的方法 例如 GET POST PUT 等
简单使用
from urllib import request, parse
url = 'https://www.httpbin.org/post'
headers = {'User-Agen': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36',
'Host': 'www.httpbin.org'}
dict = {'name': 'germey'}
data = bytes(parse.urlencode(dict), encoding='utf-8')
req = request.Request(url=url, data=data, headers=headers, method='POST')
response = request.urlopen(req)
print(response.read().decode('utf-8'))
通过add_header 方法添加 headers
req = request.Request(url=url, data=data, method='POST')
req.add_header('User-Agent', 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36')
Handler
Handler可以理解为各种处理器，有专门处理登录验证，处理Cookie, 处理代理设置利用这些Handler几乎可以实现HTTP请求中的所有功能
urllib.request模块中的BaseHandler类是所有Handler类的父类，它提供了最基本的方法
会有各种子类继承BaseHandler类
1. HTTPDefaultErrorHandler 用来处理HTTP中的响应错误，所有错误都会抛出HTTPError类型异常
2. HTTPRedirectHandler 用来处理重定向
3. HTTPCookieProcessor 用于处理Cookie
4. ProxyHandler 用于处理代理，代理默认为空
5. HTTPPasswordMgr 用于管理密码，它维护着用户名密码的对照表
6. HTTPBasicAuthHandler 用于管理认证，如果一个链接在打开时需要认证，那么可以用这个类来解决认证问题
验证
在访问网站时，可能会弹出需要登录的窗口，遇到这种情况，就表示这个网站启用了基本身份认证，这是一种登录验证的方式，爬虫可以借助HTTPBasicAuthHandler模块来模拟登录
简单示例： 示例网站： https://ssr3.scrape.center
from urllib.request import HTTPPasswordMgrWithDefaultRealm, HTTPBasicAuthHandler,build_opener
from urllib.error import URLErrorusername = 'admin'
password = 'admin'
url = 'https://ssr3.scrape.center/'p = HTTPPasswordMgrWithDefaultRealm()
p.add_password(None, url, username, password)
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)
代码说明：
这里首先实例化了一个 HTTPBasicAuthHandler 对象 auth_handler 其参数是 HTTPPasswordMgrWithDefaultRealm 对象， 它利用 add_password方法添加了 用户名和密码
这样就建立了一个用来处理验证的Handler类
然后将刚建立的auth_handler 类 当作参数传入 bulid_opener方法， 构建一个Opener，这个Opener 发送请求时，就相当于验证成功了
最后利用Opener 类中中的open 方法打开链接，即可完成验证，这里获取的结果就是验证成功后的页面源码内容
代理
做爬虫的时候免不了要使用代理，如果要添加代理可以这样做
from urllib.error import URLError
from urllib.request import ProxyHandler, build_openerproxy_handler = ProxyHandler({
'http': 'http://127.0.0.1:8080',
'https': 'https://127.0.0.1:8080'
})
openr = build_opener('https://www.baidu.com')
try:
response = opener.open('https://www.baidu.com')
print(response.read().decode('utf-8'))
except URLError as e:
print(e.reason)
首先上面的代码时不能运行的，因为代理使用的时本地地址， 需要更改代理IP
代码说明：
这里现在本地搭建了一个代理，并让其运行在8080端口上
上面使用了ProxyHandler, 其参数是一个字典，键名是协议类型（HTTP 或 HTTPS等）键是代理的链接，可以添加多个代理
然后利用这个Handler 和 build_opener 方法构建了一个Opener 之后发送请求即可
Cookie
要想处理Cookie 首先要获取Cookie
示例代码：
# 获取Cookie
import http.cookiejar, urllib.requestcookie = http.cookiejar.CookieJar()
handler = urllib.request.HTTPCookieProcessor(cookie)
opener = urllib.request.build_opener(handler)
response = opener.open('https://www.baidu.com')
for item in cookie:
print(item.name + '=' + item.value)
首先必须声明一个Cookie对象，然后利用HTTPCookieProcessor构建一个Handler， 最后利用build_opener 方法构建一个Opener , 执行open即可
保存Cookie
# 保存Cookie
import urllib.request, http.cookiejarfilename = 'cookie.txt'
cookie = http.cookiejar.MozillaCookieJar(filename)
handler = urllib.request.HTTPCookieProcessor(cookie)
opener = urllib.request.build_opener(handler)
response = opener.open('https://www.baidu.com')
cookie.save(ignore_discard=True, ignore_expires=True)
这里需要将CookieJar 换成 MozillaCookieJar, 它会在生成文件时用到， 是CookieJar的子类，可以用来处理跟Cookie和文件相关的事件， 例如读取和保存Cookie， 可以将Cookie保存成Mozilla型浏览器的Cookie格式
另外， LWPCookieJar 同样也可以读取和保存Cookie， 只是Cookie文件的保存格式和MozillaCookieJar不一样，它会保存成 LWP(libwww-perl)格式
cookie = http.cookiejar.LWPCookieJar(filename)
读取Cookie 文件 这里以 LWPCookieJar格式为例
# 读取
import urllib.request, http.cookiejarcookie = http.cookiejar.LWPCookieJar()
cookie.load('cookie.txt', ignore_discard=True, ignore_expires=True)
handler = urllib.request.HTTPCookieProcessor(cookie)
opener = urllib.request.build_opener(handler)
response = opener.open('https://www.baidu.com')
print(response.read().decode())
这里只是演示读取cookie文件， 所以不要纠结从百度读取了什么，因为这里没有设置headers所以不能读取到真正的内容
这里调用了load 方法来读取本地的Cookie文件， 获取了Cookie的内容，这样做的前提是我们实现生成LWPCookieJar格式的cookie, 并保存了文件，读取cookie后，使用同样的方法构建handler类和opener类 即可完成操作
2. error-异常
异常处理模块。如果出现请求异常，那么我们可以捕获这些异常，然后进行重试或者其他操作来保证程序不会意外终止
URLError
URLErroe类来自urllib库中error模块， 继承自OSError类， 是error异常模块的基类，由request模块产生的异常都可以通过捕获这个类来处理
它具有一个属性 reason 即返回错误的原因
示例：
from urllib import request, error
try:
# response = request.urlopen('https://www.baidu.com')
response = request.urlopen('htttps://cuiqingcai.com/404')
print('111')
except error.URLError as e:
# print('not Found')
print(e.reason)
输出：
unknown url type: htttps
这里第一运行的时候报错了， 切换网址运行之后，再切换回来又好了，不明所以
HTTPError
HTTPError 是 URLError 的子类， 专门用来处理HTTP请求的错误， 例如认证请求失败等，
有如下三个属性：
code: 返回HTTP状态码
reason： 同父类一样，返回错误的原因
headers: 返回请求头
示例：
from urllib import request, error
try:
# response = request.urlopen('https://www.baidu.com')
response = request.urlopen('htttps://cuiqingcai.com/404')
except error.HTTPError as e:
# print('not Found')
print(e.reson, e.code, e.headers, sep='\n')
except error.URLError as e:
print(e.reason)
else:
print('Request Successfully')
这里并不能正确的捕获到HTTPError的异常， 暂时不知道原因
有的时候 reason 返回的不一定是字符串也有可能是一个对象
这个时候可以用 isinstance 方法判断类型， 做出更详细的异常判断
from urllib import request, error
import sockettry:
response = request.urlopen('https://www.baidu.com', timeout=0.01)
# response = request.urlopen('htttps://cuiqingcai.com/404')
except error.HTTPError as e:
# print('not Found')
print(e.reson, e.code, e.headers, sep='\n')
except error.URLError as e:
print(e.reason)
if isinstance(e.reason, socket.timeout):
print('TIME OUT')
else:
print('Request Successfully')
3. parse-解析链接
一个工具模块。它提供了很多URL的处理方法，例如拆分，解析，合并等
它支持如下协议的URL处理：
file, ftp, gopher, hdl, http, https, imap, mailto, mms, news, nntp, prospero, rsync, rtsp, rtspu, sftp, sip, sips, snews, svn, svn+ssh, telnet, wais
urlparse
该方法可以实现URL的识别和分段
示例：
from urllib.parse import urlparse
result = urlparse('https://www.baidu.com/index.html;user?id=5#comment')
print(type(result))
print(result)
输出：
<class 'urllib.parse.ParseResult'> ParseResult(scheme='https', netloc='www.baidu.com', path='/index.html', params='user', query='id=5', fragment='comment')
可以看到解析的对象是一个 ParseResult类型的对象，包含六部分，分别是： scheme, netloc, path, params, query 和 fragment
从解析的地址可以看出urlparse 方法再解析URL时有特定的分割符，:// 前面的内容是scheme, 代表协议， 第一个 / 前面是netloc, 即域名； 后面是path, 即访问路径, 分号 ; 后面是params， 代表参数， 问号 ? 后面是查询条件 query ， 一般用作GET类型的URL， 井号 # 后面是锚点 fragment,用于直接定位页面内部的下拉位置
于是可以得出一个标准的链接格式：
scheme://netloc/path;params?query#fragment
urlparse API：
urllib.parse.urlparse(urlstring, scheme='', allow_fragments=True)
urlstring: 必填， 待解析的URL
scheme: 这是默认的协议(如 http 或 https 等) 如果待解析的URL没有带协议信息，则取默认
示例：URL不带协议
result = urlparse('www.baidu.com/index.html;user?id=5#comment', scheme='https')
print(result)
输出：
ParseResult(scheme='https', netloc='', path='www.baidu.com/index.html', params='user', query='id=5', fragment='comment')
示例：URL带协议
result = urlparse('https://www.baidu.com/index.html;user?id=5#comment', scheme='http')
print(result)
输出：
ParseResult(scheme='https', netloc='www.baidu.com', path='/index.html', params='user', query='id=5', fragment='comment')
从上面两个例子可以看出， scheme 参数只在 URL不带协议的时候生效
allow_fragments: 是否忽略fragment。 如果此项被设置为False, 那么fragment部分就会被忽略，它就会被解析为 path, params 或者 query 的一部分， 而 fragment部分为空
示例：设置allow_fragments为False
result = urlparse('https://www.baidu.com/index.html;user?id=5#comment', allow_fragments=False)
print(result)
输出：fragment 解析到了 query中
ParseResult(scheme='https', netloc='www.baidu.com', path='/index.html', params='user', query='id=5#comment', fragment='')
示例：URL中不带parmas和 query
result = urlparse('https://www.baidu.com/index.html#comment', allow_fragments=False)
print(result)
输出：fragment 解析到了 path 中
ParseResult(scheme='https', netloc='www.baidu.com', path='/index.html#comment', params='', query='', fragment='')
返回结果 ParseResult 实际上是一个元组， 既可以用属性名获取其内容，也可用索引获取
示例：
result = urlparse('https://www.baidu.com/index.html;user?id=5#comment', allow_fragments=False)
print(result.scheme, result[0], result.netloc, result[1], sep='\n')
输出：
https https www.baidu.com www.baidu.com
urlunparse
有了urlparse 就有 urlunparse , 用来构造URL。 这个方法接收的参数是要给可迭代对象，其长度必须是6， 否则会抛出参数量不足或过多的异常
示例：
from urllib.parse import urlunparse
data = ['https', 'www.baidu.com', 'index.html', 'user', 'a=6', 'comment']
print(urlunparse(data))
输出：
https://www.baidu.com/index.html;user?a=6#comment
这里的参数data 用了列表类型， 也可以用其他类型， 例如元组或特定的数据结构
urlsplit
这个方法和urlparse 很相似， 只不过它不在解析 parmas 这一部分(parmas 会合并到 path中)， 只返回 5 个结果
示例：
from urllib.parse import urlsplit
result = urlsplit('https://www.baidu.com/index.html;user?id=5#comment')
print(result)
输出：
SplitResult(scheme='https', netloc='www.baidu.com', path='/index.html;user', query='id=5', fragment='comment')
返回的结果是一个 SplitResult, 也是一个元组 ，可以通过索引和属性名获取内容
示例：
from urllib.parse import urlsplit
result = urlsplit('https://www.baidu.com/index.html;user?id=5#comment')
print(result.scheme, result[0])
输出：
https https
urlunsplit
与 urlunparse 方法类似， 这也是将链接的各个部分组合成完整链接的方法， 传入的参数是一个可迭代对象， 如列表， 元组等。 唯一区别是，这里参数长度必须是 5
示例：
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
urljoin
urlunparse 和 urlunsplit 方法都能完成链接的合并， 但都有特定的长度，链接的每一部分都要清晰的分开
而 urljoin 方法 我们可以提供一个 base_url 链接(基础链接) 作为第一个参数， 将新的链接作为第二个参数， urljoin 会分析 base_url 的 scheme, netloc, path 这三个内容， 并对新链接缺失的部分进行补充， 最后返回结果
示例：
from urllib.parse import urljoin
print(urljoin('https://www.baidu.com', 'FAQ.html'))
print(urljoin('https://www.baidu.com', 'https://cuiqingcai.com/FAQ.html'))
print(urljoin('https://www.baidu.com/about.html', 'https://cuiqingcai.com/FAQ.html'))
print(urljoin('https://www.baidu.com/about.html', 'https://cuiqingcai.com/FAQ.html?question=2'))
print(urljoin('https://www.baidu.com?wd=abc', 'https://cuiqingcai.com/index.php'))
print(urljoin('https://www.baidu.com', '?category=2#comment'))
print(urljoin('www.baidu.com', '?category=2#comment'))
print(urljoin('www.baidu.com', '?category=2'))
输出：
https://www.baidu.com/FAQ.html https://cuiqingcai.com/FAQ.html https://cuiqingcai.com/FAQ.html https://cuiqingcai.com/FAQ.html?question=2 https://cuiqingcai.com/index.php https://www.baidu.com?category=2#comment www.baidu.com?category=2#comment www.baidu.com?category=2
可以发现， base_url 提供了三项内容： scheme, netloc 和 path 如果新链接里不存在这三项，
就予以补充， 如果存在，就用新链接里面的，base_url 中的不起作用
urlenclde
它再构造GET请求的时候很有用
示例：
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.com?name=germey&age=25
parse_qs
有了序列化，就有反序列化。 利用parse_qs 方法， 可以将一个GET请求参数转换成字典
示例：
from urllib.parse import parse_qs
query = 'name=germey&age=25'
print(parse_qs(query))
输出：
{'name': ['germey'], 'age': ['25']}
parse_qsl
parse_qsl 方法将参数转化为 由 元组组成的列表
示例：
from urllib.parse import parse_qsl
query = 'name=germey&age=25'
print(parse_qsl(query))
输出：
[('name', 'germey'), ('age', '25')]
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
4. robotparser-分析Robots协议
主要用来识别网站的robots.txt文件，然后判断哪些网站可以爬，哪些网站不可以爬，用的很少
Robots协议： 也称为 爬虫协议 ，机器人协议，全名为 网络爬虫排除标准，用来告诉引擎哪些页面可以抓取，哪些不可以。
它通常是一个叫做robots.txt的文本文件， 一般放在网站的根目录下
搜素爬虫在访问一个站点的时候， 首先会检查这个站点的根目录下是否存在robots.txt 文件， 如果存在，就会根据其中定义的爬取范围来爬取，如果没有，则会爬取所有可直接访问的页面
robots.txt文件示例：
User-agent: *
Disallow: /
Allow: /public/
这里限定了所有搜素爬虫只能爬取public目录。
User-agent: 描述了搜索爬虫的名称， 设置为* 代表所有爬虫，也可以指定名称
例如： User-agent: Baiduspider
这代表设置规则对百度爬虫有效，可以设置多个，但最少要有一条
Disallow: 指定了不允许爬取的目录， 设置为 / 代表不允许爬取所有页面
Allow: 一般不会单独使用， 会和 Disallow 一起用， 用来排除某些限制。上面设置为 /public/ ， 结合 Disallow 的设置， 表示所有页面都不允许爬取， 但可以爬取 public 目录
robots.txt 也可以是空文件
一些爬虫名称
| BaiduSpider | 百度 |
| Googlebot | 谷歌 |
| 360Spider | 360搜素 |
robotparser
了解了 Robots协议之后， 就可以使用 robotparser 模块来解析 robots.txt文件了。该模块为我们提供了一个类： RobotFileParser, 它可以根据一个网站的robots.txt文件来判断一个爬取爬虫是否由权限爬取这个网页
这个方法只需要在构造方法中传入robots.txt 文件的链接即可
urllib.robotparser.RobotFileParser(url='')
也可以不在声明中传入链接， 就让其默认为空， 最后再使用 set_url() 方法设置也可以
下面列出 RobotFileParser 的几个常用方法
set_url: 用来设置 robots.txt 文件的链接。 如果再创建的时候传入了，就不需要了
read: 读取 robots.txt 文件进行分析。 注意：这个方法执行读取和分析操作， 如果不调用这个方法，那么接下来的操作都会是 False,这个方法不返回任何内容， 但执行了读取操作
parse: 用来解析 robots.txt 文件， 传入其中的参数是 robots.txt 某些行的内容，它会按照 robots.txt 的语法规则来分析这些内容
can_fetch: 该方法由两个参数，第一个是User-Agent, 第二个是要抓取的URL。返回的结果是True或False 表示搜素引擎是否可以抓取这个URL
mtime: 返回上次抓取和分析 robots.txt 文件的时间
modified: 设置当前时间为上次抓取的时间
示例：
from urllib.robotparser import RobotFileParser
rp = RobotFileParser()
rp.set_url('https://www.baidu.com/robots.txt')
rp.read()
print(rp.can_fetch('Baiduspider', 'https://www.baidu.com'))
print(rp.can_fetch('Baiduspider', 'https://www.baidu.com/homepage/'))
print(rp.can_fetch('Googlebot', 'https://www.baidu.com/homepage/'))
传递URL的方法也可以为：
rp = RobotFileParser('https://www.baidu.com/robots.txt')
输出：
True True False
由此可以看出，百度限制了 谷歌对 homepage的抓取，而自己却是可以抓取的
这里同样可以使用 parse 方法执行对 robots.txt 的读取和分析
示例：
from urllib.robotparser import RobotFileParser
from urllib.request import urlopenrp = RobotFileParser()
rp.parse(urlopen('https://www.baidu.com/robots.txt').read().decode('utf-8').split('\n'))
print(rp.can_fetch('Baiduspider', 'https://www.baidu.com'))
print(rp.can_fetch('Baiduspider', 'https://www.baidu.com/homepage/'))
print(rp.can_fetch('Googlebot', 'https://www.baidu.com/homepage/'))
输出：
True True False
可以看出，结果是一样的
原文地址：https://blog.csdn.net/qq_39217312/article/details/140414432
免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！