urllib

发送请求request

urlopen()

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

接下来，看看它返回的到底是什么。利用type()方法输出响应的类型：

 import urllib.request
  
 response = urllib.request.urlopen('https://www.python.org')
 print(type(response))

输出结果如下：

 <class 'http.client.HTTPResponse'>

可以发现，它是一个HTTPResposne类型的对象。它主要包含read()、readinto()、getheader(name)、getheaders()、fileno()等方法，以及msg、version、status、reason、debuglevel、closed等属性。

得到这个对象之后，我们把它赋值为response变量，然后就可以调用这些方法和属性，得到返回结果的一系列信息了。

例如，调用read()方法可以得到返回的网页内容，调用status属性可以得到返回结果的状态码，如200代表请求成功，404代表网页未找到等。

下面再通过一个实例来看看：

 import urllib.request
 ​
 response = urllib.request.urlopen('https://www.python.org')
 print(response.status)
 print(response.getheaders())
 print(response.getheader('Server'))

 200
 [('Server', 'nginx'), ('Content-Type', 'text/html; charset=utf-8'), ('X-Frame-Options', 'SAMEORIGIN'), ('X-Clacks-Overhead', 'GNU Terry Pratchett'), ('Content-Length', '47397'), ('Accept-Ranges', 'bytes'), ('Date', 'Mon, 01 Aug 2016 09:57:31 GMT'), ('Via', '1.1 varnish'), ('Age', '2473'), ('Connection', 'close'), ('X-Served-By', 'cache-lcy1125-LCY'), ('X-Cache', 'HIT'), ('X-Cache-Hits', '23'), ('Vary', 'Cookie'), ('Strict-Transport-Security', 'max-age=63072000; includeSubDomains')]
 nginx

可见，前两个输出分别输出了响应的状态码和响应的头信息，最后一个输出通过调用getheader()方法并传递一个参数Server获取了响应头中的Server值，结果是nginx，意思是服务器是用Nginx搭建的。

利用最基本的urlopen()方法，可以完成最基本的简单网页的GET请求抓取。

如果想给链接传递一些参数，该怎么实现呢？首先看一下urlopen()函数的API：

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

可以发现，除了第一个参数可以传递URL之外，我们还可以传递其他内容，比如data（附加数据）、timeout（超时时间）等。

下面我们详细说明下这几个参数的用法。

data参数

data参数是可选的。如果要添加该参数，并且如果它是字节流编码格式的内容，即bytes类型，则需要通过bytes()方法转化。另外，如果传递了这个参数，则它的请求方式就不再是GET方式，而是POST方式。

下面用实例来看一下：

 import urllib.parseimport urllib.request data = bytes(urllib.parse.urlencode({'word': 'hello'}), encoding='utf8')response = urllib.request.urlopen('http://httpbin.org/post', data=data)print(response.read())

这里我们传递了一个参数word，值是hello。它需要被转码成bytes（字节流）类型。其中转字节流采用了bytes()方法，该方法的第一个参数需要是str（字符串）类型，需要用urllib.parse模块里的urlencode()方法来将参数字典转化为字符串；第二个参数指定编码格式，这里指定为utf8。

这里请求的站点是httpbin.org，它可以提供HTTP请求测试。本次我们请求的URL为http://httpbin.org/post，这个链接可以用来测试POST请求，它可以输出请求的一些信息，其中包含我们传递的data参数。

运行结果如下：

 {
      "args": {},
      "data": "",
      "files": {},
      "form": {
          "word": "hello"
      },
      "headers": {
          "Accept-Encoding": "identity",
          "Content-Length": "10",
          "Content-Type": "application/x-www-form-urlencoded",
          "Host": "httpbin.org",
          "User-Agent": "Python-urllib/3.5"
      },
      "json": null,
      "origin": "123.124.23.253",
      "url": "http://httpbin.org/post"
 }

我们传递的参数出现在了form字段中，这表明是模拟了表单提交的方式，以POST方式传输数据。

