Python爬虫入门教程导航，已经完结啦，以后的时间不定期补番。
 
 
 
本系列博客争取把爬虫入门阶段的所有内容都包含住，需要你有较好的 Python 基础知识，当然你完全零基础也可以观看本系列博客。
 
Python 爬虫入门教程，加油！
 
基础篇，包含多线程爬虫
 
1. Python爬虫入门教程 1-100 CentOS环境安装
 
2. Python爬虫入门教程 2-100 和谐图网站爬取
 
3. Python爬虫入门教程 3-100 美空网数据爬取
 
4. Python爬虫入门教程 4-100 美空网未登录图片爬取
 
5. Python爬虫入门教程 5-100 27270图片爬取
 
6. Python爬虫入门教程 6-100 蜂鸟网图片爬取之一
 
7. Python爬虫入门教程 7-100 蜂鸟网图片爬取之二
 
8. 

 
 

 
本文主要分为两个部分：一部分是网络爬虫的概述，帮助大家详细了解网络爬虫；另一部分是HTTP请求的Python实现，帮助大家了解Python中实现HTTP请求的各种方式，以便具备编写HTTP网络程序的能力。
 


 
01 

 
网络爬虫概述
 


 
接下来从网络爬虫的概念、用处与价值和结构等三个方面，让大家对网络爬虫有一个基本的了解。
 
1. 网络爬虫及其应用
 
随着网络的迅速发展，万维网成为大量信息的载体，如何有效地提取并利用这些信息成为一个巨大的挑战，网络爬虫应运而生。网络爬虫（又被称为网页蜘蛛、网络机器人），是一种按照一定的规则，自动地抓取万维网信息的程序或者脚本。下面通过图3-1展示一下网络爬虫在互联网中起到的作用：
 


 

 
▲图3-1 网络爬虫
 


 
网络爬虫按照系统结构和实现技术，大致可以分为以下几种类型：通用网络爬虫、聚焦网络爬虫、增量式网络爬虫、深层网络爬虫。实际的网络爬虫系统通常是几种爬虫技术相结合实现的。
 
搜索引擎（Search Engine），例如传统的通用搜索引擎baidu、Yahoo和Google等，是一种大型复杂的网络爬虫，属于通用性网络爬虫的范畴。但是通用性搜索引擎存在着一定的局限性：
 
不同领域、不同背景的用户往往具有不同的检索目的和需求，通用搜索引擎所返回的结果包含大量用户不关心的网页。
通用搜索引擎的目标是尽可能大的网络覆盖率，有限的搜索引擎服务器资源与无限的网络数据资源之间的矛盾将进一步加深。
万维网数据形式的丰富和网络技术的不断发展，图片、数据库、音频、视频多媒体等不同数据大量出现，通用搜索引擎往往对这些信息含量密集且具有一定结构的数据无能为力，不能很好地发现和获取。
通用搜索引擎大多提供基于关键字的检索，难以支持根据语义信息提出的查询。
 
为了解决上述问题，定向抓取相关网页资源的聚焦爬虫应运而生。
 
聚焦爬虫是一个自动下载网页的程序，它根据既定的抓取目标，有选择地访问万维网上的网页与相关的链接，获取所需要的信息。与通用爬虫不同，聚焦爬虫并不追求大的覆盖，而将目标定为抓取与某一特定主题内容相关的网页，为面向主题的用户查询准备数据资源。
 
说完了聚焦爬虫，接下来再说一下增量式网络爬虫。增量式网络爬虫是指对已下载网页采取增量式更新和只爬行新产生的或者已经发生变化网页的爬虫，它能够在一定程度上保证所爬行的页面是尽可能新的页面。
 
和周期性爬行和刷新页面的网络爬虫相比，增量式爬虫只会在需要的时候爬行新产生或发生更新的页面，并不重新下载没有发生变化的页面，可有效减少数据下载量，及时更新已爬行的网页，减小时间和空间上的耗费，但是增加了爬行算法的复杂度和实现难度。
 
例如：想获取赶集网的招聘信息，以前爬取过的数据没有必要重复爬取，只需要获取更新的招聘数据，这时候就要用到增量式爬虫。
 
最后说一下深层网络爬虫。Web页面按存在方式可以分为表层网页和深层网页。表层网页是指传统搜索引擎可以索引的页面，以超链接可以到达的静态网页为主构成的Web页面。深层网络是那些大部分内容不能通过静态链接获取的、隐藏在搜索表单后的，只有用户提交一些关键词才能获得的Web页面。
 
例如用户登录或者注册才能访问的页面。可以想象这样一个场景：爬取贴吧或者论坛中的数据，必须在用户登录后，有权限的情况下才能获取完整的数据。
 
2. 网络爬虫结构
 
下面用一个通用的网络爬虫结构来说明网络爬虫的基本工作流程，如图3-4所示。
 


 

 
▲图3-4 网络爬虫结构
 
网络爬虫的基本工作流程如下：
 
首先选取一部分精心挑选的种子URL。
将这些URL放入待抓取URL队列。
从待抓取URL队列中读取待抓取队列的URL，解析DNS，并且得到主机的IP，并将URL对应的网页下载下来，存储进已下载网页库中。此外，将这些URL放进已抓取URL队列。
分析已抓取URL队列中的URL，从已下载的网页数据中分析出其他URL，并和已抓取的URL进行比较去重，最后将去重过的URL放入待抓取URL队列，从而进入下一个循环。

 
02
 
 HTTP请求的Python实现
 


 
