urlopen#

urllib.request模块提供了最基本的构造HTTP请求的方法，利用它可以模拟浏览器的一个请求发起过程，同时它还带有处理授权验证(authentication)、重定向(redirection)、浏览器Cookies以及其他内容。

以 Python 官网为例，我们来把这个网页抓下来：

1
import urllib.request
2

3
response = urllib.request.urlopen('<https://www.python.org>')
4
print(response.read().decode('utf-8'))
5

6
print(type(response))

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

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

1
import urllib.request
2

3
response = urllib.request.urlopen('<https://www.python.org>')
4
print(response.status)
5
print(response.getheaders())
6
print(response.getheader('Server'))
7

8
print(type(response))
9
# <class 'http.client.HTTPResponse'>

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

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

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

利用最基本的 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 方式。

  1
  import urllib.parse
  2
  import urllib.request
  3
  
  4
  data = bytes(urllib.parse.urlencode({'word': 'hello'}), encoding='utf8')
  5
  response = urllib.request.urlopen('<http://httpbin.org/post>', data=data)
  6
  print(response.read())

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

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

  运行结果如下：

  1
  {
  2
      "args": {},
  3
      "data": "",
  4
      "files": {},
  5
      "form": {
  6
          "word": "hello"
  7
      },
  8
      "headers": {
  9
          "Accept-Encoding": "identity",
  10
          "Content-Length": "10",
  11
          "Content-Type": "application/x-www-form-urlencoded",
  12
          "Host": "httpbin.org",
  13
          "User-Agent": "Python-urllib/3.5"
  14
      },
  15
      "json": null,
  16
      "origin": "123.124.23.253",
  17
      "url":"<http://httpbin.org/post>"
  18
  }

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

• timeout 参数

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

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

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

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

  1
  import socket
  2
  import urllib.request
  3
  import urllib.error
  4
  
  5
  try:
  6
      response = urllib.request.urlopen('<http://httpbin.org/get>', timeout=0.1)
  7
  except urllib.error.URLError as e:
  8
      if isinstance(e.reason, socket.timeout):
  9
          print('TIME OUT')

  这里我们请求了 http://httpbin.org/get 这个测试链接，设置了超时时间是 0.1 秒，然后捕获了 URLError 这个异常，然后判断异常原因是 socket.timeout 类型，意思就是超时异常，就得出它确实是因为超时而报错，打印输出了 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 的用法：

1
import urllib.request
2

3
request = urllib.request.Request('<https://python.org>')
4
response = urllib.request.urlopen(request)
5
print(response.read().decode('utf-8'))

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

它的构造方法如下：

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

1. 第一个参数 url 用于请求 URL，这是必传参数，其他都是可选参数。
2. 第二个参数 data 如果要传，必须传 bytes（字节流）类型的。如果它是字典，可以先用 urllib.parse 模块里的 urlencode() 编码。
3. 第三个参数 headers 是一个字典，它就是请求头，我们可以在构造请求时通过 headers 参数直接构造，也可以通过调用请求实例的 add_header() 方法添加。 添加请求头最常用的用法就是通过修改 User-Agent 来伪装浏览器，默认的 User-Agent 是 Python-urllib，我们可以通过修改它来伪装浏览器。比如要伪装火狐浏览器，你可以把它设置为：Mozilla/5.0 (X11; U; Linux i686) Gecko/20071127 Firefox/
4. 第四个参数 origin_req_host 指的是请求方的 host 名称或者 IP 地址。
5. 第五个参数 unverifiable 表示这个请求是否是无法验证的，默认是 False，意思就是说用户没有足够权限来选择接收这个请求的结果。例如，我们请求一个 HTML 文档中的图片，但是我们没有自动抓取图像的权限，这时 unverifiable 的值就是 True。
6. 第六个参数 method 是一个字符串，用来指示请求使用的方法，比如 GET、POST 和 PUT 等。

1
from urllib import request, parse
2

3
url = '<http://httpbin.org/post>'
4
headers = {'User-Agent': 'Mozilla/4.0 (compatible; MSIE 5.5; Windows NT)',
5
    'Host': 'httpbin.org'
6
}
7
dict = {'name': 'Germey'}
8
data = bytes(parse.urlencode(dict), encoding='utf8')
9
req = request.Request(url=url, data=data, headers=headers, method='POST')
10
response = request.urlopen(req)
11
print(response.read().decode('utf-8'))

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

