目录
一、处理异常
上一节，我们学习了如何发送网络请求。但在实际使用中，网络情况往往不稳定，很容易出现异常。要是对这些异常不管不顾，程序就可能报错，甚至直接终止运行。所以，对异常进行处理是很有必要的。
在Python的urllib库中，`error`模块专门定义了`request`模块在运行时可能产生的各种异常。也就是说，当`request`模块执行出现问题时，就会抛出`error`模块里预先定义好的异常 。
1.1 URLError
`URLError`类包含在urllib库的`error`模块里，它从`OSError`类继承而来，是`error`模块里处理异常的基础类。只要是`request`模块运行过程中产生的异常，都可以通过捕获`URLError`类来处理。`URLError`类有个`reason`属性，借助它能够获取到报错的具体原因。
下面通过实例来看：
from urllib import request, error
try:
response = request.urlopen('https://cuiqingcai.com/index.htm')
except error.URLError as e:
print(e.reason)我们尝试打开一个不存在的页面，正常情况下应该会报错。但通过捕获`URLError`这个异常，运行结果如下：
Not Found
程序没直接报错，而是输出了上面那些内容。这么做，一方面能防止程序因异常而终止运行，另一方面也实现了对异常的有效处理。
1.2 HTTPError
`HTTPError`隶属于`URLError`子类，主要用来处理HTTP请求时出现的错误，像认证请求失败这类问题。它包含3个属性：
- `code`：给出HTTP状态码，比如404意味着网页找不到，500代表服务器内部出错。
- `reason`：和父类功能相同，都是为了给出错误的成因。
- `headers`：返回请求头信息。
下面通过几个实例来了解：
from urllib import request, error
try:
response = request.urlopen('https://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:<https://cuiqingcai.com/wp-json/>;rel="https://api.w.org/"
同样是访问该网址，这里捕获了`HTTPError`异常，并输出了`reason`、`code`和`headers`属性。由于`URLError`是`HTTPError`的父类，因此可以先捕获子类错误，再捕获父类错误。
上述代码更优的写法如下：
from urllib import request, error
try:
response = request.urlopen('https://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`模块的使用方法。在编写程序时，合理地捕获异常，不仅能更准确地判断异常类型，还能增强程序的稳定性，减少错误发生。
二、解析链接
前面讲过，urllib库包含`parse`模块。这个模块制定了处理URL的标准接口，能实现URL各部分的提取、整合，以及链接的转换。`parse`模块支持处理多种协议的URL，像`file`、`fp`、`gopher` ，还有日常常用的`http`、`https`，以及`imap`、`mailto`等。接下来这节，会介绍`parse`模块里一些常用方法，帮助大家体会这些方法在处理URL时有多方便。
2.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')
运行后能看到，`urlparse()`方法返回的结果是`ParseResult`类型对象，这个对象包含6个部分，分别为`scheme`、`netloc`、`path`、`params`、`query`和`fragment`。
以`http://www.baidu.com/index.html;user?id=5#comment`这个URL为例，`urlparse()`方法把它拆成了6个部分。仔细观察会发现，解析URL时存在特定分隔符：`://`前面的内容是`scheme`，代表协议类型；第一个`/`前面的是`netloc`，也就是域名，`/`后面的则是`path`，即访问路径；分号`;`前面的是`params`，用来表示参数；问号`?`后面是`query`查询条件，常见于GET类型URL；井号`#`后面是锚点，能直接定位到页面内部特定位置。
由此可知，标准URL格式为`scheme://netloc/path;params?query#fragment`，只要是标准URL，都能通过`urlparse()`方法进行拆分。
除了上述基本解析方式，`urlparse()`方法还有其他配置。下面来看它的API用法：`urllib.parse.urlparse(urlstring, scheme='', allow_fragments=True)`，该方法有3个参数：
- `urlstring`：这是必须填写的参数，就是需要解析的URL。
- `scheme`：默认协议类型（如`http`、`https`）。当URL中没有协议信息时，就会将此参数值作为默认协议 。
-`allow_fragments`：指的是是否忽略`fragment`。要是把它设成`False`，`fragment`部分就会被忽略，它会被当成`path`、`parameters`或者`query`的一部分来解析，`fragment`部分就没内容了。
通过实例来看：
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`参数后，返回结果里的`scheme`就是`https`。
要是URL本身带有`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.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的构造。
2.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
2.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
2.5 urljoin()
使用`urlunparse()`和`urlunsplit()`方法，能实现链接的合并。不过，使用这两个方法时，需要有一个特定长度的对象，并且链接的各个部分必须清晰区分开来。
除了上述两种方法，`urljoin()`也能用来生成链接。使用`urljoin()`方法时，第一个参数是`base_url`（基础链接），第二个参数是新链接。这个方法会分析`base_url`中的`scheme`（协议）、`netloc`（域名）和`path`（路径），若新链接中缺少这些部分，它会用`base_url`中的对应部分进行补充，最后返回生成的链接。
下面通过几个实例来看：
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`三项内容。如果这三项在新的链接里不存在，就予以补充；如果新的链接存在，就使用新链接的部分。而`base_url`中的`params`、`query`和`fragment`不起作用。
通过`urljoin()`方法，我们可以轻松实现链接的解析、拼合与生成。
2.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的参数时，只需调用该方法即可。
2.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']}
可以看到，这样就成功转回为字典类型了。
2.8 parse_qsl()
另外，还有一个`parse_qsl()`方法，它用于将参数转化为元组组成的列表。示例如下：
from urllib.parse import parse_qsl
query = 'name=germey&age=22'
print(parse_qsl(query))运行结果如下：
[('name', 'germey'), ('age', '22')]
可以看到，运行结果是一个列表，而列表中的每一个元素都是一个元组，元组的第一个内容是参数名，第二个内容是参数值。
2.9 quote()
该方法可以将内容转化为URL编码的格式。URL中带有中文参数时，有时可能会导致乱码问题，此时用这个方法可以将中文字符转化为URL编码。示例如下：
from urllib.parse import quote
keyword = '壁纸'
url = 'https://www.baidu.com/s?wd=' + quote(keyword)
print(url) 这里我们声明了一个中文的搜索文字，然后用`quote()`方法对其进行URL编码，最后得到的结果如下：
https://www.baidu.com/s?wd=%E5%A3%81%E7%BA%B8
2.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协议
借助urllib库的`robotparser`模块，我们能对网站的Robots协议展开分析。在这一节，我们就来简要认识一下这个模块的使用方法。
3.1 Robots协议
Robots协议又叫爬虫协议、机器人协议，其正式名称是网络爬虫排除标准（Robots Exclusion Protocol）。该协议的作用是告知爬虫和搜索引擎，网站中哪些页面能被抓取，哪些不能被抓取。Robots协议一般以`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`记录，那对应的多个爬虫的爬取行为都会受到限制，不过至少得有一条`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`文件常见的写法。
3.2 爬虫名称
大家或许会好奇，爬虫的名字是怎么来的？为啥要叫这些名字呢？其实，爬虫名都是有固定规范的。比如百度的爬虫，就叫`BaiduSpider`。下面这张表，列举了一些常见搜索爬虫的名字，以及它们对应的网站 。
3.3 robotparser
认识Robots协议后，就能借助`robotparser`模块解析`robots.txt`文件了。`robotparser`模块里有个`RobotFileParser`类，通过它可以依据某网站的`robots.txt`文件，判断某个爬虫有没有权限爬取该网站的网页。
这个类使用起来很容易，在创建对象时，只要在构造方法中传入`robots.txt`文件的链接就行。它的声明是`urllib.robotparser.RobotFileParser(url='')`。
要是创建对象时没传入链接，默认链接为空，后续也能使用`seturl()`方法来设置链接。
下面讲讲这个类常用的几个方法：
- `seturl()`：专门用来设置`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.seturl('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`对象，然后通过`seturl()`方法设置了`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
到这里，我们介绍了`robotparser`模块的基本使用方法，还举了一些例子。借助这个模块，我们能轻松判断出哪些页面能被抓取，哪些页面不能被抓取。
参考学习书籍：Python 3网络爬虫开发实战