通过上面的网络爬虫结构，我们可以看到读取URL、下载网页是每一个爬虫必备而且关键的功能，这就需要和HTTP请求打交道。接下来讲解Python中实现HTTP请求的三种方式：urllib2/urllib、httplib/urllib以及Requests。
 
1. urllib2/urllib实现
 
urllib2和urllib是Python中的两个内置模块，要实现HTTP功能，实现方式是以urllib2为主，urllib为辅。
 
1.1 首先实现一个完整的请求与响应模型
 
urllib2提供一个基础函数urlopen，通过向指定的URL发出请求来获取数据。最简单的形式是：
 

 
import urllib2
response=urllib2.urlopen('http://www.zhihu.com')
html=response.read()
print html
 
其实可以将上面对http://www.zhihu.com的请求响应分为两步，一步是请求，一步是响应，形式如下：
 

 
import urllib2
# 请求
request=urllib2.Request('http://www.zhihu.com')
# 响应
response = urllib2.urlopen(request)
html=response.read()
print html
 
上面这两种形式都是GET请求，接下来演示一下POST请求，其实大同小异，只是增加了请求数据，这时候用到了urllib。示例如下：
 

 
import urllib
import urllib2
url = 'http://www.xxxxxx.com/login'
postdata = {'username' : 'qiye',
    'password' : 'qiye_pass'}
# info 需要被编码为urllib2能理解的格式，这里用到的是urllib
data = urllib.urlencode(postdata)
req = urllib2.Request(url, data)
response = urllib2.urlopen(req)
html = response.read()
 
但是有时会出现这种情况：即使POST请求的数据是对的，但是服务器拒绝你的访问。这是为什么呢?问题出在请求中的头信息，服务器会检验请求头，来判断是否是来自浏览器的访问，这也是反爬虫的常用手段。
 
1.2 请求头headers处理
 
将上面的例子改写一下，加上请求头信息，设置一下请求头中的User-Agent域和Referer域信息。
 

 
import urllib
import urllib2
url = 'http://www.xxxxxx.com/login'
user_agent = 'Mozilla/4.0 (compatible; MSIE 5.5; Windows NT)'
referer='http://www.xxxxxx.com/'
postdata = {'username' : 'qiye',
    'password' : 'qiye_pass'}
# 将user_agent,referer写入头信息
headers={'User-Agent':user_agent,'Referer':referer}
data = urllib.urlencode(postdata)
req = urllib2.Request(url, data,headers)
response = urllib2.urlopen(req)
html = response.read()
 
也可以这样写，使用add_header来添加请求头信息，修改如下：
 

 
import urllib
import urllib2
url = 'http://www.xxxxxx.com/login'
user_agent = 'Mozilla/4.0 (compatible; MSIE 5.5; Windows NT)'
referer='http://www.xxxxxx.com/'
postdata = {'username' : 'qiye',
    'password' : 'qiye_pass'}
data = urllib.urlencode(postdata)
req = urllib2.Request(url)
# 将user_agent,referer写入头信息
req.add_header('User-Agent',user_agent)
req.add_header('Referer',referer)
req.add_data(data)
response = urllib2.urlopen(req)
html = response.read()
 
对有些header要特别留意，服务器会针对这些header做检查，例如：
 
User-Agent：有些服务器或Proxy会通过该值来判断是否是浏览器发出的请求。
Content-Type：在使用REST接口时，服务器会检查该值，用来确定HTTP Body中的内容该怎样解析。在使用服务器提供的RESTful或SOAP服务时，Content-Type设置错误会导致服务器拒绝服务。常见的取值有：application/xml（在XML RPC，如RESTful/SOAP调用时使用）、application/json（在JSON RPC调用时使用）、application/x-www-form-urlencoded（浏览器提交Web表单时使用）。
Referer：服务器有时候会检查防盗链。
 
1.3 Cookie处理
 
urllib2对Cookie的处理也是自动的，使用CookieJar函数进行Cookie的管理。如果需要得到某个Cookie项的值，可以这么做：
 

 
import urllib2
import cookielib
cookie = cookielib.CookieJar()
opener = urllib2.build_opener(urllib2.HTTPCookieProcessor(cookie))
response = opener.open('http://www.zhihu.com')
for item in cookie:
    print item.name+':'+item.value
 
但是有时候会遇到这种情况，我们不想让urllib2自动处理，我们想自己添加Cookie的内容，可以通过设置请求头中的Cookie域来做：
 

 
import  urllib2
opener = urllib2.build_opener()
opener.addheaders.append( ( 'Cookie', 'email=' + "xxxxxxx@163.com" ) )
req = urllib2.Request( "http://www.zhihu.com/" )
response = opener.open(req)
print response.headers
retdata = response.read()
 
1.4 Timeout设置超时
 
在Python2.6之前的版本，urllib2的API并没有暴露Timeout的设置，要设置Timeout值，只能更改Socket的全局Timeout值。示例如下：
 

 
import urllib2
import socket
socket.setdefaulttimeout(10) # 10 秒钟后超时
urllib2.socket.setdefaulttimeout(10) # 另一种方式
 