运行结果如下：

1
{
2
    "args": {},
3
    "data": "",
4
    "files": {},
5
    "form": {
6
        "name": "Germey"
7
    },
8
    "headers": {
9
        "Accept-Encoding": "identity",
10
        "Content-Length": "11",
11
        "Content-Type": "application/x-www-form-urlencoded",
12
        "Host": "httpbin.org",
13
        "User-Agent": "Mozilla/4.0 (compatible; MSIE 5.5; Windows NT)"
14
    },
15
    "json": null,
16
    "origin": "219.224.169.11",
17
    "url":"<http://httpbin.org/post>"
18
}

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

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

1
req = request.Request(url=url, data=data, method='POST')
2
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 呢？因为需要实现更高级的功能。

Opener 可以使用 open 方法，返回的类型和 urlopen 如出一辙，同时可以利用 Handler 来构建 Opener。

• 验证

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

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

  1
  from urllib.request import HTTPPasswordMgrWithDefaultRealm, HTTPBasicAuthHandler, build_opener
  2
  from urllib.error import URLError
  3
  
  4
  username = 'username'
  5
  password = 'password'
  6
  url = '<http://localhost:5000/>'
  7
  
  8
  p = HTTPPasswordMgrWithDefaultRealm()
  9
  p.add_password(None, url, username, password)
  10
  auth_handler = HTTPBasicAuthHandler(p)
  11
  opener = build_opener(auth_handler)
  12
  
  13
  try:
  14
      result = opener.open(url)
  15
      html = result.read().decode('utf-8')
  16
      print(html)
  17
  except URLError as e:
  18
      print(e.reason)

  这里首先实例化 HTTPBasicAuthHandler 对象，其参数是 HTTPPasswordMgrWithDefaultRealm 对象，它利用 add_password 方法添加进去用户名和密码，这样就建立了一个处理验证的 Handler。

  接下来，利用这个 Handler 并使用 build_opener 方法构建一个 Opener，这个 Opener 在发送请求时就相当于已经验证成功了。然后，利用 Opener 的 open 方法打开链接，就可以完成验证了。这里获取到的结果就是验证后的页面源码内容。

• 代理

  有些网站会检测某一段时间某个 IP 的访问次数，如果访问次数过多，它会禁止你的访问。所以我们可以设置一些代理服务器，每隔一段时间换一个代理，就算 IP 被禁止，依然可以换个 IP 继续爬取。

  代理的设置也是通过 Handler 来实现的，这里介绍下 ProxyHandler 的用法：

  1
  from urllib.error import URLError
  2
  from urllib.request import ProxyHandler, build_opener
  3
  
  4
  proxy_handler = ProxyHandler({
  5
      'http': '<http://127.0.0.1>：9743',
  6
      'https': '<https://127.0.0.1:9743>'
  7
  })
  8
  opener = build_opener(proxy_handler)
  9
  try:
  10
      response = opener.open('<https://www.baidu.com>')
  11
      print(response.read().decode('utf-8'))
  12
  except URLError as e:
  13
      print(e.reason)

  这里我们在本地搭建了一个代理，它运行在 9743 端口上。以及使用了 ProxyHandler，其参数是一个字典，键名是协议类型（比如 HTTP 或者 HTTPS 等），键值是代理链接，可以添加多个代理。

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

• Cookies

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

  1
  import http.cookiejar, urllib.request
  2
  
  3
  cookie = http.cookiejar.CookieJar()
  4
  handler = urllib.request.HTTPCookieProcessor(cookie)
  5
  opener = urllib.request.build_opener(handler)
  6
  response = opener.open('<http://www.baidu.com>')
  7
  for item in cookie:
  8
      print(item.name+"="+item.value)

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

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

  也可以输出成文件格式，我们知道 Cookies 实际上也是以文本形式保存的。

  1
  filename = 'cookies.txt'
  2
  cookie = http.cookiejar.MozillaCookieJar(filename)
  3
  handler = urllib.request.HTTPCookieProcessor(cookie)
  4
  opener = urllib.request.build_opener(handler)
  5
  response = opener.open('<http://www.baidu.com>')
  6
  cookie.save(ignore_discard=True, ignore_expires=True)

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

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

  要保存成 LWP 格式的 Cookies 文件，可以在声明时就改为：cookie = http.cookiejar.LWPCookieJar(filename)

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

  1
  cookie = http.cookiejar.LWPCookieJar()
  2
  cookie.load('cookies.txt', ignore_discard=True, ignore_expires=True)
  3
  handler = urllib.request.HTTPCookieProcessor(cookie)
  4
  opener = urllib.request.build_opener(handler)
  5
  response = opener.open('<http://www.baidu.com>')
  6
  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

