python爬虫(3)

爬虫最基本的操作就是模拟浏览器向服务器发出请求。Python提供了功能齐全的类库来帮助我们完成这些请求。最基础的HTTP库有urllib、httplib2、requests、treq等。下面我们学习这些库究竟是如何使用的。

使用urllib

在python2中,有urllib和urllib2两个库来实现请求的发送。在python3中,已经不存在urllib2这个库了,统一为urllib,官方文档为:https://docs.python.org/zh-cn/3/library/urllib.html
urllib库,它是python内置的HTTP请求库,也就是说不需要额外安装即可使用。包含如下4个模块。

  • request——最基本的HTTP请求模块,用来模拟发送请求,只需要给库方法传入URL和额外参数,就可以模拟实现这个过程了。
  • error——异常处理模块,如果出现请求错误,可以捕获这些异常,然后重试或其他操作以确保程序不会意外终止。
  • parse——工具模块,提供了许多URL处理方法,比如拆分、解析、合并等。
  • robotparser——主要用来识别网站的robots.txt文件,然后判断哪些网站可以爬,哪些网站不可以爬。

    request模块

    使用urllib的request模块,可以方便地实现请求的发送并得到响应。
  1. urlopen()

urllib.request模块提供了最基本的构造HTTP请求的方法,还带有处理授权验证(authentication)、重定向(redirection)、浏览器Cookies以及其他内容。
示例代码:

1
2
3
4
5
6
7
8
import urllib.request

response = urllib.request.urlopen('https://www.python.org')
print(type(response))
print(response.status)
print(response.getheaders())
print(response.getheader('Server'))
print(response.read().decode('utf-8'))

运行结果:

1
2
3
4
5
6
<class 'http.client.HTTPResponse'>
200
[('Server', 'nginx'), ('Content-Type', 'text/html; charset=utf-8'), ('X-Frame-Options', 'DENY'), ('Via', '1.1 vegur'), ('Via', '1.1 varnish'), ('Content-Length', '49119'), ('Accept-Ranges', 'bytes'), ('Date', 'Thu, 30 May 2019 09:09:17 GMT'), ('Via', '1.1 varnish'), ('Age', '2642'), ('Connection', 'close'), ('X-Served-By', 'cache-iad2120-IAD, cache-tyo19936-TYO'), ('X-Cache', 'HIT, HIT'), ('X-Cache-Hits', '3, 3620'), ('X-Timer', 'S1559207357.201590,VS0,VE0'), ('Vary', 'Cookie'), ('Strict-Transport-Security', 'max-age=63072000; includeSubDomains')]
nginx
<!doctype html>
...#此处省略代码

上述代码,使用urlopen方法,传入Python官网首页的URL,对其发送了一个请求,返回了一个HTTPResponse类型的对象。
第一条输出语句使用type()方法获取了response的返回对象类型。
第二条输出语句获取了response的status属性,即返回结果的状态码。
第三条输出语句调用了getheaders()方法,返回了响应头。
第四条输出语句调用了getheader()方法,传入了参数’Server’,返回了响应头中的Server值。
第五条输出语句调用了read()方法得到返回的网页内容。

由此可知,调用urlopen()方法,就可以完成最基本的简单网页的GET请求抓取,返回的是HTTPResponse类型的对象。它主要包含read()、readinto()、getheader(name)、fileno()等方法,以及msg、version、status、reason、debuglevel、closed等属性。
但是其实urlopen()方法还可以传递额外的参数,urlopen()函数的API:

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

下面详细说明一下这几个参数的用法:
data参数
可选的。如果要添加该参数,并且如果它是字节流编码格式的内容,即bytes类型,则需要通过bytes()方法转化。另外,如果传递了这个参数,则它的请求方式就不再是GET方式,而是POST方式。
示例代码:

1
2
3
4
5
6
import urllib.parse
import urllib.request

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

运行结果如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
{
"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"
}

这里传递了一个参数word,值是hello。它需要被转码成bytes(字节流)类型。其中转字节流使用了bytes()方法,该方法的第一个参数需要是str(字符串)类型,需要用urllib.parse模块里的urlencode()方法来将参数字典转化为字符串;第二个参数指定编码格式,这里指定为utf8。
请求的站点是httpbin.org,它可以提供HTTP请求测试。本次我们请求的URL为http://httpbin.org/post,这个链接可以用来测试POST请求,它可以输出请求的一些信息,其中包含我们传递的data参数。
由运行结果可知,我们传递的参数出现在了form字段中,这表明是模拟了表单提交的方式,以POST方式传输数据。

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

1
2
3
4
5
6
7
8
9
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')

运行结果:

1
TIME OUT