在Python2.6及新的版本中，urlopen函数提供了对Timeout的设置，示例如下：
 

 
import urllib2
request=urllib2.Request('http://www.zhihu.com')
response = urllib2.urlopen(request,timeout=2)
html=response.read()
print html
 
1.5 获取HTTP响应码
 
对于200 OK来说，只要使用urlopen返回的response对象的getcode()方法就可以得到HTTP的返回码。但对其他返回码来说，urlopen会抛出异常。这时候，就要检查异常对象的code属性了，示例如下：
 

 
import urllib2
try:
    response = urllib2.urlopen('http://www.google.com')
    print response
except urllib2.HTTPError as e:
    if hasattr(e, 'code'):
        print 'Error code:',e.code
 
1.6 重定向
 
urllib2默认情况下会针对HTTP 3XX返回码自动进行重定向动作。要检测是否发生了重定向动作，只要检查一下Response的URL和Request的URL是否一致就可以了，示例如下：
 

 
import urllib2
response = urllib2.urlopen('http://www.zhihu.cn')
isRedirected = response.geturl() == 'http://www.zhihu.cn'
 
如果不想自动重定向，可以自定义HTTPRedirectHandler类，示例如下：
 

 
import urllib2
class RedirectHandler(urllib2.HTTPRedirectHandler):
    def http_error_301(self, req, fp, code, msg, headers):
        pass
    def http_error_302(self, req, fp, code, msg, headers):
        result = urllib2.HTTPRedirectHandler.http_error_301(self, req, fp, code, 
        msg, headers)
        result.status = code
        result.newurl = result.geturl()
        return result
opener = urllib2.build_opener(RedirectHandler)
opener.open('http://www.zhihu.cn')
 
1.7 Proxy的设置
 
在做爬虫开发中，必不可少地会用到代理。urllib2默认会使用环境变量http_proxy来设置HTTP Proxy。但是我们一般不采用这种方式，而是使用ProxyHandler在程序中动态设置代理，示例代码如下：
 

 
import urllib2
proxy = urllib2.ProxyHandler({'http': '127.0.0.1:8087'})
opener = urllib2.build_opener([proxy,])
urllib2.install_opener(opener)
response = urllib2.urlopen('http://www.zhihu.com/')
print response.read()
 
这里要注意的一个细节，使用urllib2.install_opener()会设置urllib2的全局opener，之后所有的HTTP访问都会使用这个代理。这样使用会很方便，但不能做更细粒度的控制，比如想在程序中使用两个不同的Proxy设置，这种场景在爬虫中很常见。比较好的做法是不使用install_opener去更改全局的设置，而只是直接调用opener的open方法代替全局的urlopen方法，修改如下：
 

 
import urllib2
proxy = urllib2.ProxyHandler({'http': '127.0.0.1:8087'})
opener = urllib2.build_opener(proxy,)
response = opener.open("http://www.zhihu.com/")
print response.read()
 


 
2. httplib/urllib实现
 
httplib模块是一个底层基础模块，可以看到建立HTTP请求的每一步，但是实现的功能比较少，正常情况下比较少用到。在Python爬虫开发中基本上用不到，所以在此只是进行一下知识普及。下面介绍一下常用的对象和函数：
 


 
创建HTTPConnection对象：
class httplib.HTTPConnection(host[, port[, strict[, timeout[, source_address]]]])。
发送请求：
HTTPConnection.request(method, url[, body[, headers]])。
获得响应：
HTTPConnection.getresponse()。
读取响应信息：
HTTPResponse.read([amt])。
获得指定头信息：
HTTPResponse.getheader(name[, default])。
获得响应头(header, value)元组的列表：
HTTPResponse.getheaders()。
获得底层socket文件描述符：
HTTPResponse.fileno()。
获得头内容：
HTTPResponse.msg。
获得头http版本：
HTTPResponse.version。
获得返回状态码：
HTTPResponse.status。
获得返回说明：
HTTPResponse.reason。
 
接下来演示一下GET请求和POST请求的发送，首先是GET请求的示例，如下所示：
 

 
import httplib
conn =None
try:
    conn = httplib.HTTPConnection("www.zhihu.com")
    conn.request("GET", "/")
    response = conn.getresponse()
    print response.status, response.reason
    print '-' * 40
    headers = response.getheaders()
    for h in headers:
        print h
    print '-' * 40
    print response.msg
except Exception,e:
    print e
finally:
    if conn:
        conn.close()
 
POST请求的示例如下：
 

 
import httplib, urllib
conn = None
try:
    params = urllib.urlencode({'name': 'qiye', 'age': 22})
    headers = {"Content-type": "application/x-www-form-urlencoded"
    , "Accept": "text/plain"}
    conn = httplib.HTTPConnection("www.zhihu.com", 80, timeout=3)
    conn.request("POST", "/login", params, headers)
    response = conn.getresponse()
    print response.getheaders() # 获取头信息
    print response.status
    print response.read()
except Exception, e:
    print e
    finally:
    if conn:
        conn.close()
 
3. 更人性化的Requests

 
Python中Requests实现HTTP请求的方式，是本人极力推荐的，也是在Python爬虫开发中最为常用的方式。Requests实现HTTP请求非常简单，操作更加人性化。
 
Requests库是第三方模块，需要额外进行安装。Requests是一个开源库，源码位于：
 
GitHub: https://github.com/kennethreitz/requests
 
希望大家多多支持作者。
 
使用Requests库需要先进行安装，一般有两种安装方式：
 