timeout参数

timeout参数用于设置超时时间，单位为秒，意思就是如果请求超出了设置的这个时间，还没有得到响应，就会抛出异常。如果不指定该参数，就会使用全局默认时间。它支持HTTP、HTTPS、FTP请求。

下面用实例来看一下：

 import urllib.request
  
 response = urllib.request.urlopen('http://httpbin.org/get', timeout=1)
 print(response.read())

运行结果如下：

 During handling of the above exception, another exception occurred:
  
 Traceback (most recent call last): File "/var/py/python/urllibtest.py", line 4, in <module> response = urllib.request.urlopen('http://httpbin.org/get', timeout=1)
 ...
 urllib.error.URLError: <urlopen error timed out>

这里我们设置超时时间是1秒。程序1秒过后，服务器依然没有响应，于是抛出了URLError异常。该异常属于urllib.error模块，错误原因是超时。

因此，可以通过设置这个超时时间来控制一个网页如果长时间未响应，就跳过它的抓取。这可以利用try except语句来实现，相关代码如下：

 import socket
 import urllib.request
 import urllib.error
  
 try:
     response = urllib.request.urlopen('http://httpbin.org/get', timeout=0.1)
 except urllib.error.URLError as e:
     if isinstance(e.reason, socket.timeout):
         print('TIME OUT')

这里我们请求了http://httpbin.org/get测试链接，设置超时时间是0.1秒，然后捕获了URLError异常，接着判断异常是socket.timeout类型（意思就是超时异常），从而得出它确实是因为超时而报错，打印输出了TIME OUT。

运行结果如下：

 TIME OUT

按照常理来说，0.1秒内基本不可能得到服务器响应，因此输出了TIME OUT的提示。

通过设置timeout这个参数来实现超时处理，有时还是很有用的。

其他参数

除了data参数和timeout参数外，还有context参数，它必须是ssl.SSLContext类型，用来指定SSL设置。

此外，cafile和capath这两个参数分别指定CA证书和它的路径，这个在请求HTTPS链接时会有用。

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

前面讲解了urlopen()方法的用法，通过这个最基本的方法，我们可以完成简单的请求和网页抓取。若需更加详细的信息，可以参见官方文档：

https://docs.python.org/3/library/urllib.request.html。

Request

我们知道利用urlopen()方法可以实现最基本请求的发起，但这几个简单的参数并不足以构建一个完整的请求。如果请求中需要加入Headers等信息，就可以利用更强大的Request类来构建。

首先，我们用实例来感受一下Request的用法：

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

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

下面我们看一下Request可以通过怎样的参数来构造，它的构造方法如下：

 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，我们可以通过修改它来伪装浏览器。比如要伪装火狐浏览器，你可以把它设置为：

   Mozilla/5.0 (X11; U; Linux i686) Gecko/20071127 Firefox/2.0.0.11

• 第四个参数origin_req_host指的是请求方的host名称或者IP地址。