这里设置超时时间为0.1秒,程序发送请求0.1秒后,服务器没有响应,就抛出了URLError异常,该异常属于urllib.error模块,错误原因是超时。接着判断异常是socket.timeout类型(意思就是超时异常),从而得出它确实是因为超时而报错,打印输出TIME OUT。

其他参数
除了data参数和timeout参数外,还有context参数,它必须是ssl.SSLContext类型,用来指定SSL设置。此外,cafile和capath这两个参数分别指定CA证书和它的路径,这个在请求HTTPS链接时有用。cadefault参数现在已经弃用了,其默认值是false。

  1. Request类

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
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'))

运行结果如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
{
"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"
}

这里,我们依然是用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,我们可以通过修改它来伪装浏览器。
  • 第四个参数origin_req_host指的是请求方的host名称或者IP地址。
  • 第五个参数unverifiable表示这个请求是否是无法验证的,默认是false,意思就是说用户没有足够权限来选择接收这个请求的结果。例如,我们请求一个HTML文档中的图片,但是我们没有自动抓取图像的权限,这时unverifiable的值就是True。
  • 第六个参数method是一个字符串,用来指示请求使用的方法,比如GET、POST和PUT等。
  1. 高级用法

request模块中还有更强大的工具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来构建Opener。
下面用几个实例来说明它们的用法。

验证
有些网站在打开时会弹出提示框,需要填入用户名和密码,验证成功后才能对页面进行查看。
示例代码:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
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()方法打开链接,就可以完成验证了。

代理
在做爬虫时,免不了要使用代理,添加代理,示例如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
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获取下来,示例代码如下:

1
2
3
4
5
6
7
8
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)

运行结果如下:

1
2
3
4
5
6
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

首先,我们必须声明一个CookieJar对象。接下来,就需要利用HTTPCookieProcessor来构建一个Handler。最后利用build_opener()方法构建出Opener,执行open()函数即可。
上面我们获取了Cookie,并将其打印输出了。其实我们还能将其以文本格式进行保存。示例代码如下:

1
2
3
4
5
6
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)

运行之后,就生成了一个cookies.txt文件,内容如下:

1
2
3
4
5
6
7
8
9
10
# 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

这时CookieJar换成了MozillaCookieJar,它在生成文件时会用到,是CookieJar的子类,可以用来处理Cookies和文件相关的事件,比如读取和保存Cookies,可以将Cookies保存成Mozilla型浏览器的Cookies格式。
另外,LWPCookieJar同样可以读取和保存Cookies,但是保存的格式和MozillaCookieJar不一样,它会保存成libwww-perl(LWP)格式的Cookies文件。
要保存成LWP格式的Cookies文件,可以在声明时改成:

cookie = http.cookiejar.LWPCookieJar(filename)

此时生成的内容如下:

1
2
3
4
5
6
7
#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格式为例:

1
2
3
4
5
6
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模块

urlib的error模块定义了由request模块产生的异常。如果出现了问题,request模块就会抛出error模块中定义的异常。

  1. URLError

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

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

运行结果:

1
Not Found

打开了一个不存在的页面,捕获了URLError这个异常。这就避免了程序异常终止,同时异常得到了有效处理。

  1. HTTPError

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

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

示例代码:

1
2
3
4
5
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')

运行结果:

1
2
3
4
5
6
7
8
9
10
11
12
13
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的父类,所以可以先选择捕获子类的错误,再去捕获父类的错误,所以上述代码更好的写法是:

1
2
3
4
5
6
7
8
9
10
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属性返回的不一定是字符串,也可能是一个对象。
示例如下:

1
2
3
4
5
6
7
8
9
10
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')

运行结果:

1
2
<class 'socket.timeout'>
TIME OUT

这里捕获的是timeout异常,reason属性的结果是socket.timeout类。所以,这里用isinstance()方法来判断它的类型,作出更详细的异常判断。

parse模块

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的识别和分段。
示例代码:

1
2
3
4
from urllib.parse import urlparse

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

运行结果:

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

可以看到,利用urlparse()方法进行了一个URL的解析。返回结果是一个ParseResult类型的对象,它包含6部分,分别是scheme、netloc、path、params、query和fragment。通过观察可知,解析时有特定的分隔符。比如,://前面的就是scheme,代表协议;第一个/前面便是netloc,即域名;分号;前面是params,代表参数。据此,可以得出一个标准的链接格式,具体如下:

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

urlparse()方法的API用法:

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

有三个参数:

  • urlstring:必填项,即待解析的URL。
  • scheme::它是默认的协议(比如http或https等),假如这个链接没有带协议信息,会将这个作为默认的协议。
  • allow_fragments:即是否忽略fragment。如果它被设置为False,fragment部分就会被忽略,它会被解析为path、parameters或者query的一部分,而fragment部分为空。