使用pip进行安装，安装命令为：pip install requests，不过可能不是最新版。
直接到GitHub上下载Requests的源代码，下载链接为：
https://github.com/kennethreitz/requests/releases
将源代码压缩包进行解压，然后进入解压后的文件夹，运行setup.py文件即可。
 
如何验证Requests模块安装是否成功呢？在Python的shell中输入import requests，如果不报错，则是安装成功。如图3-5所示。
 

 
▲图3-5 验证Requests安装
 
3.1 首先还是实现一个完整的请求与响应模型
 
以GET请求为例，最简单的形式如下：
 

 
import requests
r = requests.get('http://www.baidu.com')
print r.content
 
大家可以看到比urllib2实现方式的代码量少。接下来演示一下POST请求，同样是非常简短，更加具有Python风格。示例如下：
 

 
import requests
postdata={'key':'value'}
r = requests.post('http://www.xxxxxx.com/login',data=postdata)
print r.content
 
HTTP中的其他请求方式也可以用Requests来实现，示例如下：
 

 
r = requests.put('http://www.xxxxxx.com/put', data = {'key':'value'})
r = requests.delete('http://www.xxxxxx.com/delete')
r = requests.head('http://www.xxxxxx.com/get')
r = requests.options('http://www.xxxxxx.com/get')
 
接着讲解一下稍微复杂的方式，大家肯定见过类似这样的URL：
 
http://zzk.cnblogs.com/s/blogpost?Keywords=blog:qiyeboy&pageindex=1
 
就是在网址后面紧跟着“?”，“?”后面还有参数。那么这样的GET请求该如何发送呢？肯定有人会说，直接将完整的URL带入即可，不过Requests还提供了其他方式，示例如下：
 

 
import requests
    payload = {'Keywords': 'blog:qiyeboy','pageindex':1}
r = requests.get('http://zzk.cnblogs.com/s/blogpost', params=payload)
print r.url
 
通过打印结果，我们看到最终的URL变成了：
 
http://zzk.cnblogs.com/s/blogpost?Keywords=blog:qiyeboy&pageindex=1
 
3.2 响应与编码
 
还是从代码入手，示例如下：
 

 
import requests
r = requests.get('http://www.baidu.com')
print 'content-->'+r.content
print 'text-->'+r.text
print 'encoding-->'+r.encoding
r.encoding='utf-8'
print 'new text-->'+r.text
 
其中r.content返回的是字节形式，r.text返回的是文本形式，r.encoding返回的是根据HTTP头猜测的网页编码格式。
 
输出结果中：“text-->”之后的内容在控制台看到的是乱码，“encoding-->”之后的内容是ISO-8859-1（实际上的编码格式是UTF-8），由于Requests猜测编码错误，导致解析文本出现了乱码。Requests提供了解决方案，可以自行设置编码格式，r.encoding='utf-8'设置成UTF-8之后，“new text-->”的内容就不会出现乱码。
 
但是这种手动的方式略显笨拙，下面提供一种更加简便的方式：chardet，这是一个非常优秀的字符串/文件编码检测模块。安装方式如下：
 

 
pip install chardet
 
安装完成后，使用chardet.detect()返回字典，其中confidence是检测精确度，encoding是编码形式。示例如下：
 

 
import requests
r = requests.get('http://www.baidu.com')
print chardet.detect(r.content)
r.encoding = chardet.detect(r.content)['encoding']
print r.text
 
直接将chardet探测到的编码，赋给r.encoding实现解码，r.text输出就不会有乱码了。
 
除了上面那种直接获取全部响应的方式，还有一种流模式，示例如下：
 

 
import requests
r = requests.get('http://www.baidu.com',stream=True)
print r.raw.read(10)
 
设置stream=True标志位，使响应以字节流方式进行读取，r.raw.read函数指定读取的字节数。
 
3.3 请求头headers处理
 
Requests对headers的处理和urllib2非常相似，在Requests的get函数中添加headers参数即可。示例如下：
 

 
import requests
user_agent = 'Mozilla/4.0 (compatible; MSIE 5.5; Windows NT)'
headers={'User-Agent':user_agent}
r = requests.get('http://www.baidu.com',headers=headers)
print r.content
 
3.4 响应码code和响应头headers处理
 
获取响应码是使用Requests中的status_code字段，获取响应头使用Requests中的headers字段。示例如下：
 

 
import requests
r = requests.get('http://www.baidu.com')
if r.status_code == requests.codes.ok:
    print r.status_code# 响应码
    print r.headers# 响应头
    print r.headers.get('content-type')# 推荐使用这种获取方式，获取其中的某个字段
    print r.headers['content-type']# 不推荐使用这种获取方式
else:
    r.raise_for_status()
 
上述程序中，r.headers包含所有的响应头信息，可以通过get函数获取其中的某一个字段，也可以通过字典引用的方式获取字典值，但是不推荐，因为如果字段中没有这个字段，第二种方式会抛出异常，第一种方式会返回None。
 
r.raise_for_status()是用来主动地产生一个异常，当响应码是4XX或5XX时，raise_for_status()函数会抛出异常，而响应码为200时，raise_for_status()函数返回None。
 
3.5 Cookie处理
 