• 第五个参数unverifiable表示这个请求是否是无法验证的，默认是False，意思就是说用户没有足够权限来选择接收这个请求的结果。例如，我们请求一个HTML文档中的图片，但是我们没有自动抓取图像的权限，这时unverifiable的值就是True`。

• 第六个参数method是一个字符串，用来指示请求使用的方法，比如GET、POST和PUT等。

下面我们传入多个参数构建请求来看一下：

 from urllib import request, parse
  
 url = 'http://httpbin.org/post'
 headers = {
     'User-Agent': 'Mozilla/4.0 (compatible; MSIE 5.5; Windows NT)',
     'Host': 'httpbin.org'
 }
 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'))

这里我们通过4个参数构造了一个请求，其中url即请求URL，headers中指定了User-Agent和Host，参数data用urlencode()和bytes()方法转成字节流。另外，指定了请求方式为POST。

运行结果如下：

 {
   "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/4.0 (compatible; MSIE 5.5; Windows NT)"
   }, 
   "json": null, 
   "origin": "219.224.169.11", 
   "url": "http://httpbin.org/post"
 }

观察结果可以发现，我们成功设置了data、headers和method。

另外，headers也可以用add_header()方法来添加：

 req = request.Request(url=url, data=data, method='POST')
 req.add_header('User-Agent', 'Mozilla/4.0 (compatible; MSIE 5.5; Windows NT)')

如此一来，我们就可以更加方便地构造请求，实现请求的发送啦。

高级用法

在上面的过程中，我们虽然可以构造请求，但是对于一些更高级的操作（比如Cookies处理、代理设置等），我们该怎么办呢？

接下来，就需要更强大的工具Handler登场了。简而言之，我们可以把它理解为各种处理器，有专门处理登录验证的，有处理Cookies的，有处理代理设置的。利用它们，我们几乎可以做到HTTP请求中所有的事情。

首先，介绍一下urllib.request模块里的BaseHandler类，它是所有其他Handler的父类，它提供了最基本的方法，例如default_open()、protocol_request()等。

接下来，就有各种Handler子类继承这个BaseHandler类，举例如下。

• HTTPDefaultErrorHandler：用于处理HTTP响应错误，错误都会抛出HTTPError类型的异常。

• HTTPRedirectHandler：用于处理重定向。

• HTTPCookieProcessor：用于处理Cookies。

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

• HTTPPasswordMgr：用于管理密码，它维护了用户名和密码的表。

• HTTPBasicAuthHandler：用于管理认证，如果一个链接打开时需要认证，那么可以用它来解决认证问题。

另外，还有其他的Handler类，这里就不一一列举了，详情可以参考官方文档：https://docs.python.org/3/library/urllib.request.html#urllib.request.BaseHandler。

关于怎么使用它们，现在先不用着急，后面会有实例演示。

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

那么，为什么要引入Opener呢？因为需要实现更高级的功能。之前使用的Request和urlopen()相当于类库为你封装好了极其常用的请求方法，利用它们可以完成基本的请求，但是现在不一样了，我们需要实现更高级的功能，所以需要深入一层进行配置，使用更底层的实例来完成操作，所以这里就用到了Opener。

Opener可以使用open()方法，返回的类型和urlopen()如出一辙。那么，它和Handler有什么关系呢？简而言之，就是利用Handler来构建Opener。

下面用几个实例来看看它们的用法。

验证

有些网站在打开时就会弹出提示框，直接提示你输入用户名和密码，验证成功后才能查看页面，如图3-2所示。

图3-2 验证页面

那么，如果要请求这样的页面，该怎么办呢？借助HTTPBasicAuthHandler就可以完成，相关代码如下：

 from urllib.request import HTTPPasswordMgrWithDefaultRealm, HTTPBasicAuthHandler, build_opener
 from urllib.error import URLError
  
 username = 'username'
 password = 'password'
 url = 'http://localhost:5000/'
  
 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对象，其参数是HTTPPasswordMgrWithDefaultRealm对象，它利用add_password()添加进去用户名和密码，这样就建立了一个处理验证的Handler。

接下来，利用这个Handler并使用build_opener()方法构建一个Opener，这个Opener在发送请求时就相当于已经验证成功了。

接下来，利用Opener的open()方法打开链接，就可以完成验证了。这里获取到的结果就是验证后的页面源码内容。

代理

在做爬虫的时候，免不了要使用代理，如果要添加代理，可以这样做：

 from urllib.error import URLError
 from urllib.request import ProxyHandler, build_opener
  
 proxy_handler = ProxyHandler({
     'http': 'http://127.0.0.1:9743',
     'https': 'https://127.0.0.1:9743'
 })
 opener = build_opener(proxy_handler)
 try:
     response = opener.open('https://www.baidu.com')
     print(response.read().decode('utf-8'))
 except URLError as e:
     print(e.reason)

这里我们在本地搭建了一个代理，它运行在9743端口上。

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

然后，利用这个Handler及build_opener()方法构造一个Opener，之后发送请求即可。

Cookies

Cookies的处理就需要相关的Handler了。

我们先用实例来看看怎样将网站的Cookies获取下来，相关代码如下：

 import http.cookiejar, 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)

首先，我们必须声明一个CookieJar对象。接下来，就需要利用HTTPCookieProcessor来构建一个Handler，最后利用build_opener()方法构建出Opener，执行open()函数即可。

运行结果如下：

 BAIDUID=2E65A683F8A8BA3DF521469DF8EFF1E1:FG=1
 BIDUPSID=2E65A683F8A8BA3DF521469DF8EFF1E1
 H_PS_PSSID=20987_1421_18282_17949_21122_17001_21227_21189_21161_20927
 PSTM=1474900615
 BDSVRTM=0
 BD_HOME=0

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

不过既然能输出，那可不可以输出成文件格式呢？我们知道Cookies实际上也是以文本形式保存的。

答案当然是肯定的，这里通过下面的实例来看看：

 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)

这时CookieJar就需要换成MozillaCookieJar，它在生成文件时会用到，是CookieJar的子类，可以用来处理Cookies和文件相关的事件，比如读取和保存Cookies，可以将Cookies保存成Mozilla型浏览器的Cookies格式。

运行之后，可以发现生成了一个cookies.txt文件，其内容如下：

 # Netscape HTTP Cookie File
 # http://curl.haxx.se/rfc/cookie_spec.html
 # This is a generated file!  Do not edit.
  
 .baidu.com    TRUE    /    FALSE    3622386254    BAIDUID    05AE39B5F56C1DEC474325CDA522D44F:FG=1
 .baidu.com    TRUE    /    FALSE    3622386254    BIDUPSID    05AE39B5F56C1DEC474325CDA522D44F
 .baidu.com    TRUE    /    FALSE        H_PS_PSSID    19638_1453_17710_18240_21091_18560_17001_21191_21161
 .baidu.com    TRUE    /    FALSE    3622386254    PSTM    1474902606
 www.baidu.com    FALSE    /    FALSE        BDSVRTM    0
 www.baidu.com    FALSE    /    FALSE        BD_HOME    0

另外，LWPCookieJar同样可以读取和保存Cookies，但是保存的格式和MozillaCookieJar不一样，它会保存成libwww-perl(LWP)格式的Cookies文件。

要保存成LWP格式的Cookies文件，可以在声明时就改为：

 cookie = http.cookiejar.LWPCookieJar(filename)

此时生成的内容如下：

 #LWP-Cookies-2.0
 Set-Cookie3: BAIDUID="0CE9C56F598E69DB375B7C294AE5C591:FG=1"; path="/"; domain=".baidu.com"; path_spec; domain_dot; expires="2084-10-14 18:25:19Z"; version=0
 Set-Cookie3: BIDUPSID=0CE9C56F598E69DB375B7C294AE5C591; path="/"; domain=".baidu.com"; path_spec; domain_dot; expires="2084-10-14 18:25:19Z"; version=0
 Set-Cookie3: H_PS_PSSID=20048_1448_18240_17944_21089_21192_21161_20929; path="/"; domain=".baidu.com"; path_spec; domain_dot; discard; version=0
 Set-Cookie3: PSTM=1474902671; path="/"; domain=".baidu.com"; path_spec; domain_dot; expires="2084-10-14 18:25:19Z"; version=0
 Set-Cookie3: BDSVRTM=0; path="/"; domain="www.baidu.com"; path_spec; discard; version=0
 Set-Cookie3: BD_HOME=0; path="/"; domain="www.baidu.com"; path_spec; discard; version=0

由此看来，生成的格式还是有比较大差异的。

那么，生成了Cookies文件后，怎样从文件中读取并利用呢？

下面我们以LWPCookieJar格式为例来看一下：

 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('utf-8'))

可以看到，这里调用load()方法来读取本地的Cookies文件，获取到了Cookies的内容。不过前提是我们首先生成了LWPCookieJar格式的Cookies，并保存成文件，然后读取Cookies之后使用同样的方法构建Handler和Opener即可完成操作。

运行结果正常的话，会输出百度网页的源代码。

通过上面的方法，我们可以实现绝大多数请求功能的设置了。

这便是urllib库中request模块的基本用法，如果想实现更多的功能，可以参考官方文档的说明：https://docs.python.org/3/library/urllib.request.html#basehandler-objects。

---

 

处理异常error

前一节我们了解了请求的发送过程，但是在网络不好的情况下，如果出现了异常，该怎么办呢？这时如果不处理这些异常，程序很可能因报错而终止运行，所以异常处理还是十分有必要的。

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

1. URLError

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

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

下面用一个实例来看一下：

 from urllib import request, error
 try:
     response = request.urlopen('http://cuiqingcai.com/index.htm')
 except error.URLError as e:
     print(e.reason)

 

我们打开一个不存在的页面，照理来说应该会报错，但是这时我们捕获了URLError这个异常，运行结果如下：

 Not Found

程序没有直接报错，而是输出了如上内容，这样通过如上操作，我们就可以避免程序异常终止，同时异常得到了有效处理。

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')

 

运行结果如下：

 Not Found
 404
 Server: nginx/1.4.6 (Ubuntu)
 Date: Wed, 03 Aug 2016 08:54:22 GMT
 Content-Type: text/html; charset=UTF-8
 Transfer-Encoding: chunked
 Connection: close
 X-Powered-By: PHP/5.5.9-1ubuntu4.14
 Vary: Cookie
 Expires: Wed, 11 Jan 1984 05:00:00 GMT
 Cache-Control: no-cache, must-revalidate, max-age=0
 Pragma: no-cache
 Link: <http://cuiqingcai.com/wp-json/>; rel="https://api.w.org/"

 

依然是同样的网址，这里捕获了HTTPError异常，输出了reason、code和headers属性。

因为URLError是HTTPError的父类，所以可以先选择捕获子类的错误，再去捕获父类的错误，所以上述代码更好的写法如下：

 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')

 

这样就可以做到先捕获HTTPError，获取它的错误状态码、原因、headers等信息。如果不是HTTPError异常，就会捕获URLError异常，输出错误原因。最后，用else来处理正常的逻辑。这是一个较好的异常处理写法。

有时候，reason属性返回的不一定是字符串，也可能是一个对象。再看下面的实例：

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

这里我们直接设置超时时间来强制抛出timeout异常。

运行结果如下：

 <class 'socket.timeout'>
 TIME OUT

可以发现，reason属性的结果是socket.timeout类。所以，这里我们可以用isinstance()方法来判断它的类型，作出更详细的异常判断。

本节中，我们讲述了error模块的相关用法，通过合理地捕获异常可以做出更准确的异常判断，使程序更加稳健。

 

解析链接parse

前面说过，urllib库里还提供了parse这个模块，它定义了处理URL的标准接口，例如实现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。本节中，我们介绍一下该模块中常用的方法来看一下它的便捷之处。

1. urlparse()

该方法可以实现URL的识别和分段，这里先用一个实例来看一下：

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

 

这里我们利用urlparse()方法进行了一个URL的解析。首先，输出了解析结果的类型，然后将结果也输出出来。

运行结果如下：

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

可以看到，返回结果是一个ParseResult类型的对象，它包含6部分，分别是scheme、netloc、path、params、query和fragment。

观察一下该实例的URL：

 http://www.baidu.com/index.html;user?id=5#comment

 

可以发现，urlparse()方法将其拆分成了6部分。大体观察可以发现，解析时有特定的分隔符。比如，://前面的就是scheme，代表协议；第一个/前面便是netloc，即域名；分号;前面是params，代表参数。

所以，可以得出一个标准的链接格式，具体如下：

 scheme://netloc/path;parameters?query#fragment

一个标准的URL都会符合这个规则，利用urlparse()方法可以将它拆分开来。

除了这种最基本的解析方式外，urlparse()方法还有其他配置吗？接下来，看一下它的API用法：

 urllib.parse.urlparse(urlstring, scheme='', allow_fragments=True)

可以看到，它有3个参数。

• urlstring：这是必填项，即待解析的URL。

• scheme：它是默认的协议（比如http或https等）。假如这个链接没有带协议信息，会将这个作为默认的协议。我们用实例来看一下：

 from urllib.parse import urlparse
  
 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没有包含最前面的scheme信息，但是通过指定默认的scheme参数，返回的结果是https。

假设我们带上了scheme：

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

则结果如下：

 ParseResult(scheme='http', netloc='www.baidu.com', path='/index.html', params='user', query='id=5', fragment='comment')

可见，scheme参数只有在URL中不包含scheme信息时才生效。如果URL中有scheme信息，就会返回解析出的scheme。

• allow_fragments：即是否忽略fragment。如果它被设置为False，fragment部分就会被忽略，它会被解析为path、parameters或者query的一部分，而fragment部分为空。下面我们用实例来看一下：

 from urllib.parse import urlparse
  
 result = urlparse('http://www.baidu.com/index.html;user?id=5#comment', allow_fragments=False)
 print(result)

运行结果如下：

 ParseResult(scheme='http', netloc='www.baidu.com', path='/index.html', params='user', query='id=5#comment', fragment='')

假设URL中不包含params和query，我们再通过实例看一下：

 from urllib.parse import urlparse
  
 result = urlparse('http://www.baidu.com/index.html#comment', allow_fragments=False)
 print(result)

运行结果如下：

 ParseResult(scheme='http', netloc='www.baidu.com', path='/index.html#comment', params='', query='', fragment='')

可以发现，当URL中不包含params和query时，fragment便会被解析为path的一部分。

返回结果ParseResult实际上是一个元组，我们可以用索引顺序来获取，也可以用属性名获取。示例如下：

 from urllib.parse import urlparse
  
 result = urlparse('http://www.baidu.com/index.html#comment', allow_fragments=False)
 print(result.scheme, result[0], result.netloc, result[1], sep='\n')

这里我们分别用索引和属性名获取了scheme和netloc，其运行结果如下：

 http
 http
 www.baidu.com
 www.baidu.com

可以发现，二者的结果是一致的，两种方法都可以成功获取。

2. urlunparse()

有了urlparse()，相应地就有了它的对立方法urlunparse()。它接受的参数是一个可迭代对象，但是它的长度必须是6，否则会抛出参数数量不足或者过多的问题。先用一个实例看一下：

 from urllib.parse import urlunparse
  
 data = ['http', 'www.baidu.com', 'index.html', 'user', 'a=6', 'comment']
 print(urlunparse(data))

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

运行结果如下：

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

这样我们就成功实现了URL的构造。

3. urlsplit()

这个方法和urlparse()方法非常相似，只不过它不再单独解析params这一部分，只返回5个结果。上面例子中的params会合并到path中。示例如下：

 from urllib.parse import urlsplit
  
 result = urlsplit('http://www.baidu.com/index.html;user?id=5#comment')
 print(result)

运行结果如下：

 SplitResult(scheme='http', netloc='www.baidu.com', path='/index.html;user', query='id=5', fragment='comment')

可以发现，返回结果是SplitResult，它其实也是一个元组类型，既可以用属性获取值，也可以用索引来获取。示例如下：

 from urllib.parse import urlsplit
  
 result = urlsplit('http://www.baidu.com/index.html;user?id=5#comment')
 print(result.scheme, result[0])

运行结果如下：

 http http

4. urlunsplit()

与urlunparse()类似，它也是将链接各个部分组合成完整链接的方法，传入的参数也是一个可迭代对象，例如列表、元组等，唯一的区别是长度必须为5。示例如下：

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

运行结果如下：

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

 

5. urljoin()

有了urlunparse()和urlunsplit()方法，我们可以完成链接的合并，不过前提必须要有特定长度的对象，链接的每一部分都要清晰分开。

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

下面通过几个实例看一下：

 from urllib.parse import urljoin
  
 print(urljoin('http://www.baidu.com', 'FAQ.html'))
 print(urljoin('http://www.baidu.com', 'https://cuiqingcai.com/FAQ.html'))
 print(urljoin('http://www.baidu.com/about.html', 'https://cuiqingcai.com/FAQ.html'))
 print(urljoin('http://www.baidu.com/about.html', 'https://cuiqingcai.com/FAQ.html?question=2'))
 print(urljoin('http://www.baidu.com?wd=abc', 'https://cuiqingcai.com/index.php'))
 print(urljoin('http://www.baidu.com', '?category=2#comment'))
 print(urljoin('www.baidu.com', '?category=2#comment'))
 print(urljoin('www.baidu.com#comment', '?category=2'))

运行结果如下：

 http://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
 http://www.baidu.com?category=2#comment
 www.baidu.com?category=2#comment
 www.baidu.com?category=2

 

可以发现，base_url提供了三项内容scheme、netloc和path。如果这3项在新的链接里不存在，就予以补充；如果新的链接存在，就使用新的链接的部分。而base_url中的params、query和fragment是不起作用的。

通过urljoin()方法，我们可以轻松实现链接的解析、拼合与生成。

6. urlencode()

这里我们再介绍一个常用的方法——urlencode()，它在构造GET请求参数的时候非常有用，示例如下：

 from urllib.parse import urlencode
  
 params = {
     'name': 'germey',
     'age': 22
 }
 base_url = 'http://www.baidu.com?'
 url = base_url + urlencode(params)
 print(url)

这里首先声明了一个字典来将参数表示出来，然后调用urlencode()方法将其序列化为GET请求参数。

运行结果如下：

 http://www.baidu.com?name=germey&age=22

可以看到，参数就成功地由字典类型转化为GET请求参数了。

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

7. parse_qs()

有了序列化，必然就有反序列化。如果我们有一串GET请求参数，利用parse_qs()方法，就可以将它转回字典，示例如下：

 from urllib.parse import parse_qs
  
 query = 'name=germey&age=22'
 print(parse_qs(query))

运行结果如下：

 {'name': ['germey'], 'age': ['22']}

可以看到，这样就成功转回为字典类型了。

8. parse_qsl()

另外，还有一个parse_qsl()方法，它用于将参数转化为元组组成的列表，示例如下：

 from urllib.parse import parse_qsl
  
 query = 'name=germey&age=22'
 print(parse_qsl(query))

运行结果如下：

 [('name', 'germey'), ('age', '22')]

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

9. quote()

该方法可以将内容转化为URL编码的格式。URL中带有中文参数时，有时可能会导致乱码的问题，此时用这个方法可以将中文字符转化为URL编码，示例如下：

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

这里我们声明了一个中文的搜索文字，然后用quote()方法对其进行URL编码，最后得到的结果如下：

10. unquote()

有了quote()方法，当然还有unquote()方法，它可以进行URL解码，示例如下：

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

这是上面得到的URL编码后的结果，这里利用unquote()方法还原，结果如下：

 https://www.baidu.com/s?wd=壁纸

 

可以看到，利用unquote()方法可以方便地实现解码。

本节中，我们介绍了parse模块的一些常用URL处理方法。有了这些方法，我们可以方便地实现URL的解析和构造，建议熟练掌握。

分析Robots协议robotparser

 

1. Robots协议

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

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

下面我们看一个robots.txt的样例：

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

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

上面的User-agent描述了搜索爬虫的名称，这里将其设置为*则代表该协议对任何爬取爬虫有效。比如，我们可以设置：

 User-agent: Baiduspider

这就代表我们设置的规则对百度爬虫是有效的。如果有多条User-agent记录，则就会有多个爬虫会受到爬取限制，但至少需要指定一条。

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

Allow一般和Disallow一起使用，一般不会单独使用，用来排除某些限制。现在我们设置为/public/，则表示所有页面不允许抓取，但可以抓取public目录。

下面我们再来看几个例子。禁止所有爬虫访问任何目录的代码如下：

 User-agent: * 
 Disallow: /

允许所有爬虫访问任何目录的代码如下：

 User-agent: *
 Disallow:

另外，直接把robots.txt文件留空也是可以的。

禁止所有爬虫访问网站某些目录的代码如下：

 User-agent: *
 Disallow: /private/
 Disallow: /tmp/

只允许某一个爬虫访问的代码如下：

 User-agent: WebCrawler
 Disallow:
 User-agent: *
 Disallow: /

这些是robots.txt的一些常见写法。

2. 爬虫名称

大家可能会疑惑，爬虫名是哪儿来的？为什么就叫这个名？其实它是有固定名字的了，比如百度的就叫作BaiduSpider。表3-1列出了一些常见的搜索爬虫的名称及对应的网站。

一些常见搜索爬虫的名称及其对应的网站

爬虫名称	名称	网站
BaiduSpider	百度	www.baidu.com
Googlebot	谷歌	www.google.com
360Spider	360搜索	www.so.com
YodaoBot	有道	www.youdao.com
ia_archiver	Alexa	www.alexa.cn
Scooter	altavista	www.altavista.com

3. robotparser

了解Robots协议之后，我们就可以使用robotparser模块来解析robots.txt了。该模块提供了一个类RobotFileParser，它可以根据某网站的robots.txt文件来判断一个爬取爬虫是否有权限来爬取这个网页。

该类用起来非常简单，只需要在构造方法里传入robots.txt的链接即可。首先看一下它的声明：

 urllib.robotparser.RobotFileParser(url='')

当然，也可以在声明时不传入，默认为空，最后再使用set_url()方法设置一下也可。

下面列出了这个类常用的几个方法。

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

• read()：读取robots.txt文件并进行分析。注意，这个方法执行一个读取和分析操作，如果不调用这个方法，接下来的判断都会为False，所以一定记得调用这个方法。这个方法不会返回任何内容，但是执行了读取操作。

• parse()：用来解析robots.txt文件，传入的参数是robots.txt某些行的内容，它会按照robots.txt的语法规则来分析这些内容。

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

• mtime()：返回的是上次抓取和分析robots.txt的时间，这对于长时间分析和抓取的搜索爬虫是很有必要的，你可能需要定期检查来抓取最新的robots.txt。

• modified()：它同样对长时间分析和抓取的搜索爬虫很有帮助，将当前时间设置为上次抓取和分析robots.txt的时间。

下面我们用实例来看一下：

 from urllib.robotparser import RobotFileParser
  
 rp = RobotFileParser()
 rp.set_url('http://www.jianshu.com/robots.txt')
 rp.read()
 print(rp.can_fetch('*', 'http://www.jianshu.com/p/b67554025d7d'))
 print(rp.can_fetch('*', "http://www.jianshu.com/search?q=python&page=1&type=collections"))

这里以简书为例，首先创建RobotFileParser对象，然后通过set_url()方法设置了robots.txt的链接。当然，不用这个方法的话，可以在声明时直接用如下方法设置：

 rp = RobotFileParser('http://www.jianshu.com/robots.txt')

接着利用can_fetch()方法判断了网页是否可以被抓取。

运行结果如下：

 True
 False

这里同样可以使用parse()方法执行读取和分析，示例如下：

 from urllib.robotparser import RobotFileParser
 from urllib.request import urlopen
  
 rp = RobotFileParser()
 rp.parse(urlopen('http://www.jianshu.com/robots.txt').read().decode('utf-8').split('\n'))
 print(rp.can_fetch('*', 'http://www.jianshu.com/p/b67554025d7d'))
 print(rp.can_fetch('*', "http://www.jianshu.com/search?q=python&page=1&type=collections"))

运行结果一样：

 True
 False