Python爬虫技术--基础篇--内建模块itertools，contextlib和urllib

1.itertools

Python的内建模块​​itertools​​提供了非常有用的用于操作迭代对象的函数。

首先，我们看看​​itertools​​提供的几个“无限”迭代器：

>>> import itertools
>>> natuals = itertools.count(1)
>>> for n in natuals:
... print(n)
...
1
2
3
...

因为​​count()​​​会创建一个无限的迭代器，所以上述代码会打印出自然数序列，根本停不下来，只能按​​Ctrl+C​​退出。

​​cycle()​​会把传入的一个序列无限重复下去：

>>> import itertools
>>> cs = itertools.cycle('ABC') # 注意字符串也是序列的一种
>>> for c in cs:
... print(c)
...
'A'
'B'
'C'
'A'
'B'
'C'
...

同样停不下来。

​​repeat()​​负责把一个元素无限重复下去，不过如果提供第二个参数就可以限定重复次数：

>>> ns = itertools.repeat('A', 3)
>>> for n in ns:
... print(n)
...
A
A
A

无限序列只有在​​for​​迭代时才会无限地迭代下去，如果只是创建了一个迭代对象，它不会事先把无限个元素生成出来，事实上也不可能在内存中创建无限多个元素。

无限序列虽然可以无限迭代下去，但是通常我们会通过​​takewhile()​​等函数根据条件判断来截取出一个有限的序列：

>>> natuals = itertools.count(1)
>>> ns = itertools.takewhile(lambda x: x <= 10, natuals)
>>> list(ns)
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

​​itertools​​提供的几个迭代器操作函数更加有用：

chain()

​​chain()​​可以把一组迭代对象串联起来，形成一个更大的迭代器：

>>> for c in itertools.chain('ABC', 'XYZ'):
... print(c)
# 迭代效果：'A' 'B' 'C' 'X' 'Y' 'Z'

groupby()

​​groupby()​​把迭代器中相邻的重复元素挑出来放在一起：

>>> for key, group in itertools.groupby('AAABBBCCAAA'):
... print(key, list(group))
...
A ['A', 'A', 'A']
B ['B', 'B', 'B']
C ['C', 'C']
A ['A', 'A', 'A']

实际上挑选规则是通过函数完成的，只要作用于函数的两个元素返回的值相等，这两个元素就被认为是在一组的，而函数返回值作为组的key。如果我们要忽略大小写分组，就可以让元素​​'A'​​​和​​'a'​​都返回相同的key：

>>> for key, group in itertools.groupby('AaaBBbcCAAa', lambda c: c.upper()):
... print(key, list(group))
...
A ['A', 'a', 'a']
B ['B', 'B', 'b']
C ['c', 'C']
A ['A', 'A', 'a']

小结

​​itertools​​​模块提供的全部是处理迭代功能的函数，它们的返回值不是list，而是​​Iterator​​​，只有用​​for​​循环迭代的时候才真正计算。

 

 

2.contextlib

在Python中，读写文件这样的资源要特别注意，必须在使用完毕后正确关闭它们。正确关闭文件资源的一个方法是使用​​try...finally​​：

try:
f = open('/path/to/file', 'r')
f.read()
finally:
if f:
f.close()

写​​try...finally​​​非常繁琐。Python的​​with​​语句允许我们非常方便地使用资源，而不必担心资源没有关闭，所以上面的代码可以简化为：

with open('/path/to/file', 'r') as f:
f.read()

并不是只有​​open()​​​函数返回的fp对象才能使用​​with​​​语句。实际上，任何对象，只要正确实现了上下文管理，就可以用于​​with​​语句。

实现上下文管理是通过​​__enter__​​​和​​__exit__​​这两个方法实现的。例如，下面的class实现了这两个方法：

class Query(object):

def __init__(self, name):
self.name = name

def __enter__(self):
print('Begin')
return self

def __exit__(self, exc_type, exc_value, traceback):
if exc_type:
print('Error')
else:
print('End')

def query(self):
print('Query info about %s...' % self.name)

这样我们就可以把自己写的资源对象用于​​with​​语句：

with Query('Bob') as q:
q.query()

@contextmanager

编写​​__enter__​​​和​​__exit__​​​仍然很繁琐，因此Python的标准库​​contextlib​​提供了更简单的写法，上面的代码可以改写如下：

from contextlib import contextmanager

class Query(object):

def __init__(self, name):
self.name = name

def query(self):
print('Query info about %s...' % self.name)

@contextmanager
def create_query(name):
print('Begin')
q = Query(name)
yield q
print('End')

​​@contextmanager​​​这个decorator接受一个generator，用​​yield​​​语句把​​with ... as var​​​把变量输出出去，然后，​​with​​语句就可以正常地工作了：

with create_query('Bob') as q:
q.query()

很多时候，我们希望在某段代码执行前后自动执行特定代码，也可以用​​@contextmanager​​实现。例如：

@contextmanager
def tag(name):
print("<%s>" % name)
yield
print("" % name)

with tag("h1"):
print("hello")
print("world")

上述代码执行结果为：

hello
world

代码的执行顺序是：

​​with​​​语句首先执行​​yield​​​之前的语句，因此打印出​​<h1>​​；

​​yield​​​调用会执行​​with​​​语句内部的所有语句，因此打印出​​hello​​​和​​world​​；

最后执行​​yield​​​之后的语句，打印出​​</h1>​​。

因此，​​@contextmanager​​让我们通过编写generator来简化上下文管理。

@closing