如果响应中包含Cookie的值，可以如下方式获取Cookie字段的值，示例如下：
 

 
import requests
user_agent = 'Mozilla/4.0 (compatible; MSIE 5.5; Windows NT)'
headers={'User-Agent':user_agent}
r = requests.get('http://www.baidu.com',headers=headers)
# 遍历出所有的cookie字段的值
for cookie in r.cookies.keys():
    print cookie+':'+r.cookies.get(cookie)
 
如果想自定义Cookie值发送出去，可以使用以下方式，示例如下：
 

 
import requests
user_agent = 'Mozilla/4.0 (compatible; MSIE 5.5; Windows NT)'
headers={'User-Agent':user_agent}
cookies = dict(name='qiye',age='10')
r = requests.get('http://www.baidu.com',headers=headers,cookies=cookies)
print r.text
 
还有一种更加高级，且能自动处理Cookie的方式，有时候我们不需要关心Cookie值是多少，只是希望每次访问的时候，程序自动把Cookie的值带上，像浏览器一样。Requests提供了一个session的概念，在连续访问网页，处理登录跳转时特别方便，不需要关注具体细节。使用方法示例如下：
 

 
import Requests
oginUrl = 'http://www.xxxxxxx.com/login'
s = requests.Session()
#首先访问登录界面，作为游客，服务器会先分配一个cookie
r = s.get(loginUrl,allow_redirects=True)
datas={'name':'qiye','passwd':'qiye'}
#向登录链接发送post请求，验证成功，游客权限转为会员权限
r = s.post(loginUrl, data=datas,allow_redirects= True)
print r.text
 
上面的这段程序，其实是正式做Python开发中遇到的问题，如果没有第一步访问登录的页面，而是直接向登录链接发送Post请求，系统会把你当做非法用户，因为访问登录界面时会分配一个Cookie，需要将这个Cookie在发送Post请求时带上，这种使用Session函数处理Cookie的方式之后会很常用。
 
3.6 重定向与历史信息
 
处理重定向只是需要设置一下allow_redirects字段即可，例如：
 
r=requests.get('http://www.baidu.com',allow_redirects=True)
 
将allow_redirects设置为True，则是允许重定向；设置为False，则是禁止重定向。如果是允许重定向，可以通过r.history字段查看历史信息，即访问成功之前的所有请求跳转信息。示例如下：
 

 
import requests
r = requests.get('http://github.com')
print r.url
print r.status_code
print r.history
 
打印结果如下：
 

 
https://github.com/
200
(<Response [301]>,)
 
上面的示例代码显示的效果是访问GitHub网址时，会将所有的HTTP请求全部重定向为HTTPS。
 
3.7 超时设置
 
超时选项是通过参数timeout来进行设置的，示例如下：
 

 
requests.get('http://github.com', timeout=2)
 
3.8 代理设置
 
使用代理Proxy，你可以为任意请求方法通过设置proxies参数来配置单个请求：
 

 
import requests
proxies = {
    "http": "http://0.10.1.10:3128",
    "https": "http://10.10.1.10:1080",
}
requests.get("http://example.org", proxies=proxies)
 
也可以通过环境变量HTTP_PROXY和HTTPS_PROXY?来配置代理，但是在爬虫开发中不常用。你的代理需要使用HTTP Basic Auth，可以使用http://user:password@host/语法：
 

 
proxies = {
    "http": "http://user:pass@10.10.1.10:3128/",
}
 


 
03 

 
小结
 


 
本文主要讲解了网络爬虫的结构和应用，以及Python实现HTTP请求的几种方法。希望大家对本文中的网络爬虫工作流程和Requests实现HTTP请求的方式重点吸收消化。
 
本文摘编自《Python爬虫开发与项目实战》，经出版方授权发布。
 
关于作者：范传辉，资深网虫，Python开发者，参与开发了多项网络应用，在实际开发中积累了丰富的实战经验,并善于总结，贡献了多篇技术文章广受好评。研究兴趣是网络安全、爬虫技术、数据分析、驱动开发等技术。
 

 
《Python爬虫开发与项目实战》
 
扫码购买
 

 


 
本书特色：
 
由浅入深，从Python和Web前端基础开始讲起，逐步加深难度，层层递进。
内容详实，从静态网站到动态网站，从单机爬虫到分布式爬虫，既包含基础知识点，又讲解了关键问题和难点分析，方便读者完成进阶。
实用性强，本书共有9个爬虫项目，以系统的实战项目为驱动，由浅及深地讲解爬虫开发中所需的知识和技能。
难点详析，对js加密的分析、反爬虫措施的突破、去重方案的设计、分布式爬虫的开发进行了细致的讲解。
 
扫码购买
 
 

中国知网爬虫
 
一、知网介绍
 
提起中国知网，如果你曾经写过论文，那么基本上都会与中国知网打交道，因为写一篇论文必然面临着各种查重，当然翟博士除外。但是，本次重点不在于写论文跟查重上，而在于我们要爬取知网上一些论文的数据，什么样的数据呢？我们举一个例子来说，在知网上，搜索论文的方式有很多种，但是对于专业人士来说，一般都会使用高级检索，因为直接去查找作者的话，容易查找到很多重名作者，所以我们本次的爬虫也是使用了高级检索(泛称)的爬虫，再具体就是专业检索，有助于我们唯一定位到作者。
 
 
 
二、常规步骤—页面分析
 