URLError#

URLError 类来自 urllib 库的 error 模块，它继承自 OSError 类，是 error 异常模块的基类，由 request 模块产生的异常都可以通过捕获这个类来处理。 它具有一个属性 reason，即返回错误的原因。

1
from urllib import request, error
2
try:
3
    response = request.urlopen('<https://cuiqingcai.com/index.htm>')
4
except error.URLError as e:
5
    print(e.reason)

我们打开一个不存在的页面，照理来说应该会报错，但是这时我们捕获了 URLError 这个异常，运行结果如下： Not Found 程序没有直接报错，而是输出了如上内容，这样通过如上操作，我们就可以避免程序异常终止，同时异常得到了有效处理。

HTTPError#

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

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

1
from urllib import request,error
2
try:
3
    response = request.urlopen('<https://cuiqingcai.com/index.htm>')
4
except error.HTTPError as e:
5
    print(e.reason, e.code, e.headers, sep='\\n')

运行结果如下：

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

依然是同样的网址，这里捕获了 HTTPError 异常，输出了 reason、code 和 headers 属性。 因为 URLError 是 HTTPError 的父类，所以可以先选择捕获子类的错误，再去捕获父类的错误，所以上述代码更好的写法如下：

1
from urllib import request, error
2

3
try:
4
    response = request.urlopen('<https://cuiqingcai.com/index.htm>')
5
except error.HTTPError as e:
6
    print(e.reason, e.code, e.headers, sep='\\n')
7
except error.URLError as e:
8
    print(e.reason)
9
else:
10
    print('Request Successfully')

这样就可以做到先捕获 HTTPError，获取它的错误状态码、原因、headers 等信息。如果不是 HTTPError 异常，就会捕获 URLError 异常，输出错误原因。最后，用 else 来处理正常的逻辑。这是一个较好的异常处理写法。 有时候，reason 属性返回的不一定是字符串，也可能是一个对象。

1
import socket
2
import urllib.request
3
import urllib.error
4

5
try:
6
    response = urllib.request.urlopen('<https://www.baidu.com>', timeout=0.01)
7
except urllib.error.URLError as e:
8
    print(type(e.reason))
9
    if isinstance(e.reason, socket.timeout):
10
        print('TIME OUT')

这里我们直接设置超时时间来强制抛出 timeout 异常。 运行结果如下： <class'socket.timeout'> TIME OUT 可以发现，reason 属性的结果是 socket.timeout 类。所以，这里我们可以用 isinstance 方法来判断它的类型，作出更详细的异常判断。

urlparse#

该方法可以实现 URL 的识别和分段

1
from urllib.parse import urlparse
2

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

<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。

可以发现，urlparse 方法将其拆分成了 6 个部分。大体观察可以发现，解析时有特定的分隔符。比如，:// 前面的就是 scheme，代表协议；第一个 / 符号前面便是 netloc，即域名，后面是 path，即访问路径；分号；后面是 params，代表参数；问号？后面是查询条件 query，一般用作 GET 类型的 URL；井号 #后面是锚点，用于直接定位页面内部的下拉位置。

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

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

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

1
# API配置
2
urllib.parse.urlparse(urlstring, scheme='', allow_fragments=True)

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

• urlstring：这是必填项，即待解析的 URL。
• scheme：它是默认的协议（比如 http 或 https 等）。 scheme 参数只有在 URL 中不包含 scheme 信息时才生效。如果 URL 中有 scheme 信息，就会返回解析出的 scheme。
• allow_fragments：即是否忽略 fragment。如果它被设置为 False，fragment 部分就会被忽略，它会被解析为 path、parameters 或者 query 的一部分，而 fragment 部分为空。

