爬虫 订阅
网络爬虫(又称为网页蜘蛛,网络机器人,在FOAF社区中间,更经常的称为网页追逐者),是一种按照一定的规则,自动地抓取万维网信息的程序或者脚本。另外一些不常使用的名字还有蚂蚁、自动索引、模拟程序或者蠕虫。 展开全文
网络爬虫(又称为网页蜘蛛,网络机器人,在FOAF社区中间,更经常的称为网页追逐者),是一种按照一定的规则,自动地抓取万维网信息的程序或者脚本。另外一些不常使用的名字还有蚂蚁、自动索引、模拟程序或者蠕虫。
信息
外文名
web crawler
别    称
网络蜘蛛、蠕虫
作    用
抓取网站上的信息
中文名
网络爬虫
目    的
按要求获取万维网信息
算    法
网络拓扑、基于网页内容和基于用户访问行为三种算法
网络爬虫产生背景
随着网络的迅速发展,万维网成为大量信息的载体,如何有效地提取并利用这些信息成为一个巨大的挑战。搜索引擎(Search Engine),例如传统的通用搜索引擎AltaVista,Yahoo!和Google等,作为一个辅助人们检索信息的工具成为用户访问万维网的入口和指南。但是,这些通用性搜索引擎也存在着一定的局限性,如:(1)不同领域、不同背景的用户往往具有不同的检索目的和需求,通过搜索引擎所返回的结果包含大量用户不关心的网页。(2)通用搜索引擎的目标是尽可能大的网络覆盖率,有限的搜索引擎服务器资源与无限的网络数据资源之间的矛盾将进一步加深。(3)万维网数据形式的丰富和网络技术的不断发展,图片、数据库、音频、视频多媒体等不同数据大量出现,通用搜索引擎往往对这些信息含量密集且具有一定结构的数据无能为力,不能很好地发现和获取。(4)通用搜索引擎大多提供基于关键字的检索,难以支持根据语义信息提出的查询。 为了解决上述问题,定向抓取相关网页资源的聚焦爬虫应运而生。聚焦爬虫是一个自动下载网页的程序,它根据既定的抓取目标,有选择的访问万维网上的网页与相关的链接,获取所需要的信息。与通用爬虫(general purpose web crawler)不同,聚焦爬虫并不追求大的覆盖,而将目标定为抓取与某一特定主题内容相关的网页,为面向主题的用户查询准备数据资源。1 聚焦爬虫工作原理以及关键技术概述网络爬虫是一个自动提取网页的程序,它为搜索引擎从万维网上下载网页,是搜索引擎的重要组成。传统爬虫从一个或若干初始网页的URL开始,获得初始网页上的URL,在抓取网页的过程中,不断从当前页面上抽取新的URL放入队列,直到满足系统的一定停止条件。聚焦爬虫的工作流程较为复杂,需要根据一定的网页分析算法过滤与主题无关的链接,保留有用的链接并将其放入等待抓取的URL队列。然后,它将根据一定的搜索策略从队列中选择下一步要抓取的网页URL,并重复上述过程,直到达到系统的某一条件时停止。另外,所有被爬虫抓取的网页将会被系统存贮,进行一定的分析、过滤,并建立索引,以便之后的查询和检索;对于聚焦爬虫来说,这一过程所得到的分析结果还可能对以后的抓取过程给出反馈和指导。 相对于通用网络爬虫,聚焦爬虫还需要解决三个主要问题:(1) 对抓取目标的描述或定义;(2) 对网页或数据的分析与过滤;(3) 对URL的搜索策略。
收起全文
精华内容
参与话题
问答
  • 手把手教你利用爬虫爬网页(Python代码)

    万次阅读 多人点赞 2019-05-14 14:34:48
    本文主要分为两个部分:一部分是网络爬虫的概述,帮助大家详细了解网络爬虫;另一部分是HTTP请求的Python实现,帮助大家了解Python中实现HTTP请求的各种方式,以...
        

    640?wx_fmt=jpeg

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


    01

    网络爬虫概述


    接下来从网络爬虫的概念、用处与价值和结构等三个方面,让大家对网络爬虫有一个基本的了解。

    1. 网络爬虫及其应用

    随着网络的迅速发展,万维网成为大量信息的载体,如何有效地提取并利用这些信息成为一个巨大的挑战,网络爬虫应运而生。网络爬虫(又被称为网页蜘蛛、网络机器人),是一种按照一定的规则,自动地抓取万维网信息的程序或者脚本。下面通过图3-1展示一下网络爬虫在互联网中起到的作用:


    640?wx_fmt=png

    ▲图3-1 网络爬虫


    网络爬虫按照系统结构和实现技术,大致可以分为以下几种类型:通用网络爬虫、聚焦网络爬虫、增量式网络爬虫、深层网络爬虫。实际的网络爬虫系统通常是几种爬虫技术相结合实现的。

    搜索引擎(Search Engine),例如传统的通用搜索引擎baidu、Yahoo和Google等,是一种大型复杂的网络爬虫,属于通用性网络爬虫的范畴。但是通用性搜索引擎存在着一定的局限性:

    1. 不同领域、不同背景的用户往往具有不同的检索目的和需求,通用搜索引擎所返回的结果包含大量用户不关心的网页。

    2. 通用搜索引擎的目标是尽可能大的网络覆盖率,有限的搜索引擎服务器资源与无限的网络数据资源之间的矛盾将进一步加深。

    3. 万维网数据形式的丰富和网络技术的不断发展,图片、数据库、音频、视频多媒体等不同数据大量出现,通用搜索引擎往往对这些信息含量密集且具有一定结构的数据无能为力,不能很好地发现和获取。

    4. 通用搜索引擎大多提供基于关键字的检索,难以支持根据语义信息提出的查询。

    为了解决上述问题,定向抓取相关网页资源的聚焦爬虫应运而生。

    聚焦爬虫是一个自动下载网页的程序,它根据既定的抓取目标,有选择地访问万维网上的网页与相关的链接,获取所需要的信息。与通用爬虫不同,聚焦爬虫并不追求大的覆盖,而将目标定为抓取与某一特定主题内容相关的网页,为面向主题的用户查询准备数据资源。

    说完了聚焦爬虫,接下来再说一下增量式网络爬虫。增量式网络爬虫是指对已下载网页采取增量式更新和只爬行新产生的或者已经发生变化网页的爬虫,它能够在一定程度上保证所爬行的页面是尽可能新的页面。

    和周期性爬行和刷新页面的网络爬虫相比,增量式爬虫只会在需要的时候爬行新产生或发生更新的页面,并不重新下载没有发生变化的页面,可有效减少数据下载量,及时更新已爬行的网页,减小时间和空间上的耗费,但是增加了爬行算法的复杂度和实现难度。

    例如:想获取赶集网的招聘信息,以前爬取过的数据没有必要重复爬取,只需要获取更新的招聘数据,这时候就要用到增量式爬虫。

    最后说一下深层网络爬虫。Web页面按存在方式可以分为表层网页和深层网页。表层网页是指传统搜索引擎可以索引的页面,以超链接可以到达的静态网页为主构成的Web页面。深层网络是那些大部分内容不能通过静态链接获取的、隐藏在搜索表单后的,只有用户提交一些关键词才能获得的Web页面。

    例如用户登录或者注册才能访问的页面。可以想象这样一个场景:爬取贴吧或者论坛中的数据,必须在用户登录后,有权限的情况下才能获取完整的数据。

    2. 网络爬虫结构

    下面用一个通用的网络爬虫结构来说明网络爬虫的基本工作流程,如图3-4所示。


    640?wx_fmt=png

    ▲图3-4 网络爬虫结构

    网络爬虫的基本工作流程如下:

    1. 首先选取一部分精心挑选的种子URL。

    2. 将这些URL放入待抓取URL队列。

    3. 从待抓取URL队列中读取待抓取队列的URL,解析DNS,并且得到主机的IP,并将URL对应的网页下载下来,存储进已下载网页库中。此外,将这些URL放进已抓取URL队列。

    4. 分析已抓取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所示。

    640?wx_fmt=png

    ▲图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开发者,参与开发了多项网络应用,在实际开发中积累了丰富的实战经验,并善于总结,贡献了多篇技术文章广受好评。研究兴趣是网络安全、爬虫技术、数据分析、驱动开发等技术。

    640?wx_fmt=jpeg

    Python爬虫开发与项目实战

    扫码购买

    640?wx_fmt=png


    本书特色:

    • 由浅入深,从Python和Web前端基础开始讲起,逐步加深难度,层层递进。

    • 内容详实,从静态网站到动态网站,从单机爬虫到分布式爬虫,既包含基础知识点,又讲解了关键问题和难点分析,方便读者完成进阶。

    • 实用性强,本书共有9个爬虫项目,以系统的实战项目为驱动,由浅及深地讲解爬虫开发中所需的知识和技能。

    • 难点详析,对js加密的分析、反爬虫措施的突破、去重方案的设计、分布式爬虫的开发进行了细致的讲解。

    扫码购买

    640?wx_fmt=png

    展开全文
  • Python爬虫入门项目

    万次阅读 多人点赞 2017-12-25 16:26:21
    Python是什么 Python是著名的“龟叔”Guido van Rossum在1989年圣诞节期间,为了打发无聊的圣诞节而编写的一个编程语言。 创始人Guido van Rossum是BBC出品英剧Monty Python’s Flying Circus(中文:蒙提·派森的...

    Python是什么

    Python是著名的“龟叔”Guido van Rossum在1989年圣诞节期间,为了打发无聊的圣诞节而编写的一个编程语言。

    创始人Guido van Rossum是BBC出品英剧Monty Python’s Flying Circus(中文:蒙提·派森的飞行马戏团)的狂热粉丝,因而将自己创造的这门编程语言命名为Python。

    人生苦短,我用python,翻译自"Life is short, you need Python"

    Python英式发音:/ˈpaɪθən/ ,中文类似‘拍森’。而美式发音:/ˈpaɪθɑːn/,中文类似‘拍赏’。我看麻省理工授课教授读的是‘拍赏’,我觉得国内大多是读‘拍森’吧。

    2017年python排第一也无可争议,比较AI第一语言,在当下人工智能大数据大火的情况下,python无愧第一语言的称号,至于C、C++、java都是万年的老大哥了,在代码量比较方面,小编相信java肯定是完爆其它语言的。

    不过从这一年的编程语言流行趋势看,java依然是传播最多的,比较无论app、web、云计算都离不开,而其相对python而言,学习路径更困难一点,想要转行编程,而且追赶潮流,python已然是最佳语言。

    许多大型网站就是用Python开发的,国内:豆瓣、搜狐、金山、腾讯、盛大、网易、百度、阿里、淘宝、热酷、土豆、新浪、果壳…; 国外:谷歌、NASA、YouTube、Facebook、工业光魔、红帽…

    Python将被纳入高考内容

    浙江省信息技术课程改革方案已经出台,Python确定进入浙江省信息技术高考,从2018年起浙江省信息技术教材编程语言将会从vb更换为Python。其实不止浙江,教育大省北京和山东也确定要把Python编程基础纳入信息技术课程和高考的内容体系,Python语言课程化也将成为孩子学习的一种趋势。尤其山东省最新出版的小学信息技术六年级教材也加入了Python内容,小学生都开始接触Python语言了!!

    再不学习,又要被小学生完爆了。。。

     

    Python入门教程

    Python能做什么

    • 网络爬虫
    • Web应用开发
    • 系统网络运维
    • 科学与数字计算
    • 图形界面开发
    • 网络编程
    • 自然语言处理(NLP)
    • 人工智能
    • 区块链
    • 多不胜举。。。

    Python入门爬虫

    这是我的第一个python项目,在这里与大家分享出来~

    • 需求
      • 我们目前正在开发一款产品其功能大致是:用户收到短信如:购买了电影票或者火车票机票之类的事件。然后app读取短信,解析短信,获取时间地点,然后后台自动建立一个备忘录,在事件开始前1小时提醒用户。
    • 设计
      • 开始我们将解析的功能放在了服务端,但是后来考虑到用户隐私问题。后来将解析功能放到了app端,服务端只负责收集数据,然后将新数据发送给app端。
      • 关于服务端主要是分离出两个功能,一、响应app端请求返回数据。二、爬取数据,存入数据库。
      • 响应请求返回数据使用java来做,而爬取数据存入数据库使用python来做,这样分别使用不同语言来做是因为这两种语言各有优势,java效率比python高些,适合做web端,而爬取数据并不是太追求性能且python语言和大量的库适合做爬虫。
    • 代码
      • 本项目使用python3的版本
      • 获取源码:扫描下方关注微信公众号「裸睡的猪」回复:爬虫入门 获取
         

         

      • 了解这个项目你只需要有简单的python基础,能了解python语法就可以。其实我自己也是python没学完,然后就开始写,遇到问题就百度,边做边学这样才不至于很枯燥,因为python可以做一些很有意思的事情,比如模拟连续登录挣积分,比如我最近在写一个预定模范出行车子的python脚本。推荐看廖雪峰的python入门教程
      • 首先带大家看看我的目录结构,开始我打算是定义一个非常好非常全的规范,后来才发现由于自己不熟悉框架,而是刚入门级别,所以就放弃了。从简而入:
      • 下面咱们按照上图中的顺序,从上往下一个一个文件的讲解init.py包的标识文件,python包就是文件夹,当改文件夹下有一个init.py文件后它就成为一个package,我在这个包中引入一些py供其他py调用。

    init.py

    # -*- coding: UTF-8 -*-  
    
    # import need manager module  
    import MongoUtil  
    import FileUtil  
    import conf_dev  
    import conf_test  
    import scratch_airport_name  
    import scratch_flight_number  
    import scratch_movie_name  
    import scratch_train_number  
    import scratch_train_station  
    import MainUtil
    

    下面两个是配置文件,第一个是开发环境的(windows),第二个是测试环境的(linux),然后再根据不同系统启用不同的配置文件

    conf_dev.py

    # -*- coding: UTF-8 -*-  
    # the configuration file of develop environment  
    
    # path configure  
    data_root_path = 'E:/APK98_GNBJ_SMARTSERVER/Proj-gionee-data/smart/data'  
    
    # mongodb configure  
    user = "cmc"  
    pwd = "123456"  
    server = "localhost"  
    port = "27017"  
    db_name = "smartdb"
    

    conf_test.py

    # -*- coding: UTF-8 -*-  
    # the configuration file of test environment  
    
    #path configure  
    data_root_path = '/data/app/smart/data'  
    
    #mongodb configure  
    user = "smart"  
    pwd = "123456"  
    server = "10.8.0.30"  
    port = "27017"  
    db_name = "smartdb"
    

    下面文件是一个util文件,主要是读取原文件的内容,还有将新内容写入原文件。

    FileUtil.py

    # -*- coding: UTF-8 -*-  
    import conf_dev  
    import conf_test  
    import platform  
    
    
    # configure Multi-confronment  
    # 判断当前系统,并引入相对的配置文件
    platform_os = platform.system()  
    config = conf_dev  
    if (platform_os == 'Linux'):  
        config = conf_test  
    # path  
    data_root_path = config.data_root_path  
    
    
    # load old data  
    def read(resources_file_path, encode='utf-8'):  
        file_path = data_root_path + resources_file_path  
        outputs = []  
        for line in open(file_path, encoding=encode):  
            if not line.startswith("//"):  
                outputs.append(line.strip('\n').split(',')[-1])  
        return outputs  
    
    
    # append new data to file from scratch  
    def append(resources_file_path, data, encode='utf-8'):  
        file_path = data_root_path + resources_file_path  
        with open(file_path, 'a', encoding=encode) as f:  
            f.write(data)  
        f.close
    

    下面这个main方法控制着执行流程,其他的执行方法调用这个main方法

    MainUtil.py

    # -*- coding: UTF-8 -*-  
    
    import sys  
    from datetime import datetime  
    import MongoUtil  
    import FileUtil  
    
    # @param resources_file_path 资源文件的path  
    # @param base_url 爬取的连接  
    # @param scratch_func 爬取的方法  
    def main(resources_file_path, base_url, scratch_func):  
        old_data = FileUtil.read(resources_file_path)   #读取原资源  
        new_data = scratch_func(base_url, old_data)     #爬取新资源  
        if new_data:        #如果新数据不为空  
            date_new_data = "//" + datetime.now().strftime('%Y-%m-%d') + "\n" + "\n".join(new_data) + "\n"      #在新数据前面加上当前日期  
            FileUtil.append(resources_file_path, date_new_data)     #将新数据追加到文件中  
            MongoUtil.insert(resources_file_path, date_new_data)    #将新数据插入到mongodb数据库中  
        else:   #如果新数据为空,则打印日志  
            print(datetime.now().strftime('%Y-%m-%d %H:%M:%S'), '----', getattr(scratch_func, '__name__'), ": nothing to update ")
    

    将更新的内容插入mongodb中

    MongoUtil.py

    # -*- coding: UTF-8 -*-  
    
    import platform  
    from pymongo import MongoClient  
    from datetime import datetime, timedelta, timezone  
    import conf_dev  
    import conf_test  
    
    # configure Multi-confronment  
    platform_os = platform.system()  
    config = conf_dev  
    if (platform_os == 'Linux'):  
        config = conf_test  
    # mongodb  
    uri = 'mongodb://' + config.user + ':' + config.pwd + '@' + config.server + ':' + config.port + '/' + config.db_name  
    
    
    # 将数据写入mongodb  
    # @author chenmc  
    # @param uri connect to mongodb  
    # @path save mongodb field  
    # @data save mongodb field  
    # @operation save mongodb field default value 'append'  
    # @date 2017/12/07 16:30  
    # 先在mongodb中插入一条自增数据 db.sequence.insert({ "_id" : "version","seq" : 1})  
    
    def insert(path, data, operation='append'):  
        client = MongoClient(uri)  
        resources = client.smartdb.resources  
        sequence = client.smartdb.sequence  
        seq = sequence.find_one({"_id": "version"})["seq"]      #获取自增id  
        sequence.update_one({"_id": "version"}, {"$inc": {"seq": 1}})       #自增id+1  
        post_data = {"_class": "com.gionee.smart.domain.entity.Resources", "version": seq, "path": path,  
                     "content": data, "status": "enable", "operation": operation,  
                     "createtime": datetime.now(timezone(timedelta(hours=8)))}  
        resources.insert(post_data)     #插入数据
    

    项目引入的第三方库,可使用pip install -r requirements.txt下载第三方库

    requirements.txt

    # need to install module# need to install module  
    bs4  
    pymongo  
    requests  
    json
    

    下面真正的执行方法来了,这五个py分别表示爬取五种信息:机场名、航班号、电影名、列车号、列车站。他们的结构都差不多,如下:

    第一部分:定义查找的url;
    第二部分:获取并与旧数据比较,返回新数据;
    第三部分:main方法,执行写入新数据到文件和mongodb中;
    

    scratch_airport_name.py:爬取全国机场

    # -*- coding: UTF-8 -*-  
    import requests  
    import bs4  
    import json  
    import MainUtil  
    
    resources_file_path = '/resources/airplane/airportNameList.ini'  
    scratch_url_old = 'https://data.variflight.com/profiles/profilesapi/search'  
    scratch_url = 'https://data.variflight.com/analytics/codeapi/initialList'  
    get_city_url = 'https://data.variflight.com/profiles/Airports/%s'  
    
    
    #传入查找网页的url和旧数据,然后本方法会比对原数据中是否有新的条目,如果有则不加入,如果没有则重新加入,最后返回新数据
    def scratch_airport_name(scratch_url, old_airports):  
        new_airports = []  
        data = requests.get(scratch_url).text  
        all_airport_json = json.loads(data)['data']  
        for airport_by_word in all_airport_json.values():  
            for airport in airport_by_word:  
                if airport['fn'] not in old_airports:  
                    get_city_uri = get_city_url % airport['id']  
                    data2 = requests.get(get_city_uri).text  
                    soup = bs4.BeautifulSoup(data2, "html.parser")  
                    city = soup.find('span', text="城市").next_sibling.text  
                    new_airports.append(city + ',' + airport['fn'])  
        return new_airports  
    
     #main方法,执行这个py,默认调用main方法,相当于java的main
    if __name__ == '__main__':  
        MainUtil.main(resources_file_path, scratch_url, scratch_airport_name)
    

    scratch_flight_number.py:爬取全国航班号

    #!/usr/bin/python  
    # -*- coding: UTF-8 -*-  
    
    import requests  
    import bs4  
    import MainUtil  
    
    resources_file_path = '/resources/airplane/flightNameList.ini'  
    scratch_url = 'http://www.variflight.com/sitemap.html?AE71649A58c77='  
    
    
    def scratch_flight_number(scratch_url, old_flights):  
        new_flights = []  
        data = requests.get(scratch_url).text  
        soup = bs4.BeautifulSoup(data, "html.parser")  
        a_flights = soup.find('div', class_='list').find_all('a', recursive=False)  
        for flight in a_flights:  
            if flight.text not in old_flights and flight.text != '国内航段列表':  
                new_flights.append(flight.text)  
        return new_flights  
    
    
    if __name__ == '__main__':  
        MainUtil.main(resources_file_path, scratch_url, scratch_flight_number)
    

    scratch_movie_name.py:爬取最近上映的电影

    #!/usr/bin/python  
    # -*- coding: UTF-8 -*-  
    import re  
    import requests  
    import bs4  
    import json  
    import MainUtil  
    
    # 相对路径,也是需要将此路径存入数据库  
    resources_file_path = '/resources/movie/cinemaNameList.ini'  
    scratch_url = 'http://theater.mtime.com/China_Beijing/'  
    
    
    # scratch data with define url  
    def scratch_latest_movies(scratch_url, old_movies):  
        data = requests.get(scratch_url).text  
        soup = bs4.BeautifulSoup(data, "html.parser")  
        new_movies = []  
        new_movies_json = json.loads(  
            soup.find('script', text=re.compile("var hotplaySvList")).text.split("=")[1].replace(";", ""))  
        coming_movies_data = soup.find_all('li', class_='i_wantmovie')  
        # 上映的电影  
        for movie in new_movies_json:  
            move_name = movie['Title']  
            if move_name not in old_movies:  
                new_movies.append(movie['Title'])  
        # 即将上映的电影  
        for coming_movie in coming_movies_data:  
            coming_movie_name = coming_movie.h3.a.text  
            if coming_movie_name not in old_movies and coming_movie_name not in new_movies:  
                new_movies.append(coming_movie_name)  
        return new_movies  
    
    
    if __name__ == '__main__':  
        MainUtil.main(resources_file_path, scratch_url, scratch_latest_movies)
    

    scratch_train_number.py:爬取全国列车号

    #!/usr/bin/python  
    # -*- coding: UTF-8 -*-  
    import requests  
    import bs4  
    import json  
    import MainUtil  
    
    resources_file_path = '/resources/train/trainNameList.ini'  
    scratch_url = 'http://www.59178.com/checi/'  
    
    
    def scratch_train_number(scratch_url, old_trains):  
        new_trains = []  
        resp = requests.get(scratch_url)  
        data = resp.text.encode(resp.encoding).decode('gb2312')  
        soup = bs4.BeautifulSoup(data, "html.parser")  
        a_trains = soup.find('table').find_all('a')  
        for train in a_trains:  
            if train.text not in old_trains and train.text:  
                new_trains.append(train.text)  
        return new_trains  
    
    
    if __name__ == '__main__':  
        MainUtil.main(resources_file_path, scratch_url, scratch_train_number)
    

    scratch_train_station.py:爬取全国列车站

    #!/usr/bin/python  
    # -*- coding: UTF-8 -*-  
    import requests  
    import bs4  
    import random  
    import MainUtil  
    
    resources_file_path = '/resources/train/trainStationNameList.ini'  
    scratch_url = 'http://www.smskb.com/train/'  
    
    
    def scratch_train_station(scratch_url, old_stations):  
        new_stations = []  
        provinces_eng = (  
            "Anhui", "Beijing", "Chongqing", "Fujian", "Gansu", "Guangdong", "Guangxi", "Guizhou", "Hainan", "Hebei",  
            "Heilongjiang", "Henan", "Hubei", "Hunan", "Jiangsu", "Jiangxi", "Jilin", "Liaoning", "Ningxia", "Qinghai",  
            "Shandong", "Shanghai", "Shanxi", "Shanxisheng", "Sichuan", "Tianjin", "Neimenggu", "Xianggang", "Xinjiang",  
            "Xizang",  
            "Yunnan", "Zhejiang")  
        provinces_chi = (  
            "安徽", "北京", "重庆", "福建", "甘肃", "广东", "广西", "贵州", "海南", "河北",  
            "黑龙江", "河南", "湖北", "湖南", "江苏", "江西", "吉林", "辽宁", "宁夏", "青海",  
            "山东", "上海", "陕西", "山西", "四川", "天津", "内蒙古", "香港", "新疆", "西藏",  
            "云南", "浙江")  
        for i in range(0, provinces_eng.__len__(), 1):  
            cur_url = scratch_url + provinces_eng[i] + ".htm"  
            resp = requests.get(cur_url)  
            data = resp.text.encode(resp.encoding).decode('gbk')  
            soup = bs4.BeautifulSoup(data, "html.parser")  
            a_stations = soup.find('left').find('table').find_all('a')  
            for station in a_stations:  
                if station.text not in old_stations:  
                    new_stations.append(provinces_chi[i] + ',' + station.text)  
        return new_stations  
    
    
    if __name__ == '__main__':  
        MainUtil.main(resources_file_path, scratch_url, scratch_train_station)
    

    将项目放到测试服务器(centos7系统)中运行起来,我写了一个crontab,定时调用他们,下面贴出crontab。

    /etc/crontab

    SHELL=/bin/bash  
    PATH=/sbin:/bin:/usr/sbin:/usr/bin  
    MAILTO=root  
    
    # For details see man 4 crontabs  
    
    # Example of job definition:  
    # .---------------- minute (0 - 59)  
    # |  .------------- hour (0 - 23)  
    # |  |  .---------- day of month (1 - 31)  
    # |  |  |  .------- month (1 - 12) OR jan,feb,mar,apr ...  
    # |  |  |  |  .---- day of week (0 - 6) (Sunday=0 or 7) OR sun,mon,tue,wed,thu,fri,sat  
    # |  |  |  |  |  
    # *  *  *  *  * user-name  command to be executed  
      0  0  *  *  * root python3 /data/app/smart/py/scratch_movie_name.py    >> /data/logs/smartpy/out.log 2>&1  
      0  1  *  *  1 root python3 /data/app/smart/py/scratch_train_station.py >> /data/logs/smartpy/out.log 2>&1  
      0  2  *  *  2 root python3 /data/app/smart/py/scratch_train_number.py  >> /data/logs/smartpy/out.log 2>&1  
      0  3  *  *  4 root python3 /data/app/smart/py/scratch_flight_number.py >> /data/logs/smartpy/out.log 2>&1  
      0  4  *  *  5 root python3 /data/app/smart/py/scratch_airport_name.py  >> /data/logs/smartpy/out.log 2>&1
    

    后续

    目前项目已经正常运行了三个多月啦。。。

    有问题反馈

    在阅读与学习中有任何问题,欢迎反馈给我,可以用以下联系方式跟我交流

    • 微信公众号:裸睡的猪
    • 在下面留言
    • 直接给我私信

    关于此公众号

    • 后期或提供各种软件的免费激活码
    • 推送python,java等编程技术文章和面试技巧
    • 当然你们可以将你们感兴趣的东西直接送给我
    • 谢谢你们真诚的关注,此公众号以后获得的收益将全部通过抽奖的形式送给大家
    • 以后如果博主要创业的话,也会在此公众号中挑选小伙伴哦~
    • 希望大家分享出去,让更多想学习python的朋友看到~

     

     

    展开全文
  • 用Java(Jsoup)实现的爬虫程序,能够获取人民日报的某一天的全部文本新闻信息,然后用JFrame显示出来。
  • 爬虫微课5小时 Python学习路线

    万人学习 2018-07-10 13:28:05
    Python爬虫技术视频教程,该课程每堂课都有一个作业,包含的项目案例有家长帮142600条数据爬取与分析,全球天气数据抓取与分析,淘宝商品信息数据众数分析,12306余票查询,python软件打包exe与发布。学完此课程能让...
  • 从零开始学scrapy网络爬虫

    千人学习 2020-01-22 16:10:17
    《从零开始学Scrapy网络爬虫》从零开始,循序渐进地介绍了目前流行的网络爬虫框架Scrapy。即使你没有任何编程基础,学习起来也不会有压力,因为我们有针对性地介绍了Python编程技术。另外,《从零开始学Scrapy网络...
  • 150讲轻松搞定Python网络爬虫

    万人学习 2019-05-16 15:30:54
    【为什么学爬虫?】        1、爬虫入手容易,但是深入较难,如何写出高效率的爬虫,如何写出灵活性高可扩展的爬虫都是一项技术活。另外在爬虫过程中,经常容易遇到被反爬虫,比如字体...
  • 爬虫基本介绍

    千次阅读 2019-05-16 09:56:00
    爬虫基本介绍 1、什么是爬虫 #1、什么是互联网? 互联网是由网络设备(网线,路由器,交换机,防火墙等等)和一台台计算机连接而成,像一张网一样。 #2、互联网建立的目的? 互联网的核心...

    爬虫基本介绍

    1、什么是爬虫

    #1、什么是互联网?
        互联网是由网络设备(网线,路由器,交换机,防火墙等等)和一台台计算机连接而成,像一张网一样。
    
    #2、互联网建立的目的?
        互联网的核心价值在于数据的共享/传递:数据是存放于一台台计算机上的,而将计算机互联到一起的目的就是为了能够方便彼此之间的数据共享/传递,否则你只能拿U盘去别人的计算机上拷贝数据了。
    
    #3、什么是上网?爬虫要做的是什么?
        我们所谓的上网便是由用户端计算机发送请求给目标计算机,将目标计算机的数据下载到本地的过程。
        #3.1 只不过,用户获取网络数据的方式是:
          浏览器提交请求->下载网页代码->解析/渲染成页面。
    
        #3.2 而爬虫程序要做的就是:
          模拟浏览器发送请求->下载网页代码->只提取有用的数据->存放于数据库或文件中
     
        #3.1与3.2的区别在于:
          我们的爬虫程序只提取网页代码中对我们有用的数据
    
    #4、总结爬虫
        #4.1 爬虫的比喻:
          如果我们把互联网比作一张大的蜘蛛网,那一台计算机上的数据便是蜘蛛网上的一个猎物,而爬虫程序就是一只小蜘蛛,沿着蜘蛛网抓取自己想要的猎物/数据
    
        #4.2 爬虫的定义:
          向网站发起请求,获取资源后分析并提取有用数据的程序 
    
        #4.3 爬虫的价值:
          互联网中最有价值的便是数据,比如天猫商城的商品信息,链家网的租房信息,雪球网的证券投资信息等等,这些数据都代表了各个行业的真金白银,可以说,谁掌握了行业内的第一手数据,谁就成了整个行业的主宰,如果把整个互联网的数据比喻为一座宝藏,那我们的爬虫课程就是来教大家如何来高效地挖掘这些宝藏,掌握了爬虫技能,你就成了所有互联网信息公司幕后的老板,换言之,它们都在免费为你提供有价值的数据。

    二 爬虫的基本流程

    #1、发起请求
    使用http库向目标站点发起请求,即发送一个Request
    Request包含:请求头、请求体等
    
    #2、获取响应内容
    如果服务器能正常响应,则会得到一个Response
    Response包含:html,json,图片,视频等
    
    #3、解析内容
    解析html数据:正则表达式,第三方解析库如Beautifulsoup,pyquery等
    解析json数据:json模块
    解析二进制数据:以b的方式写入文件
    
    #4、保存数据
    数据库

    三 请求与响应

    '''
    URL:
        即统一资源定位符,也就是我们说的网址,统一资源定位符是对可以从互联网上得到的资源的位置和访问方法的一种简洁的表示,是互联网上标准资源的地址。
        互联网上的每个文件都有一个唯一的URL,它包含的信息指出文件的位置以及浏览器应该怎么处理它。
    
    URL的格式由三部分组成:
        ①第一部分是协议(或称为服务方式)。
        ②第二部分是存有该资源的主机IP地址(有时也包括端口号)。
        ③第三部分是主机资源的具体地址,如目录和文件名等
    
    http协议:
        https://www.cnblogs.com/kermitjam/p/10432198.html
    
    robots协议: 
        https://www.cnblogs.com/kermitjam/articles/9692568.html
    
    Request:
        用户将自己的信息通过浏览器(socket client)发送给服务器(socket server)
    
    Response:
        服务器接收请求,分析用户发来的请求信息,然后返回数据(返回的数据中可能包含其他链接,如:图片,js,css等)
    
    ps:
      浏览器在接收Response后,会解析其内容来显示给用户,而爬虫程序在模拟浏览器发送请求然后接收Response后,是要提取其中的有用数据。
    '''

    四 Request

    #1、请求方式:
        常用的请求方式:GET,POST
        其他请求方式:HEAD,PUT,DELETE,OPTHONS
    
        ps:用浏览器演示get与post的区别,(用登录演示post)
    
        post与get请求最终都会拼接成这种形式:k1=xxx&k2=yyy&k3=zzz
        post请求的参数放在请求体内:
            可用浏览器查看,存放于form data内
        get请求的参数直接放在url后
    
    #2、请求url
        url全称统一资源定位符,如一个网页文档,一张图片
        一个视频等都可以用url唯一来确定
    
        url编码
        https://www.baidu.com/s?wd=图片
        图片会被编码(看示例代码)
    
    
        网页的加载过程是:
        加载一个网页,通常都是先加载document文档,
        在解析document文档的时候,遇到链接,则针对超链接发起下载图片的请求
    
    #3、请求头
        User-agent:请求头中如果没有user-agent客户端配置,
        服务端可能将你当做一个非法用户
        host
        cookies:cookie用来保存登录信息
    
        一般做爬虫都会加上请求头
    
    
    #4、请求体
        如果是get方式,请求体没有内容
        如果是post方式,请求体是format data
    
        ps:
        1、登录窗口,文件上传等,信息都会被附加到请求体内
        2、登录,输入错误的用户名密码,然后提交,就可以看到post,正确登录后页面通常会跳转,无法捕捉到post 

     

    Cookie
    
    ```
    Cookie: "......"
    同样是一个比较关键的字段,Cookie是 client 请求 服务器时,服务器会返回一个键值对样的数据给浏览器,下一次浏览器再访问这个域名下的网页时,就需要携带这些键值对数据在 Cookie中,用来跟踪浏览器用户的访问前后路径。 
    在爬虫时,我会根据前次访问得到 cookie数据,然后添加到下一次的访问请求头中。
    ```
    
    - User-Agent
    
    ```
    中文名用户代理,服务器从此处知道客户端的 操作系统类型和版本,电脑CPU类型,浏览器种类版本,浏览器渲染引擎,等等。这是爬虫当中最最重要的一个请求头参数,所以一定要伪造,甚至多个。如果不进行伪造,而直接使用各种爬虫框架中自定义的user-agent,很容易被封禁。举例:
    User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:52.0) Gecko/20100101 Firefox/52.0
    User-Agent: Mozilla/5.0 (Windows NT 6.3; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/52.0.2743.116 Safari/537.36
    网上有很多的用户代理大全,用户代理大全越多越好,用以伪造多个请求头。
    ```
    - Referer
    ```
    浏览器上次访问的网页url,uri。由于http协议的无记忆性,服务器可从这里了解到客户端访问的前后路径,并做一些判断,如果后一次访问的 url 不能从前一次访问的页面上跳转获得,在一定程度上说明了请求头有可能伪造。 
    我在爬虫时,起始入口我会给一个随意的百度搜索地址,然后,在爬取过程中,不断将索引页面的url添加在伪造请求头中。
    Referer: https://www.baidu.com/s?wd=%E7%BE%8E%E5%A5%B3&rsv_spt=1&rsv_iqid=0xce19ceff0002f196&issp=1&f=8&rsv_bp=1&rsv_idx=2&ie=utf-8&rqlang=cn&tn=baiduhome_pg&rsv_enter=1&oq=%25E7%25BE%258E%25E5%25A5%25B3&inputT=4&rsv_t=46216vF7O9LH18hEfGKnjaFukwpJdM3UIwrvEb6LkFIXOIsDt2OQf5Ocfy%2F5LJsCTnkJ&rsv_sug3=9&rsv_sug1=6&rsv_sug7=100&rsv_sug2=0&rsv_pq=e4b29f73000184eb&rsv_sug4=596&rsv_sug=1
    ```
    
    - Accept:
    ```
    Accept:text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8
    
    指定客户端可以接受的内容类型,比如文本,图片,应用等等,内容的先后排序表示客户端接收的先后次序,每种类型之间用逗号隔开。 
    其中,对于每一种内容类型,分号 ; 后面会加一个 q=0.6 这样的 q 值,表示该种类型被客户端喜欢接受的程度,如果没有表示 q=1,数值越高,客户端越喜欢这种类型。 
    爬虫的时候,我一般会伪造若干,将想要找的文字,图片放在前面,其他的放在后面,最后一定加上*/*;q=0.8。
    
    比如Accept: image/gif,image/x-xbitmap,image/jpeg,application/x-shockwave-flash,application/vnd.ms-excel,application/vnd.ms-powerpoint,application/msword,*/*
    
    text/xml,text/shtml:文本类型,斜杠后表示文档的类型,xml,或者shtml
    application/xml,application/xhtml+xml:应用类型,后面表示文档类型,比如 flash动画,excel表格等等
    image/gif,image/x-xbitmap:图片类型,表示接收何种类型的图片
    ```
    
    - Accept-Language
    ```
    客户端可以接受的语言类型,参数值规范和 accept的很像。一般就接收中文和英文,有其他语言需求自行添加。比如:
    
    Accept-Language: zh-CN,zh;q=0.8,en-US;q=0.6,en;q=0.4
    zh-CN:中文简体大陆?
    zh:其他中文
    en-US:英语美语
    en:其他英语
    
    Accept-Language: zh-CN,zh;q=0.9
    ```
    
    - Accept-Encoding: 
    ```
    客户端接收编码类型,一些网络压缩格式。我看了很多常见的请求头,基本上都不变,就是如下:
    
    Accept-Encoding: gzip, deflate, sdch。相对来说,deflate是一种过时的压缩格式,现在常用的是gzip
    ```
    - Cache-Control
    ```
    Cache-Control: no-cache
    指定了服务器和客户端在交互时遵循的缓存机制,即是否要留下缓存页面数据。 
    一般在使用浏览器访问时,都会在计算机本地留下缓存页面,相当于是浏览器中的页面保存和下载选项。但是爬虫就是为了从网络上爬取数据,所以几乎不会从缓存中读取数据。所以在设置的时候要侧重从服务器请求数据而非加载缓存。
    
    no-cache:客户端告诉服务器,自己不要读取缓存,要向服务器发起请求
    no-store:同时也是响应头的参数,请求和响应都禁止缓存,即不存储
    max-age=0:表示当访问过此网页后的多少秒内再次访问,只加载缓存,而不去服务器请求,在爬虫时一般就写0秒
    一般爬虫就使用以上几个参数,其他的参数都是接受缓存的,所以就不列出了。
    
    ```
    
    - Connection
    ```
    Connection: keep-alive
    请求头的 header字段指的是当 client 浏览器和 server 通信时对于长链接如何处理。由于http请求是无记忆性的,长连接指的是在 client 和server 之间建立一个通道,方便两者之间进行多次数据传输,而不用来回传输数据。有 close,keep-alive 等几种赋值,close表示不想建立长连接在操作完成后关闭链接,而keep-alive 表示希望保持畅通来回传输数据。
    
    此外,connection还可以存放一些自定义声明,比如:
    
    Connection: my-header, close
    My-Header: xxx
    其中,my-header指的是当前访问请求中使用的请求头,close表示数据传输完毕后不保持畅通,关闭链接。
    
    在爬虫时我一般都建立一个长链接。
    ```
    
    
    - Host
    ```
    Host:www.baidu.com
    访问的服务器主机名,比如百度的 www.baidu.com。这个值在爬虫时可以从 访问的 URI 中获得
    ```
    
    - Pragma
    ```
    Pragma: no-cache
    和 cache-control类似的一个字段,但是具体什么含义我还没有查清楚,一般爬虫时我都写成 no-cache。
    ```
    
    - Proxy-Connection
    ```
    当使用代理服务器的时候,这个就指明了代理服务器是否使用长链接。但是,数据在从client 到代理服务器,和从代理服务器到被请求的服务器之间如果存在信息差异的话,会造成信息请求不到,但是在大多数情况下,都还是能够成立的。
    ```
    
    - Accept-Charset
    ```
    指的是规定好服务器处理表单数据所接受的字符集,也就是说,客户端浏览器告诉服务器自己的表单数据的字符集类型,用以正确接收。若没有定义,则默认值为“unknown”。如果服务器没有包含此种字符集,就无法正确接收。一般情况下,在爬虫时我不定义该属性,如果定义,例子如下:
    Accept-Charset:gb2312,gbk;q=0.7,utf-8;q=0.7,*;q=0.7
    ```
    
    - Upgrade-Insecure-Requests
    ```
    自动将不安全的访问请求转换成安全的请求 request。赋值数字1表示可以,0就表示不可以。
    ```
    - Range
    ```
    浏览器告诉 WEB 服务器自己想取对象的哪部分。这个在爬虫时我接触比较少,一般都是爬取整个页面,然后再做分析处理。
    ```
    - If-Modified-Since
    ```
    只有当所请求的内容在指定的日期之后又经过修改才返回它,否则返回304。其目的是为了提高访问效率。但是在爬虫时,不设置这个值,而在增量爬取时才设置一个这样的值,用以更新信息。
    ```
    请求头参数

     

    import requests
    from urllib.parse import urlencode
    
    
    headers = {
        'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8',
        'Cookie': 'BIDUPSID=129BFA4FF0032F16FF1851332ADFC9E1; PSTM=1521466015; BD_UPN=12314753; MCITY=-154%3A; '
                  'BAIDUID=8E87475C1F615023B288E8FEF225AE72:FG=1; '
                  'BDUSS=i1SVmoyV2thVFpqMFY4RlpzYmgtQUdJdFI0aW5mY1BnenRGaW5mTmZzNDdzfnRjSVFBQUFBJCQAAAAAAAAAAAEAAADZOm5rYTE1NzM4Mjc4NTgyAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADsm1Fw7JtRcV;'
                  ' BDORZ=B490B5EBF6F3CD402E515D22BCDA1598; ispeed_lsm=2; delPer=0; BD_CK_SAM=1; BD_HOME=1; H_PS_PSSID=1453_28939_21109_28518_28773_28723_28963_28830_28584; '
                  'PSINO=7; COOKIE_SESSION=1647_0_6_6_14_5_0_0_6_2_422_0_0_0_427_0_1557927845_0_1557929065%7C9%230_0_1557929065%7C1; ZD_ENTRY=baidu; sugstore=1',
        'Host': 'www.baidu.com',
        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3538.102 Safari/537.36'
    }
    
    # data = requests.get('https://www.baidu.com', headers=headers)
    
    data1 = requests.get('https://www.baidu.com/s?' + urlencode({'wd':'美女'}), headers=headers)
    
    print(data1.text)
    View Code

    五 Response

    #1、响应状态
        200:代表成功
        301:代表跳转
        404:文件不存在
        403:权限
        502:服务器错误
    
    #2、Respone header
        set-cookie:可能有多个,是来告诉浏览器,把cookie保存下来
        
    #3、preview就是网页源代码
        最主要的部分,包含了请求资源的内容
        如网页html,图片
        二进制数据等

    六 总结

    #1、总结爬虫流程:
        爬取--->解析--->存储
    
    #2、爬虫所需工具:
        请求库:requests,selenium
        解析库:正则,beautifulsoup,pyquery
        存储库:文件,MySQL,Mongodb,Redis
    
    #3、爬虫常用框架:
        scrapy

     

    posted @ 2019-05-16 09:56 Sean_Yang 阅读(...) 评论(...) 编辑 收藏
    展开全文
  • 为何大量网站不能抓取 爬虫突破封禁的6种常见方法
                   

    为何大量网站不能抓取?爬虫突破封禁的6种常见方法

    在互联网上进行自动数据采集(抓取)这件事和互联网存在的时间差不多一样长。今天大众好像更倾向于用“网络数据采集”,有时会把网络数据采集程序称为网络机器人(bots)。最常用的方法是写一个自动化程序向网络服务器请求数据(通常是用 HTML 表单或其他网页文件),然后对数据进行解析,提取需要的信息。

     

    本文假定读者已经了解如何用代码来抓取一个远程的 URL,并具备表单如何提交及 JavaScript 在浏览器如何运行的机制。想更多了解网络数据采集基础知识,可以参考文后的资料。

     

    在采集网站的时会遇到一些比数据显示在浏览器上却抓取不出来更令人沮丧的事情。也许是向服务器提交自认为已经处理得很好的表单却被拒绝,也许是自己的 IP 地址不知道什么原因直接被网站封杀,无法继续访问。

     

     

    原因可能是一些最复杂的 bug,也可能是这些 bug 让人意想不到(程序在一个网站上可以正常使用,但在另一个看起来完全一样的网站上却用不了)。最有可能出现的情况是:对方有意不让爬虫抓取信息。网站已经把你定性为一个网络机器人直接拒绝了,你无法找出原因。

     

    接下来就介绍一些网络采集的黑魔法(HTTP headers、CSS 和 HTML 表单等),以克服网站阻止自动采集。不过,先让我们聊聊道德问题。

     

    网络爬虫的道德与礼仪

     

    说实话,从道德角度讲,写作以下文字不易。我自己的网站被网络机器人、垃圾邮件生成器、网络爬虫和其他各种不受欢迎的虚拟访问者骚扰过很多次了,你的网站可能也一样。既然如此,为什么还要介绍那些更强大的网络机器人呢?有几个很重要的理由。

     

    • 白帽子工作。在采集那些不想被采集的网站时,其实存在一些非常符合道德和法律规范的理由。比如我之前的工作就是做网络爬虫,我曾做过一个自动信息收集器,从未经许可的网站上自动收集客户的名称、地址、电话号码和其他个人信息,然后把采集的信息提交到网站上,让服务器删除这些客户信息。为了避免竞争,这些网站都会对网络爬虫严防死守。但是,我的工作要确保公司的客户们都匿名(这些人都是家庭暴力受害者,或者因其他正当理由想保持低调的人),这为网络数据采集工作创造了极其合理的条件,我很高兴自己有能力从事这项工作。

    • 虽然不太可能建立一个完全“防爬虫”的网站(最起码得让合法的用户可以方便地访问网站),但我还是希望以下内容可以帮助人们保护自己的网站不被恶意攻击。下文将指出每一种网络数据采集技术的缺点,你可以利用这些缺点保护自己的网站。其实,大多数网络机器人一开始都只能做一些宽泛的信息和漏洞扫描,接下来介绍的几个简单技术就可以挡住 99% 的机器人。但是,它们进化的速度非常快,最好时刻准备迎接新的攻击。

    • 和大多数程序员一样,我从来不相信禁止某一类信息的传播就可以让世界变得更和谐

     

    阅读之前,请牢记:这里演示的许多程序和介绍的技术都不应该在网站上使用。

     

    爬虫黑科技:

    网络机器人看起来像人类用户的一些方法

     

    网站防采集的前提就是要正确地区分人类访问用户和网络机器人。虽然网站可以使用很多识别技术(比如验证码)来防止爬虫,但还是有一些十分简单的方法,可以让你的网络机器人看起来更像人类访问用户。

     

    1. 构造合理的 HTTP 请求头

     

    除了处理网站表单,requests 模块还是一个设置请求头的利器。HTTP 的请求头是在你每次向网络服务器发送请求时,传递的一组属性和配置信息。HTTP 定义了十几种古怪的请求头类型,不过大多数都不常用。只有下面的七个字段被大多数浏览器用来初始化所有网络请求(表中信息是我自己浏览器的数据)。

     

     

    经典的 Python 爬虫在使用 urllib 标准库时,都会发送如下的请求头:

     

     

    如果你是一个防范爬虫的网站管理员,你会让哪个请求头访问你的网站呢?

     

    安装 Requests

     

    可在模块的网站上找到下载链接(http://docs.python-requests.org/en/latest/user/install/)和安装方法,或者用任意第三方 Python 模块安装器进行安装。

     

    请求头可以通过 requests 模块进行自定义。https://www.whatismybrowser.com/ 网站就是一个非常棒的网站,可以让服务器测试浏览器的属性。我们用下面的程序来采集这个网站的信息,验证我们浏览器的 cookie 设置:

     

     

     

    程序输出结果中的请求头应该和程序中设置的 headers 是一样的。

     

    虽然网站可能会对 HTTP 请求头的每个属性进行“是否具有人性”的检查,但是我发现通常真正重要的参数就是 User-Agent。无论做什么项目,一定要记得把 User-Agent 属性设置成不容易引起怀疑的内容,不要用 Python-urllib/3.4。另外,如果你正在处理一个警觉性非常高的网站,就要注意那些经常用却很少检查的请求头,比如 Accept-Language 属性,也许它正是那个网站判断你是个人类访问者的关键。

     

     

    请求头会改变你观看网络世界的方式

     

    假设你想为一个机器学习的研究项目写一个语言翻译机,却没有大量的翻译文本来测试它的效果。很多大型网站都会为同样的内容提供不同的语言翻译,根据请求头的参数响应网站不同的语言版本。因此,你只要简单地把请求头属性从 Accept-Language:en-US 修改成 Accept-Language:fr,就可以从网站上获得“Bonjour”(法语,你好)这些数据来改善翻译机的翻译效果了(大型跨国企业通常都是好的采集对象)。

     

    请求头还可以让网站改变内容的布局样式。例如,用移动设备浏览网站时,通常会看到一个没有广告、Flash 以及其他干扰的简化的网站版本。因此,把你的请求头 User-Agent 改成下面这样,就可以看到一个更容易采集的网站了!

     

    User-Agent:Mozilla/5.0 (iPhone; CPU iPhone OS 7_1_2 like Mac OS X) App leWebKit/537.51.2 (KHTML, like Gecko) Version/7.0 Mobile/11D257 Safari/9537.53

     

    2. 设置 cookie 的学问

     

    虽然 cookie 是一把双刃剑,但正确地处理 cookie 可以避免许多采集问题。网站会用 cookie 跟踪你的访问过程,如果发现了爬虫异常行为就会中断你的访问,比如特别快速地填写表单,或者浏览大量页面。虽然这些行为可以通过关闭并重新连接或者改变 IP 地址来伪装,但是如果 cookie 暴露了你的身份,再多努力也是白费。

     

    在采集一些网站时 cookie 是不可或缺的。要在一个网站上持续保持登录状态,需要在多个页面中保存一个 cookie。有些网站不要求在每次登录时都获得一个新 cookie,只要保存一个旧的“已登录”的 cookie 就可以访问。

     

    如果你在采集一个或者几个目标网站,建议你检查这些网站生成的 cookie,然后想想哪一个 cookie 是爬虫需要处理的。有一些浏览器插件可以为你显示访问网站和离开网站时 cookie 是如何设置的。EditThisCookie(http://www.editthiscookie.com/)是我最喜欢的 Chrome 浏览器插件之一。

     

    因为 requests 模块不能执行 JavaScript,所以它不能处理很多新式的跟踪软件生成的 cookie,比如 Google Analytics,只有当客户端脚本执行后才设置 cookie(或者在用户浏览页面时基于网页事件产生 cookie,比如点击按钮)。要处理这些动作,需要用 Selenium 和 PhantomJS 包。

     

    Selenium 与 PhantomJS

     

    Selenium(http://www.seleniumhq.org/)是一个强大的网络数据采集工具,最初是为网站自动化测试而开发的。近几年,它还被广泛用于获取精确的网站快照,因为它们可以直接运行在浏览器上。Selenium 可以让浏览器自动加载页面,获取需要的数据,甚至页面截屏,或者判断网站上某些动作是否发生。

     

    Selenium 自己不带浏览器,它需要与第三方浏览器结合在一起使用。例如,如果你在 Firefox 上运行 Selenium,可以直接看到 Firefox 窗口被打开,进入网站,然后执行你在代码中设置的动作。虽然这样可以看得更清楚,但是我更喜欢让程序在后台运行,所以我 PhantomJS(http://phantomjs.org/download.html)代替真实的浏览器。

     

    PhantomJS 是一个“无头”(headless)浏览器。它会把网站加载到内存并执行页面上的 JavaScript,但不会向用户展示网页的图形界面。将 Selenium 和 PhantomJS 结合在一起,就可以运行一个非常强大的网络爬虫了,可以处理 cookie、JavaScrip、header,以及任何你需要做的事情。

     

    可以从PyPI网站(https://pypi.python.org/simple/selenium/)下载Selenium库,也可以用第三方管理器(像pip)用命令行安装。

     

    你可以对任意网站(本例用的是 http://pythonscraping.com)调用 webdriver 的 get_cookie()方法来查看 cookie:

     

    点击可查看大图

     

    这样就可以获得一个非常典型的 Google Analytics 的 cookie 列表:

     

    点击可查看大图

     

    还可以调用 delete_cookie()、add_cookie() 和 delete_all_cookies() 方法来处理 cookie。另外,还可以保存 cookie 以备其他网络爬虫使用。下面的例子演示了如何把这些函数组合在一起:

     

    点击可查看大图

     

    在这个例子中,第一个 webdriver 获得了一个网站,打印 cookie 并把它们保存到变量savedCookies 里。第二个 webdriver 加载同一个网站(技术提示:必须首先加载网站,这样 Selenium 才能知道 cookie 属于哪个网站,即使加载网站的行为对我们没任何用处),删除所有的 cookie,然后替换成第一个 webdriver 得到的 cookie。当再次加载这个页面时,两组 cookie 的时间戳、源代码和其他信息应该完全一致。从 Google Analytics 的角度看,第二个 webdriver 现在和第一个 webdriver 完全一样。

     

    3. 正常的时间访问路径

     

    有一些防护措施完备的网站可能会阻止你快速地提交表单,或者快速地与网站进行交互。即使没有这些安全措施,用一个比普通人快很多的速度从一个网站下载大量信息也可能让自己被网站封杀。

     

    因此,虽然多线程程序可能是一个快速加载页面的好办法——在一个线程中处理数据,另一个线程中加载页面——但是这对编写好的爬虫来说是恐怖的策略。还是应该尽量保证一次加载页面加载且数据请求最小化。如果条件允许,尽量为每个页面访问增加一点儿时间间隔,即使你要增加一行代码:

     

    time.sleep(3)

    (小编:3 + 随机数 是不是更好一些?)

     

    合理控制速度是你不应该破坏的规则。过度消耗别人的服务器资源会让你置身于非法境地,更严重的是这么做可能会把一个小型网站拖垮甚至下线。拖垮网站是不道德的,是彻头彻尾的错误。所以请控制采集速度!

     

    常见表单反爬虫安全措施解密

     

    许多像 Litmus 之类的测试工具已经用了很多年了,现在仍用于区分网络爬虫和使用浏览器的人类访问者,这类手段都取得了不同程度的效果。虽然网络机器人下载一些公开的文章和博文并不是什么大事,但是如果网络机器人在你的网站上创造了几千个账号并开始向所有用户发送垃圾邮件,就是一个大问题了。网络表单,尤其是那些用于账号创建和登录的网站,如果被机器人肆意地滥用,网站的安全和流量费用就会面临严重威胁,因此努力限制网站的接入是最符合许多网站所有者的利益的(至少他们这么认为)。

     

    这些集中在表单和登录环节上的反机器人安全措施,对网络爬虫来说确实是严重的挑战。

     

    4. 注意隐含输入字段值

     

    在 HTML 表单中,“隐含”字段可以让字段的值对浏览器可见,但是对用户不可见(除非看网页源代码)。随着越来越多的网站开始用 cookie 存储状态变量来管理用户状态,在找到另一个最佳用途之前,隐含字段主要用于阻止爬虫自动提交表单。

     

    下图显示的例子就是 Facebook 登录页面上的隐含字段。虽然表单里只有三个可见字段(username、password 和一个确认按钮),但是在源代码里表单会向服务器传送大量的信息。

     

     

    Facebook 登录页面上的隐含字段

     

    用隐含字段阻止网络数据采集的方式主要有两种。第一种是表单页面上的一个字段可以用服务器生成的随机变量表示。如果提交时这个值不在表单处理页面上,服务器就有理由认为这个提交不是从原始表单页面上提交的,而是由一个网络机器人直接提交到表单处理页面的。绕开这个问题的最佳方法就是,首先采集表单所在页面上生成的随机变量,然后再提交到表单处理页面。

     

    第二种方式是“蜜罐”(honey pot)。如果表单里包含一个具有普通名称的隐含字段(设置蜜罐圈套),比如“用户名”(username)或“邮箱地址”(email address),设计不太好的网络机器人往往不管这个字段是不是对用户可见,直接填写这个字段并向服务器提交,这样就会中服务器的蜜罐圈套。服务器会把所有隐含字段的真实值(或者与表单提交页面的默认值不同的值)都忽略,而且填写隐含字段的访问用户也可能被网站封杀。

     

    总之,有时检查表单所在的页面十分必要,看看有没有遗漏或弄错一些服务器预先设定好的隐含字段(蜜罐圈套)。如果你看到一些隐含字段,通常带有较大的随机字符串变量,那么很可能网络服务器会在表单提交的时候检查它们。另外,还有其他一些检查,用来保证这些当前生成的表单变量只被使用一次或是最近生成的(这样可以避免变量被简单地存储到一个程序中反复使用)。

     

    5. 爬虫通常如何避开蜜罐

     

    虽然在进行网络数据采集时用 CSS 属性区分有用信息和无用信息会很容易(比如,通过读取 id和 class 标签获取信息),但这么做有时也会出问题。如果网络表单的一个字段通过 CSS 设置成对用户不可见,那么可以认为普通用户访问网站的时候不能填写这个字段,因为它没有显示在浏览器上。如果这个字段被填写了,就可能是机器人干的,因此这个提交会失效。

     

    这种手段不仅可以应用在网站的表单上,还可以应用在链接、图片、文件,以及一些可以被机器人读取,但普通用户在浏览器上却看不到的任何内容上面。访问者如果访问了网站上的一个“隐含”内容,就会触发服务器脚本封杀这个用户的 IP 地址,把这个用户踢出网站,或者采取其他措施禁止这个用户接入网站。实际上,许多商业模式就是在干这些事情。

     

    下面的例子所用的网页在 http://pythonscraping.com/pages/itsatrap.html。这个页面包含了两个链接,一个通过 CSS 隐含了,另一个是可见的。另外,页面上还包括两个隐含字段:

     


    点击可查看大图

     

    这三个元素通过三种不同的方式对用户隐藏:

    • 第一个链接是通过简单的 CSS 属性设置 display:none 进行隐藏

    • 电话号码字段 name="phone" 是一个隐含的输入字段

    • 邮箱地址字段 name="email" 是将元素向右移动 50 000 像素(应该会超出电脑显示器的边界)并隐藏滚动条

     

    因为 Selenium 可以获取访问页面的内容,所以它可以区分页面上的可见元素与隐含元素。通过 is_displayed() 可以判断元素在页面上是否可见。

     

    例如,下面的代码示例就是获取前面那个页面的内容,然后查找隐含链接和隐含输入字段:

     

    点击可查看大图

     

    Selenium 抓取出了每个隐含的链接和字段,结果如下所示:

     

    点击可查看大图

     

    虽然你不太可能会去访问你找到的那些隐含链接,但是在提交前,记得确认一下那些已经在表单中、准备提交的隐含字段的值(或者让 Selenium 为你自动提交)。

     

    使用远程服务器来避免 IP 封锁

     

    启用远程平台的人通常有两个目的:对更大计算能力和灵活性的需求,以及对可变 IP 地址的需求

     

    6. 使用可变的远程 IP 地址

     

    建立网络爬虫的第一原则是:所有信息都可以伪造。你可以用非本人的邮箱发送邮件,通过命令行自动化鼠标的行为,或者通过 IE 5.0 浏览器耗费网站流量来吓唬网管。

     

    但是有一件事情是不能作假的,那就是你的 IP 地址。任何人都可以用这个地址给你写信:“美国华盛顿特区宾夕法尼亚大道西北 1600 号,总统,邮编 20500。”但是,如果这封信是从新墨西哥州的阿尔伯克基市发来的,那么你肯定可以确信给你写信的不是美国总统。

     

    从技术上说,IP 地址是可以通过发送数据包进行伪装的,就是分布式拒绝服务攻击技术(Distributed Denial of Service,DDoS),攻击者不需要关心接收的数据包(这样发送请求的时候就可以使用假 IP 地址)。但是网络数据采集是一种需要关心服务器响应的行为,所以我们认为 IP 地址是不能造假的。

     

    阻止网站被采集的注意力主要集中在识别人类与机器人的行为差异上面。封杀 IP 地址这种矫枉过正的行为,就好像是农民不靠喷农药给庄稼杀虫,而是直接用火烧彻底解决问题。它是最后一步棋,不过是一种非常有效的方法,只要忽略危险 IP 地址发来的数据包就可以了。但是,使用这种方法会遇到以下几个问题。

     

    • IP 地址访问列表很难维护。虽然大多数大型网站都会用自己的程序自动管理 IP 地址访问列表(机器人封杀机器人),但是至少需要人偶尔检查一下列表,或者至少要监控问题的增长。

    • 因为服务器需要根据 IP 地址访问列表去检查每个准备接收的数据包,所以检查接收数据包时会额外增加一些处理时间。多个 IP 地址乘以海量的数据包更会使检查时间指数级增长。为了降低处理时间和处理复杂度,管理员通常会对 IP 地址进行分组管理并制定相应的规则,比如如果这组 IP 中有一些危险分子就“把这个区间的所有 256 个地址全部封杀”。于是产生了下一个问题。

    • 封杀 IP 地址可能会导致意外后果。例如,当我还在美国麻省欧林工程学院读本科的时候,有个同学写了一个可以在 http://digg.com/ 网站(在 Reddit 流行之前大家都用 Digg)上对热门内容进行投票的软件。这个软件的服务器 IP 地址被 Digg 封杀,导致整个网站都不能访问。于是这个同学就把软件移到了另一个服务器上,而 Digg 自己却失去了许多主要目标用户的访问量。

     

    虽然有这些缺点,但封杀 IP 地址依然是一种十分常用的手段,服务器管理员用它来阻止可疑的网络爬虫入侵服务器。

     

    Tor 代理服务器

     

    洋葱路由(The Onion Router)网络,常用缩写为 Tor,是一种 IP 地址匿名手段。由网络志愿者服务器构建的洋葱路由器网络,通过不同服务器构成多个层(就像洋葱)把客户端包在最里面。数据进入网络之前会被加密,因此任何服务器都不能偷取通信数据。另外,虽然每一个服务器的入站和出站通信都可以被查到,但是要想查出通信的真正起点和终点,必须知道整个通信链路上所有服务器的入站和出站通信细节,而这基本是不可能实现的。

     

     Tor 匿名的局限性

    虽然我们在本文中用 Tor 的目的是改变 IP 地址,而不是实现完全匿名,但有必要关注一下 Tor 匿名方法的能力和不足。

     

    虽然 Tor 网络可以让你访问网站时显示的 IP 地址是一个不能跟踪到你的 IP 地址,但是你在网站上留给服务器的任何信息都会暴露你的身份。例如,你登录 Gmail 账号后再用 Google 搜索,那些搜索历史就会和你的身份绑定在一起。

     

    另外,登录 Tor 的行为也可能让你的匿名状态处于危险之中。2013 年 12 月,一个哈佛大学本科生想逃避期末考试,就用一个匿名邮箱账号通过 Tor 网络给学校发了一封炸弹威胁信。结果哈佛大学的 IT 部门通过日志查到,在炸弹威胁信发来的时候,Tor 网络的流量只来自一台机器,而且是一个在校学生注册的。虽然他们不能确定流量的最初源头(只知道是通过 Tor 发送的),但是作案时间和注册信息证据充分,而且那个时间段内只有一台机器是登录状态,这就有充分理由起诉那个学生了。

     

    登录 Tor 网络不是一个自动的匿名措施,也不能让你进入互联网上任何区域。虽然它是一个实用的工具,但是用它的时候一定要谨慎、清醒,并且遵守道德规范。

     

    在 Python 里使用 Tor,需要先安装运行 Tor,下一节将介绍。Tor 服务很容易安装和开启。只要去 Tor 下载页面下载并安装,打开后连接就可以。不过要注意,当你用 Tor 的时候网速会变慢。这是因为代理有可能要先在全世界网络上转几次才到目的地!

     

    PySocks

     

    PySocks 是一个非常简单的 Python 代理服务器通信模块,它可以和 Tor 配合使用。你可以从它的网站(https://pypi.python.org/pypi/PySocks)上下载,或者使用任何第三方模块管理器安装。

     

    这个模块的用法很简单。示例代码如下所示。运行的时候,Tor 服务必须运行在 9150 端口(默认值)上:

     

     

    网站 http://icanhazip.com/ 会显示客户端连接的网站服务器的 IP 地址,可以用来测试 Tor 是否正常运行。当程序执行之后,显示的 IP 地址就不是你原来的 IP 了。

     

    如果你想在 Tor 里面用 Selenium 和 PhantomJS,不需要 PySocks,只要保证 Tor 在运行,然后增加 service_args 参数设置代理端口,让 Selenium 通过端口 9150 连接网站就可以了:

     

    和之前一样,这个程序打印的 IP 地址也不是你原来的,而是你通过 Tor 客户端获得的 IP 地址。

     

    从网站主机运行

     

    如果你拥有个人网站或公司网站,那么你可能已经知道如何使用外部服务器运行你的网络爬虫了。即使是一些相对封闭的网络服务器,没有可用的命令行接入方式,你也可以通过网页界面对程序进行控制。

     

    如果你的网站部署在 Linux 服务器上,应该已经运行了 Python。如果你用的是 Windows 服务器,可能就没那么幸运了;你需要仔细检查一下 Python 有没有安装,或者问问网管可不可以安装。

     

    大多数小型网络主机都会提供一个软件叫 cPanel,提供网站管理和后台服务的基本管理功能和信息。如果你接入了 cPanel,就可以设置 Python 在服务器上运行——进入“Apache Handlers”然后增加一个 handler(如还没有的话):

     

     

    这会告诉服务器所有的 Python 脚本都将作为一个 CGI 脚本运行。CGI 就是通用网关接口(Common Gateway Interface),是可以在服务器上运行的任何程序,会动态地生成内容并显示在网站上。把 Python 脚本显式地定义成 CGI 脚本,就是给服务器权限去执行 Python 脚本,而不只是在浏览器上显示它们或者让用户下载它们。

     

    写完 Python 脚本后上传到服务器,然后把文件权限设置成 755,让它可执行。通过浏览器找到程序上传的位置(也可以写一个爬虫来自动做这件事情)就可以执行程序。如果你担心在公共领域执行脚本不安全,可以采取以下两种方法。

     

    • 把脚本存储在一个隐晦或深层的 URL 里,确保其他 URL 链接都不能接入这个脚本,这样可以避免搜索引擎发现它。

    • 用密码保护脚本,或者在执行脚本之前用密码或加密令牌进行确认。

     

    确实,通过这些原本主要是用来显示网站的服务运行 Python 脚本有点儿复杂。比如,你可能会发现网络爬虫运行时网站的加载速度变慢了。其实,在整个采集任务完成之前页面都是不会加载的(得等到所有“print”语句的输出内容都显示完)。这可能会消耗几分钟,几小时,甚至永远也完成不了,要看程序的具体情况了。虽然它最终一定能完成任务,但是可能你还想看到实时的结果,这样就需要一台真正的服务器了。

     

    从云主机运行

     

    虽然云计算的花费可能是无底洞,但是写这篇文章时,启动一个计算实例最便宜只要每小时 1.3 美分(亚马逊 EC2 的 micro 实例,其他实例会更贵),Google 最便宜的计算实例是每小时 4.5 美分,最少需要用 10 分钟。考虑计算能力的规模效应,从大公司买一个小型的云计算实例的费用,和自己买一台专业实体机的费用应该差不多——不过用云计算不需要雇人去维护设备。

     

    设置好计算实例之后,你就有了新 IP 地址、用户名,以及可以通过 SSH 进行实例连接的公私密钥了。后面要做的每件事情,都应该和你在实体服务器上干的事情一样了——当然,你不需要再担心硬件维护,也不用运行复杂多余的监控工具了。

     

    总结

    爬虫被封禁常见原因列表

     

    如果你一直被网站封杀却找不到原因,那么这里有个检查列表,可以帮你诊断一下问题出在哪里。

     

    • 首先,检查 JavaScript 。如果你从网络服务器收到的页面是空白的,缺少信息,或其遇到他不符合你预期的情况(或者不是你在浏览器上看到的内容),有可能是因为网站创建页面的 JavaScript 执行有问题

    • 检查正常浏览器提交的参数。如果你准备向网站提交表单或发出 POST 请求,记得检查一下页面的内容,看看你想提交的每个字段是不是都已经填好,而且格式也正确。用 Chrome 浏览器的网络面板(快捷键 F12 打开开发者控制台,然后点击“Network”即可看到)查看发送到网站的 POST 命令,确认你的每个参数都是正确的。

    • 是否有合法的 Cookie?如果你已经登录网站却不能保持登录状态,或者网站上出现了其他的“登录状态”异常,请检查你的 cookie。确认在加载每个页面时 cookie 都被正确调用,而且你的 cookie 在每次发起请求时都发送到了网站上。

    • IP 被封禁?如果你在客户端遇到了 HTTP 错误,尤其是 403 禁止访问错误,这可能说明网站已经把你的 IP 当作机器人了,不再接受你的任何请求。你要么等待你的 IP 地址从网站黑名单里移除,要么就换个 IP 地址(可以去星巴克上网)。如果你确定自己并没有被封杀,那么再检查下面的内容。

      • 确认你的爬虫在网站上的速度不是特别快。快速采集是一种恶习,会对网管的服务器造成沉重的负担,还会让你陷入违法境地,也是 IP 被网站列入黑名单的首要原因。给你的爬虫增加延迟,让它们在夜深人静的时候运行。切记:匆匆忙忙写程序或收集数据都是拙劣项目管理的表现;应该提前做好计划,避免临阵慌乱。

      • 还有一件必须做的事情:修改你的请求头!有些网站会封杀任何声称自己是爬虫的访问者。如果你不确定请求头的值怎样才算合适,就用你自己浏览器的请求头吧。

      • 确认你没有点击或访问任何人类用户通常不能点击或接入的信息。

      • 如果你用了一大堆复杂的手段才接入网站,考虑联系一下网管吧,告诉他们你的目的。试试发邮件到 webmaster@< 域名 > 或 admin@< 域名 >,请求网管允许你使用爬虫采集数据。管理员也是人嘛!

     

    【以上内容整理自《Python 网络数据采集》第 10、12、14 章】

               

    再分享一下我老师大神的人工智能教程吧。零基础!通俗易懂!风趣幽默!还带黄段子!希望你也加入到我们人工智能的队伍中来!https://blog.csdn.net/jiangjunshow

    展开全文
  • 爬虫实例

    2018-12-24 19:45:44
    scrapy是python最有名的爬虫框架之一,可以很方便的进行web抓取,并且提供了很强的定制型,这里记录简单学习的过程和在实际应用中会遇到的一些常见问题 一、安装 在安装scrapy之前有一些依赖需要安装,否则可能会...
  • 爬虫

    2020-10-09 20:08:00
    网络爬虫(网页蜘蛛、网络机器人) 爬虫就是模拟客户端发送网络请求,接收请求对应的响应,一种按照一定的规则,自动的抓取互联网信息的程序。 理论上来说,只要用户通过 客户端(浏览器) 能够做到的事情,爬虫都...
  • 我的第一个Python爬虫——谈心得

    万次阅读 多人点赞 2018-03-30 19:24:26
    相信各大高校应该都有本校APP或超级课程表之类的软件,在信息化的时代能快速收集/查询自己想要的咨询也是种很重要的能力,所以记下了这篇博客,用于总结我所学到的东西,以及用于记录我的第一个爬虫的初生。...
  • 爬虫(一)网络爬虫/相关工具与知识

    万次阅读 多人点赞 2018-06-02 15:12:46
    网络爬虫 网络爬虫(web crawler), 以前经常称为网络蜘蛛(spider), 是按照一定的规则自动浏览万维网并获取信息的机器人程序(或叫脚本), 曾经被广泛的应用于互联网搜索引擎. 使用过互联网和浏览器的人都知道, 网页中...
  • 爬虫系列(一) 网络爬虫简介

    万次阅读 多人点赞 2018-08-09 17:45:00
    最近博主在学习网络爬虫的相关技术(基于 Python 语言),作为一个学习的总结,打算用博客记录下来,也希望和大家分享一下自己在学习过程中的点点滴滴,话不多说,让我们马上开始吧 ^_^
  • 一、网络爬虫的定义 网络爬虫,即Web Spider,是一个很形象的名字。 把互联网比喻成一个蜘蛛网,那么Spider就是在网上爬来爬去的蜘蛛。 网络蜘蛛是通过网页的链接地址来寻找网页的。 从网站某一个页面(通常是...
  • 32个Python爬虫项目让你一次吃到撑

    万次阅读 多人点赞 2017-08-23 15:09:07
    今天为大家整理了32个Python爬虫项目。 整理的原因是,爬虫入门简单快速,也非常适合新入门的小伙伴培养信心。所有链接指向GitHub,祝大家玩的愉快~O(∩_∩)O WechatSogou [1]- 微信公众号爬虫。基于搜狗微信搜索的...
  • Python爬虫100例教程导航帖(已完结)

    万次阅读 多人点赞 2019-01-08 23:40:01
    Python爬虫入门教程导航,目标100篇。 本系列博客争取把爬虫入门阶段的所有内容都包含住,需要你有较好的Python基础知识,当然你完全零基础也可以观看本系列博客。 Python爬虫入门教程,加油!
  • Python爬虫实战之爬取网站全部图片(一)

    万次阅读 多人点赞 2018-09-02 12:28:21
    Python爬虫实战之爬取网站全部图片(二) 传送门: https://blog.csdn.net/qq_33958297/article/details/89388556 爬取网址: http://www.meizitu.com/a/more_1.html 爬取地址:...
  • 京东口罩爬虫,到货通知爬虫,自动下单爬虫第二篇功能效果展示无货展示有货展示撸代码修改的地方邮箱修改口罩链接获取方式自动下单所需Cookie获取 预祝大家都能抢到口罩,请大家适量购买 第一篇 马上上班了,回来的...
  • 关于Python爬虫的超详细讲解,用例子来给大家一步步分析爬虫的代码原理,由浅入深,老年人来了,我也给你整明白。
  • python爬虫入门教程(二):开始一个简单的爬虫

    万次阅读 多人点赞 2017-09-12 15:02:21
    python爬虫入门教程,介绍编写一个简单爬虫的过程。
  • 第一个Python爬虫

    万次阅读 多人点赞 2019-05-28 10:23:39
    之前就对Python爬虫和机器学习很感兴趣,最近终于是开始学习了.... 好吧,不是没时间,而是有时间的时候都干别的了,所以对于还需要抽时间学我只能是‘好吧’的态度... 今天急急忙忙的就上手了一个小例子,随便爬...
  • Python爬虫,高清美图我全都要(彼岸桌面壁纸)

    万次阅读 多人点赞 2020-03-30 11:13:49
    爬取彼岸桌面网站较为简单,用到了requests、lxml、Beautiful Soup4
  • 我的Python爬虫代码示例(一)

    万次阅读 2019-04-29 13:54:37
    从链家网站爬虫石家庄符合条件的房源信息,并保存到文件,房源信息包括名称、建筑面积、总价、所在区域、套内面积等。其中所在区域、套内面积需要在详情页获取计算。 主要使用了requests+BeautifulSoup第三方模块,...
  • 最近两天学习了一下python,并自己写了一个网络爬虫的例子。 python版本: 3.5 IDE : pycharm 5.0.4 要用到的包可以用pycharm下载: File->Default Settings->Default Project->Project Interpreter 选择python...
  • 本人是python新手,目前在看中国大学MOOC的嵩天老师的爬虫课程,其中一个实例是讲如何爬取淘宝商品信息 以下是代码: import requests import re def getHTMLText(url): try: r = requests.get(url, timeout=30)...
  • Python爬虫的用途

    万次阅读 多人点赞 2018-08-16 14:02:03
    Python爬虫是用Python编程语言实现的网络爬虫,主要用于网络数据的抓取和处理,相比于其他语言,Python是一门非常适合开发网络爬虫的编程语言,大量内置包,可以轻松实现网络爬虫功能。 Python爬虫可以做的事情很多...
  • 爬虫100例的原则上最后一篇文章,很激动,有很多话想说,请允许我写这么一篇唠唠叨叨的文章。 写爬虫系列很迷,估计和很多进入爬虫编码圈的人一样,单纯的我只想看一些图片,然而一页页的去翻,真的好麻烦,总想着...
  • Python爬虫的N种姿势

    万次阅读 多人点赞 2018-10-16 18:12:18
      前几天,在微信公众号(Python爬虫及算法)上有个人问了笔者一个问题,如何利用爬虫来实现如下的需求,需要爬取的网页如下(网址为:https://www.wikidata.org/w/index.php?title=Special:WhatLinksHere/Q5&...
  • python爬虫入门教程(一):开始爬虫前的准备工作

    万次阅读 多人点赞 2017-09-07 18:08:50
    python爬虫(数据采集)入门教程
  • 18个Python爬虫实战案例(已开源)

    万次阅读 多人点赞 2018-06-26 08:20:00
    目录爬虫小工具文件下载小助手爬虫实战笔趣看小说下载VIP视频下载百度文库文章下载_rev1百度文库文章下载_rev2《帅啊》网帅哥图片下载构建代理IP池《火影忍者》漫画下...

空空如也

1 2 3 4 5 ... 20
收藏数 340,759
精华内容 136,303
关键字:

爬虫