1.来到高级检索页面，以【AU=王长峰 AND FU=71271031】为例检索，结果如下：
 
 
2.利用Xpath语法尝试获取这些数据，却发现一无所获。
 
 
3.按照常理来说，即使是动态网页也可以利用Xpath语法提取到数据，只是在Python里面获取不到而已，所以在这里存在我们所不知道的问题。
 
三、知网反爬虫机制
 
常见的反爬虫机制一般有两种：
 
第一种是请求头反爬虫，这个也是最简单的，如果你不给定请求头，对方服务器就不会理你。需要设置的参数有User-Agent、Referer和Cookie。
 
第二种是动态网页，利用Ajax技术使用js接口来传递数据。
 
毫无疑问，对于数据非常金贵的中国知网来说，肯定使用了以上两种反爬方式，并且中国知网的js接口非常复杂，虽说复杂，但是只要你的内功要是足够强的话，还是能够分析得出来，但是对于不懂js以及web开发的朋友来说，这将是一个非常困难的事情，所以使用selenium来进行爬虫将是一件相对来说比较容易的事情。
 
另外，知网也不是仅仅只有这两层反爬虫机制，还有第三层，那就是iframe，由于很多朋友并没有做过网站开发，所以不太清楚了这是什么东西，导致即使发现自己的Xpath语法正确，也无法正确获取数据，从而怀疑人生，实际上，iframe比较常见的一种反爬虫机制，不过，如果你不知道这个东西，那么你就基本上无缘爬取中国知网了。
 
四、什么是iframe?
 
了解iframe前，你首先得知道一个网页是什么，没错，一个网页就是一个html页面。接下来我们从感性和源码两个方面来认识一下iframe.
 
1.感性认知。
 
一句话：一个完整的网页内部又嵌套了多个完整的网页，嵌套的页面就叫做iframe。
 
 
2.网页源码认识。
 
比如一个非常简单的html页面(如下图所示)，一个html页面是拥有一个完整的html标签的，也就是起始html【<html>】和闭合html【</html>】，而iframe则是在这一个完整的html标签里面又嵌套了一个完整的html标签。
 
<html>
<body>

<p>Python伊甸园</p>

</body>
</html>
 
 
 
3.看一下中国知网的源码，发现果然存在一个iframe,所以这个就是中国知网的第三种反爬虫机制。
 
 
五、最后给出中国知网的爬虫
 
1.ways.py
 
import pandas as pd
#AU=王长峰 AND FU=71271031
def get_data():
    data_list = pd.read_excel(r"C:\Users\wwb\Desktop\科学基金.xls",
                              encoding='utf8')
    leaders = data_list.leader.values.tolist()
    codes = data_list.code.tolist()
    results = []
    for leader,code in zip(leaders,codes):
        result = "AU={} AND FU={}".format(leader,code)
        results.append(result)
    return results

#results = get_data()
#print(results)
 
2.main.py
 
from selenium import webdriver
from lxml import etree
import time
from ways import get_data
import random

def pasre_page(driver):
    html = etree.HTML(driver.page_source)
    trs = html.xpath('//tr[@bgcolor]')
    for tr in trs:
        title = tr.xpath('./td//a[@class="fz14"]/text()')[0]
        authors = tr.xpath('./td[@class="author_flag"]/a[@class="KnowledgeNetLink"]//text()')
        authors = "|".join(authors)
        source = tr.xpath('./td//a[@target="_blank"]/text()')[1]
        times = tr.xpath('./td[@align="center"]/text()')[0].strip()
        database = tr.xpath('./td[@align="center"]/text()')[1].strip()
        counted = tr.xpath('./td//span[@class="KnowledgeNetcont"]/a/text()')
        if len(counted) == 0:
            counted = 0
        else:
            counted = counted[0]
        downloadCount = tr.xpath('./td//span[@class="downloadCount"]/a/text()')
        if len(downloadCount) == 0:
            downloadCount = 0
        else:
            downloadCount = downloadCount[0]
        data = {
                "title":title,
                "authors":authors,
                "source":source,
                "times":times,
                "database":database,
                "counted":counted,
                "downloadCount":downloadCount,
                }
        datas.append(data)
        print(title)
    time.sleep(random.uniform(2,4))
    driver.switch_to.parent_frame()
    search_win = driver.find_element_by_id('expertvalue')
    search_win.clear()
    time.sleep(random.uniform(2,4))
    

driver_path = r"C:\Users\wwb\Desktop\chromedriver.exe"
driver = webdriver.Chrome(executable_path=driver_path)
url = "https://www.cnki.net/"
driver.get(url)

home_page = driver.find_element_by_id('highSearch')
home_page.click()
driver.switch_to_window(driver.window_handles[1])
search_page = driver.find_element_by_id('1_3')
search_page.click()
datas = []
results = get_data()
for result in results:
    search_win = driver.find_element_by_id('expertvalue')
    search_win.send_keys(result)
    search_btn = driver.find_element_by_id('btnSearch')
    search_btn.click()
    iframe = driver.find_element_by_id('iframeResult')
    driver.switch_to.frame(iframe) 
    time.sleep(random.uniform(2,4))
    pasre_page(driver)
 
3.部分结果展示：
 
 

扫描二维码即可参与该课程，解锁更多爬虫知识：
 
 
 
 
 
 
 

这是我前几天看到的一个真实事件，也是我写这篇文章的缘由：
 