urlunparse#

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

1
from urllib.parse import urlunparse
2

3
data = ['http', 'www.baidu.com', 'index.html', 'user', 'a=6', 'comment']
4
print(urlunparse(data))

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

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

urlsplit#

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

1
from urllib.parse import urlsplit
2

3
result = urlsplit('<http://www.baidu.com/index.html;user?id=5#comment>')
4
print(result)

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

urlunsplit#

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

1
from urllib.parse import urlunsplit
2

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

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

urljoin#

有了 urlunparse 和 urlunsplit 方法，我们可以完成链接的合并，不过前提必须要有特定长度的对象，链接的每一部分都要清晰分开。 此外，生成链接还有另一个方法，那就是 urljoin 方法。我们可以提供一个 base_url（基础链接）作为第一个参数，将新的链接作为第二个参数，该方法会分析 base_url 的 scheme、netloc 和 path 这 3 个内容并对新链接缺失的部分进行补充，最后返回结果。

1
from urllib.parse import urljoin
2

3
print(urljoin('<http://www.baidu.com>', 'FAQ.html'))
4
print(urljoin('<http://www.baidu.com>', '<https://cuiqingcai.com/FAQ.html>'))
5
print(urljoin('<http://www.baidu.com/about.html>', '<https://cuiqingcai.com/FAQ.html>'))
6
print(urljoin('<http://www.baidu.com/about.html>', '<https://cuiqingcai.com/FAQ.html?question=2>'))
7
print(urljoin('<http://www.baidu.com?wd=abc>', '<https://cuiqingcai.com/index.php>'))
8
print(urljoin('<http://www.baidu.com>', '?category=2#comment'))
9
print(urljoin('www.baidu.com', '?category=2#comment'))
10
print(urljoin('www.baidu.com#comment', '?category=2'))

运行结果如下：

1
<http://www.baidu.com/FAQ.html>
2
<https://cuiqingcai.com/FAQ.html>
3
<https://cuiqingcai.com/FAQ.html>
4
<https://cuiqingcai.com/FAQ.html?question=2>
5
<https://cuiqingcai.com/index.php>
6
<http://www.baidu.com?category=2#comment>
7
www.baidu.com?category=2#comment
8
www.baidu.com?category=2

可以发现，base_url 提供了三项内容 scheme、netloc 和 path。如果这 3 项在新的链接里不存在，就予以补充；如果新的链接存在，就使用新的链接的部分。而 base_url 中的 params、query 和 fragment 是不起作用的。 通过 urljoin 方法，我们可以轻松实现链接的解析、拼合与生成。

urlencode#

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

1
from urllib.parse import urlencode
2

3
params = {
4
    'name': 'germey',
5
    'age': 22
6
}
7
base_url = '<http://www.baidu.com>?'
8
url = base_url + urlencode(params)
9
print(url)

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

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

可以看到，参数就成功地由字典类型转化为 GET 请求参数了。 这个方法非常常用。有时为了更加方便地构造参数，我们会事先用字典来表示。要转化为 URL 的参数时，只需要调用该方法即可。

parse_qs#

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

1
from urllib.parse import parse_qs
2

3
query = 'name=germey&age=22'
4
print(parse_qs(query))

parse_qsl#

另外，还有一个 parse_qsl 方法，它用于将参数转化为元组组成的列表

1
from urllib.parse import parse_qsl
2

3
query = 'name=germey&age=22'
4
print(parse_qsl(query))

quote#

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

1
from urllib.parse import quote
2

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

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

https://www.baidu.com/s?wd=% E5% A3%81% E7% BA% B8

unquote#

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

1
from urllib.parse import unquote
2

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

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

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

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

Robots 协议#

Robots 协议也称作爬虫协议、机器人协议，它的全名叫作网络爬虫排除标准（Robots Exclusion Protocol），用来告诉爬虫和搜索引擎哪些页面可以抓取，哪些不可以抓取。它通常是一个叫作 robots.txt 的文本文件，一般放在网站的根目录下。 当搜索爬虫访问一个站点时，它首先会检查这个站点根目录下是否存在 robots.txt 文件，如果存在，搜索爬虫会根据其中定义的爬取范围来爬取。如果没有找到这个文件，搜索爬虫便会访问所有可直接访问的页面。 下面我们看一个 robots.txt 的样例：