scheme参数只有在URL中不包含scheme信息时才生效,如果URL中有scheme信息,就会解析出scheme。
当URL中不包含params和query时,fragment便会被解析为path的一部分。
返回结果ParseResult实际上是一个元祖,我们可以用索引顺序来获取,也可以用属性名获取。

  1. urlunparse()

其接受的参数是一个可迭代对象,但是它的长度必须是6,否则会抛出参数数量不足或者过多的问题。
示例代码:

1
2
3
4
from urllib.parse import urlunparse

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

运行结果:

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

  1. urlsplit()

这个方法和urlparse()方法类似,只不过它不再单独解析params这一部分,只返回5个结果。
示例代码:

1
2
3
4
from urllib.parse import urlsplit

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

运行结果:

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

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

  1. urlunsplit()

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

1
2
3
4
from urllib.parse import urlunsplit

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

运行结果:

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

  1. urljoin()

可以提供一个base_url(基础链接)作为第一个参数,将新的链接作为第二个参数,该方法会分析base_url的scheme、netloc和path这3个内容并对新链接缺失的部分进行补充,最后返回结果。
示例代码:

1
2
3
4
5
6
7
8
9
10
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'))

运行结果:

1
2
3
4
5
6
7
8
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()方法,我们可以轻松实现链接的解析、拼合与合成。

  1. urlencode

示例代码:

1
2
3
4
5
6
7
8
9
from urllib.parse import urlencode

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

运行结果:

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

首先声明了一个字典来将参数表示出来,然后调用urlencode()方法将其序列化为GET请求参数。
这个方法很有用,有时为了更加方便地构造函数,我们会事先用字典来表示,要转化为URL的参数时,只需要调用该方法即可。

  1. parse_qs()

有了序列化,就有对应的反序列化。有一串GET请求参数,利用parse_qs()方法,就可以将它转回字典。
示例代码:

1
2
3
4
from urllib.parse import parse_qs

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

运行结果:

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

  1. parse_qsl()

用于将参数转化为元祖组成的列表。
示例代码:

1
2
3
4
from urllib.parse import parse_qsl

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

运行结果:

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

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

  1. quote()

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

1
2
3
4
5
from urllib.parse import quote

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

运行结果:

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

  1. unquote()

与上面相反,这是进行URL解码的。
示例代码:

1
2
3
4
from urllib.parse import unquote

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

运行结果:

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

robotparser模块

利用urllib的robotparser模块,我们可以实现网站Robots协议的分析。

  1. Robots协议

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

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

这个协议文本实现了对所有搜索爬虫,只允许爬取public目录的功能。将上述内容保存成robots,txt文件,放在网站的根目录下,和网站的入口文件(比如index.php、index.html和index.jsp等)放在一起。
上面的User-agent描述了搜索爬虫的名称,这里将其设置为*则代表该协议对任何爬虫都有效。
Disallow指定了不允许抓取的目录,比如上例中设置为/则代表不允许抓取所有页面。
Allow一般和Disallow一起使用,一般不会单独使用,用来排除某些限制。上面设置为/public/,则表示所有页面不允许抓取,但可以抓取public目录。
另外,直接把robots.txt文件留空也可以。

  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
  1. robotparser

robotparser模块提供了一个类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
2
3
4
5
6
7
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"))

运行结果:

1
2
True
False

首先创建RobotFileParser对象,然后通过set_url()方法设置了robots.txt的链接。当然也可以下面这样直接声明:

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

接着用can_fetch()方法判断网页是否可被抓取。
这里同样可以使用parse()方法执行读取和分析,示例如下:

1
2
3
4
5
6
7
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"))

运行结果是一样的。

使用requests

虽然使用urllib库能满足我们的要求,但是写起来很不方便,比如网页验证和Cookies,需要写Opener和Handler来处理。为了更加方便地实现这些操作,就有了更为强大的库requests。

基本用法

urllib库中的urlopen()方法实际上是以GET方式请求网页,而requests中相应的方法就是get()方法。
示例代码:

1
2
3
4
5
6
7
8
import requests

r = requests.get('https://www.baidu.com/')
print(type(r))
print(r.status_code)
print(type(r.text))
print(r.text)
print(r.cookies)

运行结果:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
<class 'requests.models.Response'>
200
<class 'str'>
<html>
<head>
<script>
location.replace(location.href.replace("https://","http://"));
</script>
</head>
<body>
<noscript><meta http-equiv="refresh" content="0;url=http://www.baidu.com/"></noscript>
</body>
</html>
<RequestsCookieJar[<Cookie BIDUPSID=992C3B26F4C4D09505C5E959D5FBC005 for .baidu.com/>, <Cookie PSTM=1472227535 for .baidu.com/>, <Cookie __bsi=15304754498609545148_00_40_N_N_2_0303_C02F_N_N_N_0 for .www.baidu.com/>, <Cookie BD_NOT_HTTPS=1 for www.baidu.com/>]>