前几天有粉丝跟我反馈说，某机构的人跟他说学爬虫1个月就能接单，让这小伙子去报名那个机构的爬虫课程，学完之后1个月就能把6000多的学费赚回来。可能是因为我和粉丝的交流比较多，所以小伙子找到了我，问我这个事情的真伪，我不禁咋舌…
 
学1个月爬虫就能去接单赚6000多块钱？现在的会爬虫的人数不胜数，新手学1个月就能达到月赚6000的水平了？
 
 
秉着客观的态度，就算不信我也没有去下结论，而是去看了一下他们的课程体系，结果不出我所料，课程大部分都在讲Python入门知识（函数等）、requests和XPath等内容，这不都是一些初级爬虫的知识吗？能月赚6000？怎么不教年轻人去街上抢钱呢？
 
赚外快的事情我也干了很多年，爬虫自然不在话下，那么今天我来说说5个深入一点的爬虫问题，让你清楚爬虫的真实情况：
 
 
 
1.现在的爬虫接单真能1个月赚6000的快外？
 
 
 
 
2.初级爬虫只能接一些小单，怎样才算初级爬虫水平？
 
 
 
 
3.中级爬虫是职业爬虫工程师上岗水平，需要具备什么？
 
 
 
 
4.高级爬虫可以说是爬虫大神，需要掌握哪些技术？
 
 
 
 
5.爬虫更高水平要学什么？巅峰爬虫是什么样子？
 
 
 
一、爬虫能否一个月赚6000的外快？
 
答案肯定是能的，但这取决于你的爬虫技术水平。
 
如果你只是一个初级爬虫你只能靠运气接单，你拿得出手的一些爬虫作品可能入不了大单金主的法眼，有时候接个技术难度高一点的，整出来效果都需要花费好几天，大多数初级爬虫的人接单都不会超过200块钱，大多数都是几十块钱的单子，月挣6000需要接多少单？我就算你一单的价格平均在100块钱，那你也是需要60单！
 
做过兼职的人都知道，1个月60单私活几乎是不可能的，除非你有特殊的渠道。
 
再者，抛开初级爬虫连产品经理都会之外，现在还有那么多第三方网站提供较强大的爬虫功能，不会爬虫的人花点小钱也能解决，比如某爪鱼、某裔采集器，不管是时间还是成本上都比找花钱请一个爬虫新手强。
 
新手学1个月爬虫就能月入6000块钱的事情，我敢打包票这只是为了促成你报班，这种手段在良莠不齐的互联网教育行业屡见不鲜，我直接给出我的结论：不值这个钱、学完你也做不到1月能靠爬虫赚6000，这水平就是给你1年也赚不了几个钱。
 
 
但如果你的技术达到了中级爬虫或更高的水平，那就是靠实力和运气来挣钱了。从技术层面上来讲，接大点的单是没有问题的，一单的价格也是在300~几千不等，如果是均价600元一单来算，一个月做个四五单赚几千块钱是没问题的，拼一点或者技术好一点的可能赚得更多，前提是你得有这个技术，打脸充胖子是会翻船的。
 
挣6000块钱是有可能的，几千块钱的单子以前我也做过。
 
 
至于去哪接单已是老生常谈了，这里我就不多说了，自己去百度吧，百度什么都有，我们继续下面的话题，来看看爬虫的初级、中级、高级和巅峰水平是什么样子！
 
 
二、初级爬虫
 
根据我这些年来对爬虫的了解，初级爬虫的水平大概是这个样子的：
 

 （最近盗图盗文的人比较，图片为了防止无良的CV大法就加了水印，需要源文件的可以私聊我。）
 
这个水平能干什么？就是爬虫一些基本的网站，涉及一点反爬就GG。
 
比如说我们去爬1个某个网站的文章，这个网站没有带反爬机制，那么用 requests 等库就够了，用 XPath、BeautifulSoup、PyQuery 或者正则表达式解析一下网页的源码，再加个文本写入存下来就完事了。
 
其中的难度并不大，无非是几个方法调用和循环加储存，如果存储方面稍微扩展一下的话，可以对接上 MySQL、MongoDB、Elasticsearch、Kafka 等等来保存数据，实现持久化存储。以后查询或者操作会更方便。
 
这就是初级爬虫的水平，能爬，但距离“可见即可爬”还道长路远，接单可想而知也会较吃力，虽然它很基础，但这又是你学爬虫的必经之路。
 
那么我们回顾一下前面那个小伙子的事情，上面这些东西对于新手来说1个月能学完吗？我觉得难度不小，我不说别的，就说Python入门这一块，就包含了不少的东西。
 
 
 
1天4个小时学习，没有基础的话，在Python入门这一块你可能就要花2周时间才能学完且稳固，剩下的两周，你能学完并掌握初级爬虫剩下的知识吗？
 
技术这条道路上很忌讳急功近利。我知道你可以从头到晚看完并理解一本书就只需要几天时间，但看完了你能用起来吗？看是看完了，但看了什么记不起来了，你需要反复练习，同样的，你1个月是能跟着学完没有问题，但你能不能站得稳还是个问题。
 
更何况，有些机构的课程都是挑肥拣瘦。
 
 
三、中级爬虫
 
中级爬虫的水平可以算是职业爬虫师的基本水平，除了初级爬虫的知识点之外，还应该掌握以下一些知识点：
 
 
1.爬取方式
 