1
User-agent: *
2
Disallow: /
3
Allow: /public/3

这实现了对所有搜索爬虫只允许爬取 public 目录的功能，将上述内容保存成 robots.txt 文件，放在网站的根目录下，和网站的入口文件（比如 index.php、index.html 和 index.jsp 等）放在一起。 上面的 User-agent 描述了搜索爬虫的名称，这里将其设置为* 则代表该协议对任何爬取爬虫有效。比如，我们可以设置： User-agent: Baiduspider 这就代表我们设置的规则对百度爬虫是有效的。如果有多条 User-agent 记录，则就会有多个爬虫会受到爬取限制，但至少需要指定一条。 Disallow 指定了不允许抓取的目录，比如上例子中设置为 / 则代表不允许抓取所有页面。 Allow 一般和 Disallow 一起使用，一般不会单独使用，用来排除某些限制。现在我们设置为 /public/，则表示所有页面不允许抓取，但可以抓取 public 目录。 下面我们再来看几个例子。

1
<!-- 禁止所有爬虫访问任何目录的代码如下： -->
2
User-agent: *
3
Disallow: /
4
<!-- 允许所有爬虫访问任何目录的代码如下： -->
5
User-agent: *
6
Disallow:
7
<!-- 另外，直接把 robots.txt 文件留空也是可以的。 -->
8
<!-- 禁止所有爬虫访问网站某些目录的代码如下： -->
9
User-agent: *
10
Disallow: /private/
11
Disallow: /tmp/
12
<!-- 只允许某一个爬虫访问的代码如下： -->
13
User-agent: WebCrawler
14
Disallow:
15
User-agent: *
16
Disallow: /

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

爬虫名称#

大家可能会疑惑，爬虫名是哪儿来的？为什么就叫这个名？其实它是有固定名字的了，比如百度的就叫作 BaiduSpider。

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 的时间。

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

1
from urllib.robotparser import RobotFileParser
2
rp = RobotFileParser()
3
rp.set_url('<http://www.jianshu.com/robots.txt>')
4
rp.read()
5
print(rp.can_fetch('*', '<http://www.jianshu.com/p/b67554025d7d>'))
6
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 方法判断了网页是否可以被抓取。 运行结果如下：

1
True
2
False

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

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

urlopen#

The urllib.request module provides the most basic method to construct HTTP requests. It can simulate a browser’s request initiation process, and it also handles authentication, redirection, browser cookies, and other content.

Take the Python official site as an example; we’ll fetch this page:

1
import urllib.request
2

3
response = urllib.request.urlopen('<https://www.python.org>')
4
print(response.read().decode('utf-8'))
5

6
print(type(response))

An HTTPResponse object mainly contains methods such as read, readinto, getheader, getheaders, fileno, and attributes like msg, version, status, reason, debuglevel, and closed.

After obtaining this object, assign it to a variable named response, and you can call these methods and attributes to obtain a return information series.

1
import urllib.request
2

3
response = urllib.request.urlopen('<https://www.python.org>')
4
print(response.status)
5
print(response.getheaders())
6
print(response.getheader('Server'))
7

8
print(type(response))
9
# <class 'http.client.HTTPResponse'>

It can be seen that the return is an HTTPResponse type object, mainly containing methods such as read, readinto, getheader, getheaders, fileno, and attributes like msg, version, status, reason, debuglevel, and closed.

After obtaining this object, assign it to a variable named response, and you can call these methods and attributes to obtain a series of information about the return result.

For example, calling read can obtain the web page content, and accessing the status attribute gives the status code of the response, where 200 indicates success and 404 indicates not found, etc.

Using the most basic urlopen method, you can complete the simplest GET request for a web page.

If you want to pass parameters in the link, how can you implement that? First, look at the urlopen method API:

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

You can see that besides the first argument which can pass a URL, we can also pass other contents, such as data (payload), timeout (timeout) and so on.