调用get()方法实现与urlopen()相同的操作,得到一个Response对象,然后分别输出了Response的类型、状态码、响应体的类型、内容以及Cookies。
由运行结果得知,返回类型是requests.models.Response,响应体的类型是字符串str,Cookies的类型是RequestCookieJar。
不只是get()方法,requests还提供了post()、put()、delete()等方法实现了POST、PUT、DELETE等请求。

  1. GET请求

HTTP中最常见的请求之一就是GET请求。
基本实例
首先,创建一个最简单的GET请求,请求的链接为http://httpbin.org/get,该网站会判断如果客户端发起的是GET请求的话,它返回相应的请求信息:

1
2
3
4
import requests

r = requests.get('http://httpbin.org/get')
print(r.text)

运行结果:

1
2
3
4
5
6
7
8
9
10
11
{
"args": {},
"headers": {
"Accept": "*/*",
"Accept-Encoding": "gzip, deflate",
"Host": "httpbin.org",
"User-Agent": "python-requests/2.10.0"
},
"origin": "122.4.215.33",
"url": "http://httpbin.org/get"
}

成功发起了GET请求,返回结果中包含请求头、URL、IP等信息。
对于GET请求,如果要附加额外的信息,可以利用params参数,示例如下:

1
2
3
4
5
6
7
8
import requests

data = {
'name': 'germey',
'age': 22
}
r = requests.get("http://httpbin.org/get", params=data)
print(r.text)

运行结果:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
{
"args": {
"age": "22",
"name": "germey"
},
"headers": {
"Accept": "*/*",
"Accept-Encoding": "gzip, deflate",
"Host": "httpbin.org",
"User-Agent": "python-requests/2.10.0"
},
"origin": "122.4.215.33",
"url": "http://httpbin.org/get?age=22&name=germey"
}

网页的返回类型实际上是str类型,但是它很特殊,是JSON格式的。所以,想要直接返回结果,得到一个字典格式的话,可以直接调用json()方法。但需要注意的是,如果返回结果不是JSON格式,便会出现解析错误,抛出了json.decoder.JSONDecodeError异常。

抓取网页
示例代码:

1
2
3
4
5
6
7
8
9
10
import requests
import re

headers = {
'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_11_4) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/52.0.2743.116 Safari/537.36'
}
r = requests.get("https://www.zhihu.com/explore", headers=headers)
pattern = re.compile('explore-feed.*?question_link.*?>(.*?)</a>', re.S)
titles = re.findall(pattern, r.text)
print(titles)

运行结果:

1
['\n为什么很多人喜欢提及「拉丁语系」这个词?\n', '\n在没有水的情况下水系宝可梦如何战斗?\n', '\n有哪些经验可以送给 Kindle 新人?\n', '\n谷歌的广告业务是如何赚钱的?\n', '\n程序员该学习什么,能在上学期间挣钱?\n', '\n有哪些原本只是一个小消息,但回看发现是个惊天大新闻的例子?\n', '\n如何评价今敏?\n', '\n源氏是怎么把那么长的刀从背后拔出来的?\n', '\n年轻时得了绝症或大病是怎样的感受?\n', '\n年轻时得了绝症或大病是怎样的感受?\n']

上面加入了headers信息,其中包含了User-Agent字段信息,也就是浏览器标识信息。然后用最基础的正则表达式匹配出了所有问题内容。

抓取二进制数据
图片、音频、视频这些文件本质上都是由二进制码组成的,由于有特定的保存格式和对应的解析方案,才能看到丰富的多媒体信息。想要抓取它们,就要拿到它们的二进制码。

1
2
3
4
5
6
7
import requests

r = requests.get("https://github.com/favicon.ico")
print(r.text)
print(r.content)
with open('favicon.ico', 'wb') as f:
f.write(r.content)

先打印了Response对象的两个属性,一个是text,另一个是content。前者出现了乱码,后者是bytes类型的数据。由于图片是二进制数据,前者在打印时转化为str类型,也就是图片直接转化为字符串,所以出现乱码。最后我们调用open方法,第一个参数是文件名称,第二个参数代表以二进制写的形式打开,可以向文件里写入二进制数据,就将图片保存到了favicon.ico文件中。
添加headers
与urllib.request一样,我们也可以通过headers参数来传递头信息。

  1. post请求

示例代码:

1
2
3
4
5
import requests