当你的requests 不顶用的时候（爬下来的和网页显示的不一样），你就应该想到数据来源可能是 Ajax，你去分析网站的时候就得懂JavaScript ；如果想绕过分析 Ajax 和一些 JavaScript 逻辑的过程来爬取数据，我们就得用 Puppeteer、Pyppeteer、Selenium、Splash 等来模拟浏览器的方式来爬取。
 
2.爬取速度
 
除了爬取方式，还有爬取速度，这时候你就得有多进程、多线程、协程的知识储备了。
 
3.爬APP
 
如果你只会网页爬虫，那你还算不上中级爬虫的水平，你还得会爬APP，APP也占据着半壁江山。
 
这个时候你就得会Charles、Fiddler抓包了，抓到之后拿来模拟就行；如果接口被加密了，可以用 mitmproxy 直接监听接口数据或者走 Hook，比如上 Xposed 也可以拿到。
 
爬APP时还有一点比较重要，就是自动化爬取。如果是自己手动戳来实现爬虫的话，给再多钱也没用，这就不是个人干的活…比较好的解决方案就是adb工具和Appium ，你说该不该学？
 
 
 
 
粉丝福利，点击可查看
 
 
 
四、高级爬虫
 
高级爬虫师不管是在职场还是兼职方面，都有着很大的优势，高级爬虫水平应该掌握以下几个方面的技术：
 
 
1.企业级爬虫
 
但凡是接触过大规模的爬虫的人都会有所体会到，多线程、多进程和协程虽然能够加快爬取速度，但说白了还是个单机的爬虫，比起更高级的分布式爬虫要逊色很多，分布式爬虫才算得上企业级爬虫。
 
分布式爬虫的重心就在于资源共享，那么我们很有必要去掌握的东西就是RabbitMQ、Celery、Kafka，用来这些基础的队列或者组件来实现分布式；其次就是我们大名鼎鼎的Scrapy爬虫框架，也是目前用的最多的爬虫框架，对于Scrapy的Redis、Redis-BloomFilter、Cluster 的理解和掌握是必不可少的。
 
掌握这些东西之后，你的爬虫才能达到企业级的高效率爬虫。
 
 
2.应对反爬的技术
 
高级爬虫水平应该考虑的另一个重心就是反爬。
 
网页反爬机制的常见操作就是验证码，什么滑块验证啊、实物勾选啊、加减法啊等等的，招式层出不穷，这个时候你就得知道如何去应付这些常见的验证码了。
 
还有反爬中常见的IP检测，搞不好就会封你的号，所以应对手法也是必须得有的，不管你是用免费代理还是付费代理来换代理IP，都是可以的。
 
以及应对反爬时的分流技术避免账号被封，分流技术就得建池子，Cookies 池、Token 池、Sign 池，都可以，有了池子之后，你被封的概率也会降低，你也不想爬个公众号结果WX被封了吧？
 
 
 
五、更高水平的爬虫（爬虫的巅峰）
 
更高水平的爬虫，以下4点是必会的内容：
 
 
1.JS逆向
 
为什么要学JS逆向爬取？ 在反爬和反反爬的对抗中，用Selenium 等方式来爬也是可以，但效率还是低了，毕竟它模拟的是网页渲染的整个过程，而真实的数据可能仅仅就藏在一个小接口里，所以JS逆向则是更高级别的爬取技术，尤其是在大型网站的数据爬取，例如某多多和某宝，如果你能用JS逆向去爬下来，无疑是技术高超的证明之一，但JS逆向也不是谁都能修炼成的，确实烧头发。
 
APP的逆向就更不用说，网页可以逆向，APP也能逆向，那你配得上“牛逼”二字。
 
2.智能化爬虫
 
何为智能化爬虫？ 举个例子，一般情况下，写一个爬取小说网站的爬虫，要根据不同的网站编写不同的提取规则，才能提取出想要的内容。而如果使用智能化解析的话，不论是哪个网站，你只需要把网页的url传递给它，就可以通过算法智能识别出标题、内容、更新时间等信息，而不需要重复编写提取规则。
 
智能化爬虫简而言之就是爬虫与机器学习技术相结合，使得爬虫更加智能化，不然的话，要爬1万个网站，难道我们要写1万个爬虫脚本？
 
 
3.爬虫与运维
 
爬虫什么时候与运维搭上关系了?它们俩一直都有着密不可分的关系，只是你的爬虫需求或者水平没有达到，所以不会考虑到它们。
 
爬虫与运维的关系主要体现在部署和分发、数据的存储和监控这几个方面。
 
比如说如何把1个爬虫快速部署到100台主机运行起来?比如怎样监控一些爬虫的占用内存和 CPU 状况?比如爬虫如何设置报警机制来保证爬虫项目的安全？
 
Kubernetes 、Prometheus 、Grafana是爬虫在运维方面用的比较多的技术，在做大点的爬虫项目时我也是经常拿它们来保驾护航。
 
4.爬虫的巅峰
 
什么是巅峰？可能永远都没有巅峰…只要一天没有拥有强者的发型（全秃），我就不敢说我看到了巅峰…
 
我隐约感到，爬虫做到了极致，既能干全栈，又能做数据分析，说不好还是算法大师，没准在人工智能还能有所建树，这难到就是爬虫的巅峰吗？
 
今日的分享就到这里，愿你我都能成为金字塔顶端的男人！