• data parameter The data parameter is optional. If you want to add this parameter, you must convert the parameter to a bytes type using the bytes method. Also, if this parameter is passed, the request method is no longer GET but POST.

  1
  import urllib.parse
  2
  import urllib.request
  3
  
  4
  data = bytes(urllib.parse.urlencode({'word': 'hello'}), encoding='utf8')
  5
  response = urllib.request.urlopen('<http://httpbin.org/post>', data=data)
  6
  print(response.read())

  Here, we pass a parameter word with the value hello. It needs to be encoded into bytes. The bytes method requires the first argument to be a string, and you should use urllib.parse.urlencode to convert the parameter dictionary into a string; the second argument specifies the encoding, here utf8.

  The target site here is httpbin.org, which provides HTTP request testing. Our request URL is http://httpbin.org/post, a URL that can be used to test POST requests. It outputs some information about the Request, including the data parameter we passed.

  The result is as follows:

  1
  {
  2
      "args": {},
  3
      "data": "",
  4
      "files": {},
  5
      "form": {
  6
          "word": "hello"
  7
      },
  8
      "headers": {
  9
          "Accept-Encoding": "identity",
  10
          "Content-Length": "10",
  11
          "Content-Type": "application/x-www-form-urlencoded",
  12
          "Host": "httpbin.org",
  13
          "User-Agent": "Python-urllib/3.5"
  14
      },
  15
      "json": null,
  16
      "origin": "123.124.23.253",
  17
      "url":"<http://httpbin.org/post>"
  18
  }

  As you can see, the parameter we passed appears in the form field, indicating that we simulated a form submission using the POST method to transmit data.

• timeout parameter

  The timeout parameter is used to set a timeout in seconds. It means that if the request exceeds this time without a response, an exception will be raised. If this parameter is not specified, a global default time will be used. It supports HTTP, HTTPS, and FTP requests.

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

  Here the timeout is set to 1 second. After 1 second, the server still hasn’t responded, so an URLError exception is raised. This exception comes from the urllib.error module, and the reason is a timeout.

  Therefore, you can control a webpage’s crawl by setting this timeout. This can be implemented with try-except as follows:

  1
  import socket
  2
  import urllib.request
  3
  import urllib.error
  4
  
  5
  try:
  6
      response = urllib.request.urlopen('<http://httpbin.org/get>', timeout=0.1)
  7
  except urllib.error.URLError as e:
  8
      if isinstance(e.reason, socket.timeout):
  9
          print('TIME OUT')

  Here we request the test URL http://httpbin.org/get with a timeout of 0.1 seconds, and then catch the URLError exception, checking that the reason is socket.timeout, meaning a timeout error occurred.

  Timeout handling via the timeout parameter can be very useful.

• Other parameters

  In addition to data and timeout, there are also context, cafile, capath, cadefault, etc. The context must be an ssl.SSLContext object to specify SSL settings. Besides, cafile and capath specify CA certificates and their paths, which are useful when requesting HTTPS links. The cadefault parameter has been deprecated and its default is False.

  We have explained how to use the urlopen method above. With this fundamental method, we can complete simple requests and webpage crawling. For more detailed information, refer to the official documentation: https://docs.python.org/3/library/urllib.request.html.

Request#

We know that using the urlopen method can initiate the most basic request, but these simple parameters are not enough to build a complete request. If you need to add information such as headers in the request, you can use the more powerful Request class to construct it.

First, let’s feel the usage of Request with an example:

1
import urllib.request
2

3
request = urllib.request.Request('<https://python.org>')
4
response = urllib.request.urlopen(request)
5
print(response.read().decode('utf-8'))

We can see that we still use the urlopen method to send this request; the only difference is that this time the argument is not a URL but a Request object. By constructing this data structure, we can separate the request into an object and configure parameters more richly and flexibly.

Its constructor is as follows:

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