data = {'name': 'germey', 'age': '22'}
r = requests.post("http://httpbin.org/post", data=data)
print(r.text)

运行结果:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
{
"args": {},
"data": "",
"files": {},
"form": {
"age": "22",
"name": "germey"
},
"headers": {
"Accept": "*/*",
"Accept-Encoding": "gzip, deflate",
"Content-Length": "18",
"Content-Type": "application/x-www-form-urlencoded",
"Host": "httpbin.org",
"User-Agent": "python-requests/2.10.0"
},
"json": null,
"origin": "182.33.248.131",
"url": "http://httpbin.org/post"
}

  1. 响应

发送请求后,得到了响应。上面我们用text和content获取了响应的内容。此外,还有很多属性和方法可以用来获取其他信息,比如状态码、响应头、Cookies等。
示例代码:

1
2
3
4
5
6
7
8
import requests

r = requests.get('http://www.jianshu.com')
print(type(r.status_code), r.status_code)
print(type(r.headers), r.headers)
print(type(r.cookies), r.cookies)
print(type(r.url), r.url)
print(type(r.history), r.history)

运行结果:

1
2
3
4
5
<class 'int'> 200
<class 'requests.structures.CaseInsensitiveDict'> {'X-Runtime': '0.006363', 'Connection': 'keep-alive', 'Content-Type': 'text/html; charset=utf-8', 'X-Content-Type-Options': 'nosniff', 'Date': 'Sat, 27 Aug 2016 17:18:51 GMT', 'Server': 'nginx', 'X-Frame-Options': 'DENY', 'Content-Encoding': 'gzip', 'Vary': 'Accept-Encoding', 'ETag': 'W/"3abda885e0e123bfde06d9b61e696159"', 'X-XSS-Protection': '1; mode=block', 'X-Request-Id': 'a8a3c4d5-f660-422f-8df9-49719dd9b5d4', 'Transfer-Encoding': 'chunked', 'Set-Cookie': 'read_mode=day; path=/, default_font=font2; path=/, _session_id=xxx; path=/; HttpOnly', 'Cache-Control': 'max-age=0, private, must-revalidate'}
<class 'requests.cookies.RequestsCookieJar'> <RequestsCookieJar[<Cookie _session_id=xxx for www.jianshu.com/>, <Cookie default_font=font2 for www.jianshu.com/>, <Cookie read_mode=day for www.jianshu.com/>]>
<class 'str'> http://www.jianshu.com/
<class 'list'> []

status_code属性是状态码,headers属性是响应头,cookies属性是Cookies,url属性是URL,history属性是请求历史。
headers和cookies这两个属性得到的结果分别是CaseInsensitiveDict和RequestsCookieJar类型。
状态码常用来判断请求是否成功,而requests还提供了一个内置的状态码查询对象requests.code。
下面列出了返回码和相应的查询条件:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
# 信息性状态码
100: ('continue',),
101: ('switching_protocols',),
102: ('processing',),
103: ('checkpoint',),
122: ('uri_too_long', 'request_uri_too_long'),

# 成功状态码
200: ('ok', 'okay', 'all_ok', 'all_okay', 'all_good', '\\o/', '✓'),
201: ('created',),
202: ('accepted',),
203: ('non_authoritative_info', 'non_authoritative_information'),
204: ('no_content',),
205: ('reset_content', 'reset'),
206: ('partial_content', 'partial'),
207: ('multi_status', 'multiple_status', 'multi_stati', 'multiple_stati'),
208: ('already_reported',),
226: ('im_used',),

# 重定向状态码
300: ('multiple_choices',),
301: ('moved_permanently', 'moved', '\\o-'),
302: ('found',),
303: ('see_other', 'other'),
304: ('not_modified',),
305: ('use_proxy',),
306: ('switch_proxy',),
307: ('temporary_redirect', 'temporary_moved', 'temporary'),
308: ('permanent_redirect',
'resume_incomplete', 'resume',), # These 2 to be removed in 3.0