如果一个对象没有实现上下文，我们就不能把它用于​​with​​​语句。这个时候，可以用​​closing()​​​来把该对象变为上下文对象。例如，用​​with​​​语句使用​​urlopen()​​：

from contextlib import closing
from urllib.request import urlopen

with closing(urlopen('https://www.python.org')) as page:
for line in page:
print(line)

​​closing​​也是一个经过@contextmanager装饰的generator，这个generator编写起来其实非常简单：

@contextmanager
def closing(thing):
try:
yield thing
finally:
thing.close()

它的作用就是把任意对象变为上下文对象，并支持​​with​​语句。

​​@contextlib​​还有一些其他decorator，便于我们编写更简洁的代码。

 

3.urllib

urllib提供了一系列用于操作URL的功能。

Get

urllib的​​request​​模块可以非常方便地抓取URL内容，也就是发送一个GET请求到指定的页面，然后返回HTTP的响应：

例如，对豆瓣的一个URL​​https://api.douban.com/v2/book/2129650​​进行抓取，并返回响应：

from urllib import request

with request.urlopen('https://api.douban.com/v2/book/2129650') as f:
data = f.read()
print('Status:', f.status, f.reason)
for k, v in f.getheaders():
print('%s: %s' % (k, v))
print('Data:', data.decode('utf-8'))

可以看到HTTP响应的头和JSON数据：

Status: 200 OK
Server: nginx
Date: Tue, 26 May 2015 10:02:27 GMT
Content-Type: application/json; charset=utf-8
Content-Length: 2049
Connection: close
Expires: Sun, 1 Jan 2006 01:00:00 GMT
Pragma: no-cache
Cache-Control: must-revalidate, no-cache, private
X-DAE-Node: pidl1
Data: {"rating":{"max":10,"numRaters":16,"average":"7.4","min":0},"subtitle":"","author":["廖雪峰编著"],"pubdate":"2007-6",...}

如果我们要想模拟浏览器发送GET请求，就需要使用​​Request​​​对象，通过往​​Request​​对象添加HTTP头，我们就可以把请求伪装成浏览器。例如，模拟iPhone 6去请求豆瓣首页：

from urllib import request

req = request.Request('http://www.douban.com/')
req.add_header('User-Agent', 'Mozilla/6.0 (iPhone; CPU iPhone OS 8_0 like Mac OS X) AppleWebKit/536.26 (KHTML, like Gecko) Version/8.0 Mobile/10A5376e Safari/8536.25')
with request.urlopen(req) as f:
print('Status:', f.status, f.reason)
for k, v in f.getheaders():
print('%s: %s' % (k, v))
print('Data:', f.read().decode('utf-8'))

这样豆瓣会返回适合iPhone的移动版网页：

...



...

Post

如果要以POST发送一个请求，只需要把参数​​data​​以bytes形式传入。

我们模拟一个微博登录，先读取登录的邮箱和口令，然后按照weibo.cn的登录页的格式以​​username=xxx&password=xxx​​的编码传入：

from urllib import request, parse

print('Login to weibo.cn...')
email = input('Email: ')
passwd = input('Password: ')
login_data = parse.urlencode([
('username', email),
('password', passwd),
('entry', 'mweibo'),
('client_id', ''),
('savestate', '1'),
('ec', ''),
('pagerefer', 'https://passport.weibo.cn/signin/welcome?entry=mweibo&r=http%3A%2F%2Fm.weibo.cn%2F')
])

req = request.Request('https://passport.weibo.cn/sso/login')
req.add_header('Origin', 'https://passport.weibo.cn')
req.add_header('User-Agent', 'Mozilla/6.0 (iPhone; CPU iPhone OS 8_0 like Mac OS X) AppleWebKit/536.26 (KHTML, like Gecko) Version/8.0 Mobile/10A5376e Safari/8536.25')
req.add_header('Referer', 'https://passport.weibo.cn/signin/login?entry=mweibo&res=wel&wm=3349&r=http%3A%2F%2Fm.weibo.cn%2F')

with request.urlopen(req, data=login_data.encode('utf-8')) as f:
print('Status:', f.status, f.reason)
for k, v in f.getheaders():
print('%s: %s' % (k, v))
print('Data:', f.read().decode('utf-8'))

如果登录成功，我们获得的响应如下：

Status: 200 OK
Server: nginx/1.2.0
...
Set-Cookie: SSOLoginState=1432620126; path=/; domain=weibo.cn
...
Data: {"retcode":20000000,"msg":"","data":{...,"uid":"1658384301"}}

如果登录失败，我们获得的响应如下：

...
Data: {"retcode":50011015,"msg":"\u7528\u6237\u540d\u6216\u5bc6\u7801\u9519\u8bef","data":{"username":"example@python.org","errline":536}}

Handler

如果还需要更复杂的控制，比如通过一个Proxy去访问网站，我们需要利用​​ProxyHandler​​来处理，示例代码如下：

proxy_handler = urllib.request.ProxyHandler({'http': 'http://www.example.com:3128/'})
proxy_auth_handler = urllib.request.ProxyBasicAuthHandler()
proxy_auth_handler.add_password('realm', 'host', 'username', 'password')
opener = urllib.request.build_opener(proxy_handler, proxy_auth_handler)
with opener.open('http://www.example.com/login.html') as f:
pass

小结

urllib提供的功能就是利用程序去执行各种HTTP请求。如果要模拟浏览器完成特定功能，需要把请求伪装成浏览器。伪装的方法是先监控浏览器发出的请求，再根据浏览器的请求头来伪装，​​User-Agent​​头就是用来标识浏览器的。