1. The first parameter url is the request URL and is required; the others are optional.
2. The second parameter data, if provided, must be of type bytes. If it is a dictionary, you can first use urllib.parse.urlencode() to encode it.
3. The third parameter headers is a dictionary representing the request headers. You can construct it directly via the headers parameter when creating the request, or you can add headers later by calling add_header() on the request instance. Adding request headers most commonly via modifying the User-Agent to masquerade as a browser. The default User-Agent is Python-urllib; you can modify it to masquerade as a browser. For example, to masquerade as Firefox, you can set it to: Mozilla/5.0 (X11; U; Linux i686) Gecko/20071127 Firefox/
4. The fourth parameter origin_req_host refers to the host name or IP address of the requester.
5. The fifth parameter unverifiable indicates whether this request is verifiable; the default is False, meaning the user does not have sufficient permission to choose the outcome of receiving this request. For example, if we request an image within an HTML document but we do not have permission to automatically fetch images, the unverifiable value would be True.
6. The sixth parameter method is a string used to indicate the method used by the request, such as GET, POST, PUT, etc.

1
from urllib import request, parse
2

3
url = '<http://httpbin.org/post>'
4
headers = {'User-Agent': 'Mozilla/4.0 (compatible; MSIE 5.5; Windows NT)',
5
    'Host': 'httpbin.org'
6
}
7
dict = {'name': 'Germey'}
8
data = bytes(parse.urlencode(dict), encoding='utf8')
9
req = request.Request(url=url, data=data, headers=headers, method='POST')
10
response = request.urlopen(req)
11
print(response.read().decode('utf-8'))

Here we construct a request with four parameters, where url is the request URL, headers specify User-Agent and Host, data is converted to bytes via urlencode and bytes, and the request method is set to POST.

The following shows the result:

1
{
2
    "args": {},
3
    "data": "",
4
    "files": {},
5
    "form": {
6
        "name": "Germey"
7
    },
8
    "headers": {
9
        "Accept-Encoding": "identity",
10
        "Content-Length": "11",
11
        "Content-Type": "application/x-www-form-urlencoded",
12
        "Host": "httpbin.org",
13
        "User-Agent": "Mozilla/4.0 (compatible; MSIE 5.5; Windows NT)"
14
    },
15
    "json": null,
16
    "origin": "219.224.169.11",
17
    "url":"<http://httpbin.org/post>"
18
}

From the result, we can see that we successfully set data, headers, and method.

Headers can also be added using the add_header method:

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

This allows for easier request construction and sending.

Advanced Usage#

In the previous process, although we could construct requests, for more advanced operations (such as cookies handling, proxy settings, etc.), what should we do?

Next, we need more powerful tools: Handlers. In short, you can think of them as various processors—some for login validation, some for handling cookies, some for managing proxies. With them, you can almost do everything in HTTP requests.

First, let’s introduce the BaseHandler class inside the urllib.request module. It is the parent class of all other Handlers and provides the most basic methods, such as default_open, protocol_request, etc.

Next, there are various Handler subclasses that inherit from BaseHandler, for example:

• HTTPDefaultErrorHandler: handles HTTP response errors; errors will raise HTTPError exceptions.
• HTTPRedirectHandler: handles redirection.
• HTTPCookieProcessor: handles Cookies.
• ProxyHandler: configures proxies; the default proxy is none.
• HTTPPasswordMgr: manages passwords; maintains a table of username/password.
• HTTPBasicAuthHandler: handles authentication; if a link requires authentication, this can resolve it.

There are other Handler classes as well; for details, refer to the official documentation: https://docs.python.org/3/library/urllib.request.html#urllib.request.BaseHandler

Another important class is OpenerDirector, which we can call Opener. We have used urlopen before; in fact, it is an Opener provided by urllib for us.

Why introduce Opener? Because it enables more advanced functionality.

An Opener can use the open method; the return type is the same as urlopen, and it can be built using Handlers.

• Authentication

  Some sites present a login prompt on open, requiring you to enter a username and password; you can view the page only after successful authentication.

  To request such a page, you can complete it with HTTPBasicAuthHandler; the relevant code is:

  1
  from urllib.request import HTTPPasswordMgrWithDefaultRealm, HTTPBasicAuthHandler, build_opener
  2
  from urllib.error import URLError
  3
  
  4
  username = 'username'
  5
  password = 'password'
  6
  url = '<http://localhost:5000/>'
  7
  
  8
  p = HTTPPasswordMgrWithDefaultRealm()
  9
  p.add_password(None, url, username, password)
  10
  auth_handler = HTTPBasicAuthHandler(p)
  11
  opener = build_opener(auth_handler)
  12
  
  13
  try:
  14
      result = opener.open(url)
  15
      html = result.read().decode('utf-8')
  16
      print(html)
  17
  except URLError as e:
  18
      print(e.reason)

  Here we first instantiate an HTTPBasicAuthHandler object, whose parameter is an HTTPPasswordMgrWithDefaultRealm object. It uses the add_password method to add the username and password, thereby creating a Handler to perform the authentication.

  Next, use this Handler and build_opener to construct an Opener; this Opener acts as if authentication has already succeeded when sending requests. Then, use the Opener’s open method to open the link, completing the authentication. The result is the page source after authentication.