# 客户端错误状态码
400: ('bad_request', 'bad'),
401: ('unauthorized',),
402: ('payment_required', 'payment'),
403: ('forbidden',),
404: ('not_found', '-o-'),
405: ('method_not_allowed', 'not_allowed'),
406: ('not_acceptable',),
407: ('proxy_authentication_required', 'proxy_auth', 'proxy_authentication'),
408: ('request_timeout', 'timeout'),
409: ('conflict',),
410: ('gone',),
411: ('length_required',),
412: ('precondition_failed', 'precondition'),
413: ('request_entity_too_large',),
414: ('request_uri_too_large',),
415: ('unsupported_media_type', 'unsupported_media', 'media_type'),
416: ('requested_range_not_satisfiable', 'requested_range', 'range_not_satisfiable'),
417: ('expectation_failed',),
418: ('im_a_teapot', 'teapot', 'i_am_a_teapot'),
421: ('misdirected_request',),
422: ('unprocessable_entity', 'unprocessable'),
423: ('locked',),
424: ('failed_dependency', 'dependency'),
425: ('unordered_collection', 'unordered'),
426: ('upgrade_required', 'upgrade'),
428: ('precondition_required', 'precondition'),
429: ('too_many_requests', 'too_many'),
431: ('header_fields_too_large', 'fields_too_large'),
444: ('no_response', 'none'),
449: ('retry_with', 'retry'),
450: ('blocked_by_windows_parental_controls', 'parental_controls'),
451: ('unavailable_for_legal_reasons', 'legal_reasons'),
499: ('client_closed_request',),

# 服务端错误状态码
500: ('internal_server_error', 'server_error', '/o\\', '✗'),
501: ('not_implemented',),
502: ('bad_gateway',),
503: ('service_unavailable', 'unavailable'),
504: ('gateway_timeout',),
505: ('http_version_not_supported', 'http_version'),
506: ('variant_also_negotiates',),
507: ('insufficient_storage',),
509: ('bandwidth_limit_exceeded', 'bandwidth'),
510: ('not_extended',),
511: ('network_authentication_required', 'network_auth', 'network_authentication')

高级用法

  1. 文件上传

示例代码:

1
2
3
4
5
import requests

files = {'file': open('favicon.ico', 'rb')}
r = requests.post("http://httpbin.org/post", files=files)
print(r.text)

运行结果:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
{
"args": {},
"data": "",
"files": {
"file": "data:application/octet-stream;base64,AAAAAA...="
},
"form": {},
"headers": {
"Accept": "*/*",
"Accept-Encoding": "gzip, deflate",
"Content-Length": "6665",
"Content-Type": "multipart/form-data; boundary=809f80b1a2974132b133ade1a8e8e058",
"Host": "httpbin.org",
"User-Agent": "python-requests/2.10.0"
},
"json": null,
"origin": "60.207.237.16",
"url": "http://httpbin.org/post"
}

需要注意的是,上传的文件favicon.ico需要和当前脚本在同一目录下。
这个网站会返回响应,里面包含files字段,而form字段是空的,表明文件上传部分会单独有一个files字段来标识。

  1. Cookies

示例代码:

1
2
3
4
5
6
import requests

r = requests.get("https://www.baidu.com")
print(r.cookies)
for key, value in r.cookies.items():
print(key + '=' + value)

运行结果:

1
2
3
<RequestsCookieJar[<Cookie BDORZ=27315 for .baidu.com/>, <Cookie __bsi=13533594356813414194_00_14_N_N_2_0303_C02F_N_N_N_0 for .www.baidu.com/>]>
BDORZ=27315
__bsi=13533594356813414194_00_14_N_N_2_0303_C02F_N_N_N_0

这里首先调用cookies属性即可成功得到Cookies,可以发现它是RequestCookieJar类型。然后用items()方法将其转化为元祖组成的列表,遍历输出每一个Cookie的名称和值,实现Cookie的遍历解析。
当然,我们也可以直接用Cookie来维持登录状态,例如:

1
2
3
4
5
6
7
8
9
import requests

headers = {
'Cookie': 'q_c1=31653b264a074fc9a57816d1ea93ed8b|1474273938000|1474273938000; d_c0="AGDAs254kAqPTr6NW1U3XTLFzKhMPQ6H_nc=|1474273938"; __utmv=51854390.100-1|2=registration_date=20130902=1^3=entry_date=20130902=1;a_t="2.0AACAfbwdAAAXAAAAso0QWAAAgH28HQAAAGDAs254kAoXAAAAYQJVTQ4FCVgA360us8BAklzLYNEHUd6kmHtRQX5a6hiZxKCynnycerLQ3gIkoJLOCQ==";z_c0=Mi4wQUFDQWZid2RBQUFBWU1DemJuaVFDaGNBQUFCaEFsVk5EZ1VKV0FEZnJTNnp3RUNTWE10ZzBRZFIzcVNZZTFGQmZn|1474887858|64b4d4234a21de774c42c837fe0b672fdb5763b0',
'Host': 'www.zhihu.com',
'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_11_4) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/53.0.2785.116 Safari/537.36',
}
r = requests.get('https://www.zhihu.com', headers=headers)
print(r.text)

这里替换成你自己的Cookie,将其设置到Headers里面,然后发送请求。
运行结果包含了登录后的结果。
当然,还可以通过cookies参数来设置,不过这样就需要构造RequestsCookieJar对象,而且需要分隔一下cookies。
示例代码:

1
2
3
4
5
6
7
8
9
10
11
12
13
import requests

cookies = 'q_c1=31653b264a074fc9a57816d1ea93ed8b|1474273938000|1474273938000; d_c0="AGDAs254kAqPTr6NW1U3XTLFzKhMPQ6H_nc=|1474273938"; __utmv=51854390.100-1|2=registration_date=20130902=1^3=entry_date=20130902=1;a_t="2.0AACAfbwdAAAXAAAAso0QWAAAgH28HQAAAGDAs254kAoXAAAAYQJVTQ4FCVgA360us8BAklzLYNEHUd6kmHtRQX5a6hiZxKCynnycerLQ3gIkoJLOCQ==";z_c0=Mi4wQUFDQWZid2RBQUFBWU1DemJuaVFDaGNBQUFCaEFsVk5EZ1VKV0FEZnJTNnp3RUNTWE10ZzBRZFIzcVNZZTFGQmZn|1474887858|64b4d4234a21de774c42c837fe0b672fdb5763b0'
jar = requests.cookies.RequestsCookieJar()
headers = {
'Host': 'www.zhihu.com',
'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_11_4) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/53.0.2785.116 Safari/537.36'
}
for cookie in cookies.split(';'):
key, value = cookie.split('=', 1)
jar.set(key, value)
r = requests.get("http://www.zhihu.com", cookies=jar, headers=headers)
print(r.text)

这里我们首先新建了一个RequestCookieJar对象,然后将复制下来的cookies利用split()方法分割,接着利用set()方法设置好每个Cookie的key和value,然后通过调用requests的get()方法并传递给cookies参数即可。

  1. 会话维持

在requests中,如果直接利用get()或post()等方法的确可以做到模拟网页的请求,但是这实际上是相当于不同的会话,也就是说相当于你用了两个浏览器打开了不同的页面。
这里我们需要做到维持会话,也就是相当于打开一个新的浏览器选项卡而不是新开一个浏览器,但是又不想每次设置cookies,就需要用到Session对象。
示例代码:

1
2
3
4
5
6
import requests

s = requests.Session()
s.get('http://httpbin.org/cookies/set/number/123456789')
r = s.get('http://httpbin.org/cookies')
print(r.text)

运行结果:

1
2
3
4
5
{
"cookies": {
"number": "123456789"
}
}

利用Session,可以做到模拟同一个会话而不用担心Cookies的问题。它通常用于模拟登录成功之后再进行下一步的操作。Session在平常用得非常广泛,可以用于模拟在一个浏览器中打开同一站点的不同页面。

  1. SSL证书验证

requests提供了证书验证的功能。当发送HTTP请求的时候,它会检查SSL证书,我们可以利用verify参数控制是否检查此证书。其实如果不加verify参数的话,默认是True,会自动验证。
示例代码:

1
2
3
4
import requests

response = requests.get('https://www.12306.cn')
print(response.status_code)

运行结果:

1
requests.exceptions.SSLError: ("bad handshake: Error([('SSL routines', 'tls_process_server_certificate', 'certificate verify failed')],)",)

这里抛出了一个错误SSLError,表示证书验证错误。
其实,只要我们把verify参数设置为False即可。示例如下:

1
2
3
4
import requests

response = requests.get('https://www.12306.cn', verify=False)
print(response.status_code)

运行结果:

1
2
3
/usr/local/lib/python3.6/site-packages/urllib3/connectionpool.py:852: InsecureRequestWarning: Unverified HTTPS request is being made. Adding certificate verification is strongly advised. See: https://urllib3.readthedocs.io/en/latest/advanced-usage.html#ssl-warnings
InsecureRequestWarning)
200

这样就能打印出请求成功的状态码,还出现了警告信息,它建议我们给它指定证书。我们可以设置忽略警告:

1
2
3
4
5
6
import requests
from requests.packages import urllib3

urllib3.disable_warnings()
response = requests.get('https://www.12306.cn', verify=False)
print(response.status_code)

当然,我们也可以指定一个本地证书用作客户端证书,这可以是单个文件(包含密钥和证书)或一个包含两个文件路径的原则:

1
2
3
4
import requests

response = requests.get('https://www.12306.cn', cert=('/path/server.crt', '/path/key'))
print(response.status_code)

注意,本地私有证书的key必须是解密状态,加密状态的key是不支持的。

  1. 代理设置

设置代理需要用到proxies参数。可以用下面的方式设置:

1
2
3
4
5
6
7
8
import requests

proxies = {
"http": "http://10.10.1.10:3128",
"https": "http://10.10.1.10:1080",
}

requests.get("https://www.taobao.com", proxies=proxies)

注意将上述代理换为自己的代理。
若代理需要使用HTTP Basic Auth,可以使用类似http://user:password@host:port这样的语法来设置代理,示例如下:

1
2
3
4
5
6
import requests

proxies = {
"http": "http://user:password@10.10.1.10:3128/",
}
requests.get("https://www.taobao.com", proxies=proxies)

除了基本的HTTP代理外,requests还支持SOCKS协议的代理。
首先,需要安装socks这个库:

pip3 install ‘requests[socks]’

然后就可以使用SOCKS协议代理了,示例如下:

1
2
3
4
5
6
7
import requests

proxies = {
'http': 'socks5://user:password@host:port',
'https': 'socks5://user:password@host:port'
}
requests.get("https://www.taobao.com", proxies=proxies)

  1. 超时设置

在本机网络状况不好或者服务器网络响应太慢甚至无响应时,我们可能会等待特别久的时间才可能收到响应,甚至到最后收不到响应而报错。为了防止服务器不能及时响应,应该设置一个超时时间,即超过了这个时间还没有得到响应,那就报错。这需要用到timeout参数。这个时间的计算是发出请求到服务器返回响应的时间。示例如下:

1
2
3
4
import requests

r = requests.get("https://www.taobao.com", timeout = 1)
print(r.status_code)

上面将超时时间设置为1秒,如果1秒内没有响应,就会抛出异常。
实际上,请求分为两个阶段,即连接(connect)和读取(read)。
上面设置的timeout将用作连接和读取这二者的timeout总和。
如果要分别指定,就可以传入一个元组:

r = requests.get(‘https://www.taobao.com', timeout=(5,11, 30))

如果想永久等待,可以直接将timeout设置为None,或者不设置直接留空,因为默认是None。这样的话,如果服务器还在运行,但是响应特别慢,那就慢慢等吧,它永远不会返回超时错误。用法如下:

r = requests.get(‘https://www.taobao.com', timeout=None)
或者直接不加参数
r = requests.get(‘https://www.taobao.com')

  1. 身份认证

在访问网站时,可能需要认证,此时可以使用requests自带的身份证认证功能,示例如下:

1
2
3
4
5
import requests
from requests.auth import HTTPBasicAuth

r = requests.get('http://localhost:5000', auth=HTTPBasicAuth('username', 'password'))
print(r.status_code)

如果用户名和密码正确的话,请求时就会自动认证成功,会返回200状态码,如果认证失败,则返回401状态码。
当然,如果参数都传一个HTTPBasicAuth类,就显得有点烦琐了,所以requests提供了一个更简单的写法,可以直接传一个元组,它会默认使用HTTPBasicAuth这个类来认证。
简写为:

r = requests.get(‘http://localhost:5000', auth=(‘username’, ‘password’))

此外,requests还提供了其他认证方式,如OAuth认证,不过此时需要安装oauth包,安装命令如下:

pip3 install requests_oauthlib

使用OAuth认证的方法如下:

1
2
3
4
5
6
7
import requests
from requests_oauthlib import OAuth1

url = 'https://api.twitter.com/1.1/account/verify_credentials.json'
auth = OAuth1('YOUR_APP_KEY', 'YOUR_APP_SECRET',
'USER_OAUTH_TOKEN', 'USER_OAUTH_TOKEN_SECRET')
requests.get(url, auth=auth)

  1. Prepared Request

前面介绍urllib时,我们可以将请求表示为数据结构,其中各个参数都可以通过一个Request对象来表示。这在requests里同样可以做到,这个数据结构就叫Prepared Request。
示例代码:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
from requests import Request, Session

url = 'http://httpbin.org/post'
data = {
'name': 'germey'
}
headers = {
'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_11_4) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/53.0.2785.116 Safari/537.36'
}
s = Session()
req = Request('POST', url, data=data, headers=headers)
prepped = s.prepare_request(req)
r = s.send(prepped)
print(r.text)

运行结果如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
{
"args": {},
"data": "",
"files": {},
"form": {
"name": "germey"
},
"headers": {
"Accept": "*/*",
"Accept-Encoding": "gzip, deflate",
"Connection": "close",
"Content-Length": "11",
"Content-Type": "application/x-www-form-urlencoded",
"Host": "httpbin.org",
"User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_11_4) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/53.0.2785.116 Safari/537.36"
},
"json": null,
"origin": "182.32.203.166",
"url": "http://httpbin.org/post"
}

这里引入了Request,然后用url、data和headers参数构造了一个Request对象,这时需要再调用Session的prepare_request()方法将其转换为一个Prepared Request对象,然后调用send()方法发送即可。
有了Request这个对象,就可以将请求当作独立的对象来看待,这样在进行队列调度时会非常方便。