• Proxies

  Some sites monitor access counts from a given IP. If the count is too high, access may be blocked. We can configure proxies and switch IPs periodically to continue crawling even if one IP is blocked.

  Proxy settings are also implemented via Handlers. Here is how to use ProxyHandler:

  1
  from urllib.error import URLError
  2
  from urllib.request import ProxyHandler, build_opener
  3
  
  4
  proxy_handler = ProxyHandler({
  5
      'http': '<http://127.0.0.1>：9743',
  6
      'https': '<https://127.0.0.1:9743>'
  7
  })
  8
  opener = build_opener(proxy_handler)
  9
  try:
  10
      response = opener.open('<https://www.baidu.com>')
  11
      print(response.read().decode('utf-8'))
  12
  except URLError as e:
  13
      print(e.reason)

  Here we set up a local proxy running on port 9743. ProxyHandler’s argument is a dictionary where the keys are protocol types (e.g., HTTP or HTTPS) and the values are proxy URLs; you can add multiple proxies.

  Then, using this Handler and build_opener, construct an Opener and send requests.

• Cookies

  Handling cookies requires the corresponding Handler.

  1
  import http.cookiejar, urllib.request
  2
  
  3
  cookie = http.cookiejar.CookieJar()
  4
  handler = urllib.request.HTTPCookieProcessor(cookie)
  5
  opener = urllib.request.build_opener(handler)
  6
  response = opener.open('<http://www.baidu.com>')
  7
  for item in cookie:
  8
      print(item.name+"="+item.value)

  First, declare a CookieJar object. Next, use HTTPCookieProcessor to build a Handler, and finally use build_opener to construct an Opener and call open.

  You can see that it prints the name and value of each cookie.

  Cookies can also be saved to a file format. Cookies are stored as text as well.

  1
  filename = 'cookies.txt'
  2
  cookie = http.cookiejar.MozillaCookieJar(filename)
  3
  handler = urllib.request.HTTPCookieProcessor(cookie)
  4
  opener = urllib.request.build_opener(handler)
  5
  response = opener.open('<http://www.baidu.com>')
  6
  cookie.save(ignore_discard=True, ignore_expires=True)

  Here, CookieJar needs to be MozillaCookieJar, which is used when generating files. It handles cookies and file-related events, such as reading and saving cookies, and can save cookies in Mozilla-style browser format.

  LWPCookieJar can also read and save cookies, but its format differs from MozillaCookieJar and saves cookies in the libwww-perl (LWP) format.

  To save as an LWP cookies file, declare it as: cookie = http.cookiejar.LWPCookieJar(filename)

  After generating the cookies file, how do you read it from the file and use it?

  1
  cookie = http.cookiejar.LWPCookieJar()
  2
  cookie.load('cookies.txt', ignore_discard=True, ignore_expires=True)
  3
  handler = urllib.request.HTTPCookieProcessor(cookie)
  4
  opener = urllib.request.build_opener(handler)
  5
  response = opener.open('<http://www.baidu.com>')
  6
  print(response.read().decode('utf-8'))

  You can see that this uses load to read the local Cookies file and obtains its contents. The prerequisite is that you first generate a LWPCookieJar-formatted cookie and save it to a file, then read the cookies and use the same method to build a Handler and an Opener to complete the operation.

  If the page returns normally, you will see the source of the Baidu page.

  The above methods allow you to implement most request feature configurations.

  This is the basic usage of the request module in urllib. For more features, refer to the official documentation: https://docs.python.org/3/library/urllib.request.html#basehandler-objects