爬虫篇(1)-Scrapy - 基础(转)

Scrapy

Scrapy,Python开发的一个快速、高层次的屏幕抓取和web抓取框架,用于抓取web站点并从页面中提取结构化的数据。Scrapy用途广泛,可以用于数据挖掘、监测和自动化测试

Scrapy吸引人的地方在于它是一个框架,任何人都可以根据需求方便的修改。它也提供了多种类型爬虫的基类,如BaseSpider、sitemap爬虫等,最新版本又提供了web2.0爬虫的支持。

一、scrapy使用入门

以之前的糗事百科为列

1.、新建项目

  • 在开始爬取之前,必须创建一个新的Scrapy项目。进入自定义的项目目录中,运行下列命令:
scrapy startproject 项目名称

#例如:
scrapy startproject myspider
  • 其中, mySpider 为项目名称,可以看到将会创建一个 mySpider 文件夹,目录结构大致如下:

下面来简单介绍一下各个主要文件的作用:

scrapy.cfg :项目的配置文件

mySpider/ :项目的Python模块,将会从这里引用代码

mySpider/items.py :项目的目标文件

mySpider/pipelines.py :项目的管道文件

mySpider/settings.py :项目的设置文件

mySpider/spiders/ :存储爬虫代码目录

打开setting文件进行相应的设置

#关闭roobox协议
ROBOTSTXT_OBEY = False
#设置请求头
DEFAULT_REQUEST_HEADERS = {
  'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
  'Accept-Language': 'en',
  'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/63.0.3239.84 Safari/537.36'
}

2、明确目标(mySpider/items.py)

目标:糗事百科(段子作者和内容)

  1. 打开mySpider目录下的items.py
  2. Item 定义结构化数据字段,用来保存爬取到的数据,有点像Python中的dict,但是提供了一些额外的保护减少错误。
  3. 可以通过创建一个 scrapy.Item 类, 并且定义类型为 scrapy.Field的类属性来定义一个Item。
  4. 接下来,创建Item 类,和构建item模型(model)。
import scrapy

class QsbkItem(scrapy.Item):
    author = scrapy.Field()
    content = scrapy.Field()

3、制作爬虫 (spiders/itcastSpider.py)

爬虫功能要分两步:

1. 爬数据

  • 在当前目录下输入命令,将在mySpider/spider目录下创建一个名为itcast的爬虫,并指定爬取域的范围:
scrapy genspider itcast "qiushibaike.com"
  • 打开 mySpider/spider目录里的 qsbk.py,默认增加了下列代码:
import scrapy


class QsbkSpider(scrapy.Spider):
    name = 'qsbk'
    allowed_domains = ['qiushibaike.com'] #域名限制,该爬虫只会访问该域名下的url地址
    start_urls = ['http://www.qiushibaike.com/'] #启动的url

    def parse(self, response):
        pass

要建立一个Spider, 你必须用scrapy.Spider类创建一个子类,并确定了三个强制的属性 和 一个方法。

  • name = "" :这个爬虫的识别名称,必须是唯一的,在不同的爬虫必须定义不同的名字。
  • allow_domains = [] 是搜索的域名范围,也就是爬虫的约束区域,规定爬虫只爬取这个域名下的网页,不存在的URL会被忽略。
  • start_urls = () :爬取的URL元祖/列表。爬虫从这里开始抓取数据,所以,第一次下载的数据将会从这些urls开始。其他子URL将会从这些起始URL中继承性生成。
  • parse(self, response) :解析的方法,每个初始URL完成下载后将被调用,调用的时候传入从每一个URL传回的Response对象来作为唯一参数,主要作用如下:
    1. 负责解析返回的网页数据(response.body),提取结构化数据(生成item)
    2. 生成需要下一页的URL请求。

将start_urls的值修改为需要爬取的第一个url

 start_urls = [https://www.qiushibaike.com/text/page/1/']

然后运行项目

scrapy crawl qsbk

是的,就是 itcast,看上面代码,它是 ItcastSpider 类的 name 属性,也就是使用 scrapy genspider命令的爬虫名。

一个Scrapy爬虫项目里,可以存在多个爬虫。各个爬虫在执行时,就是按照 name 属性来区分。

运行之后,如果打印的日志出现 [scrapy] INFO: Spider closed (finished),代表执行完成。。


  1. 取数据
  • 爬取整个网页完毕,接下来的就是的取过程了,首先观察页面源码:
import scrapy
from qsbk.items import QsbkItem

class QsbkSpiderSpider(scrapy.Spider):
    name = 'qsbk_spider'
    allowed_domains = ['qiushibaike.com']
    start_urls = ['https://www.qiushibaike.com/text/page/1/']

    def parse(self, response):
        # SelectorList
        duanzidivs = response.xpath("//div[@id='content-left']/div")
        print(duanzidivs)
        for duanzidiv in duanzidivs:
            # Selector
            author = duanzidiv.xpath(".//h2/text()").get().strip()
            content = duanzidiv.xpath(".//div[@class='content']//text()").getall()
            content = "".join(content).strip()
            item = QsbkItem(author=author,content=content)
            yield item
  • 我们暂时先不处理管道,后面会详细介绍。

4、保存数据(管道pipelines)

使用管道之前,先在stteings中开启管道

#大概是在第68行
ITEM_PIPELINES = {
   'qsbk.pipelines.QsbkPipeline': 300,
}

然后再pipelines中写存储的文件信息

class QsbkPipeline(object):

    def process_item(self, item, spider):
        self.fp = open("duanzi.txt",'w')
        self.fb.write(item)
        return item

创建启动文件

from scrapy import cmdline

cmdline.execute(["scrapy",'crawl','qsbk_spider'])

二、Scrapy Shell

Scrapy终端是一个交互终端,我们可以在未启动spider的情况下尝试及调试代码,也可以用来测试XPath或CSS表达式,查看他们的工作方式,方便我们爬取的网页中提取的数据。

如果安装了 IPython ,Scrapy终端将使用 IPython (替代标准Python终端)。 IPython 终端与其他相比更为强大,提供智能的自动补全,高亮输出,及其他特性。(推荐安装IPython)

1、启动Scrapy Shell

进入项目的根目录,执行下列命令来启动shell:

scrapy shell "https://www.qiushibaike.com/text/page/1/"

Scrapy Shell根据下载的页面会自动创建一些方便使用的对象,例如 Response 对象,以及 Selector 对象 (对HTML及XML内容)

  • 当shell载入后,将得到一个包含response数据的本地 response 变量,输入 response.body将输出response的包体,输出 response.headers 可以看到response的包头。
  • 输入 response.selector 时, 将获取到一个response 初始化的类 Selector 的对象,此时可以通过使用 response.selector.xpath()response.selector.css() 来对 response 进行查询。
  • Scrapy也提供了一些快捷方式, 例如 response.xpath()response.css()同样可以生效(如之前的案例)。

2、Selectors选择器

Scrapy Selectors 内置 XPath 和 CSS Selector 表达式机制

Selector有四个基本的方法,最常用的还是xpath:

  • xpath(): 传入xpath表达式,返回该表达式所对应的所有节点的selector list列表
  • extract(): 序列化该节点为字符串并返回list
  • css(): 传入CSS表达式,返回该表达式所对应的所有节点的selector list列表,语法同 BeautifulSoup4
  • re(): 根据传入的正则表达式对数据进行提取,返回字符串list列表

XPath表达式的例子及对应的含义:

/html/head/title: 选择<HTML>文档中 <head> 标签内的 <title> 元素
/html/head/title/text(): 选择上面提到的 <title> 元素的文字
//td: 选择所有的 <td> 元素
//div[@class="mine"]: 选择所有具有 class="mine" 属性的 div 元素

尝试Selector

我们用腾讯社招的网站http://hr.tencent.com/position.php?&start=0#a举例:

# 启动
scrapy shell "http://hr.tencent.com/position.php?&start=0#a"

# 返回 xpath选择器对象列表
response.xpath('//title')
[<Selector xpath='//title' data='<title>职位搜索 | 社会招聘 | Tencent 腾讯招聘</title'>]

# 使用 extract()方法返回字符串列表
response.xpath('//title').extract()
['<title>职位搜索 | 社会招聘 | Tencent 腾讯招聘</title>']

# 打印列表第一个元素,没有则返回None
print response.xpath('//title').extract_first()
<title>职位搜索 | 社会招聘 | Tencent 腾讯招聘</title>

#contains的用法,or的用法,last()的含义
In [6]: response.xpath('//*[contains(@class,"odd") or contains(@class,"even")]/td[last()]/text()').extract()
Out[6]:
['2017-06-02',
 '2017-06-02',
 '2017-06-02',
 '2017-06-02',
 '2017-06-02',
 '2017-06-02',
 '2017-06-02',
 '2017-06-02',
 '2017-06-02',
 '2017-06-02']

 In [4]: response.xpath('//a[contains(@href,"position_detail.php?")]/text()').extract()
 Out[4]:
 ['19407-移动游戏平台合作(上海)',
  '19407-手游商业化与本地化策划(上海)',
  'OMG236-腾讯视频平台高级产品经理(深圳)',
  'OMG096-科技频道记者(北京)',
  '18402-项目管理',
  'IEG-招聘经理(深圳)',
  'OMG097-视觉设计师(北京)',
  'OMG097-策略产品经理/产品运营(北京)',
  'OMG097-策略产品经理/产品运营(北京)',
  'OMG097-数据产品经理(北京)']

  In [5]: response.xpath('//*[contains(@class,"odd") or contains(@class,"even")]/td[last()-1]/text()').extract()
  Out[5]: ['上海', '上海', '深圳', '北京', '深圳', '深圳', '北京', '北京', '北京', '北京']

以后做数据提取的时候,可以把现在Scrapy Shell中测试,测试通过后再应用到代码中。

当然Scrapy Shell作用不仅仅如此,但是不属于我们课程重点,不做详细介绍。

官方文档:http://scrapy-chs.readthedocs.io/zh_CN/latest/topics/shell.html

三、item pipeline

当Item在Spider中被收集之后,它将会被传递到Item Pipeline,这些Item Pipeline组件按定义的顺序处理Item。

每个Item Pipeline都是实现了简单方法的Python类,比如决定此Item是丢弃而存储。以下是item pipeline的一些典型应用:

  • 验证爬取的数据(检查item包含某些字段,比如说name字段)
  • 查重(并丢弃)
  • 将爬取结果保存到文件或者数据库中

1、编写item pipeline

编写item pipeline很简单,item pipiline组件是一个独立的Python类,其中process_item()方法必须实现:

import something

class QsbkPipeline(object):
    def __init__(self):    
        # 可选实现,做参数初始化等
        # doing something

    def process_item(self, item, spider):
        # item (Item 对象) – 被爬取的item
        # spider (Spider 对象) – 爬取该item的spider
        # 这个方法必须实现,每个item pipeline组件都需要调用该方法,
        # 这个方法必须返回一个 Item 对象,被丢弃的item将不会被之后的pipeline组件所处理。
        return item

    def open_spider(self, spider):
        # spider (Spider 对象) – 被开启的spider
        # 可选实现,当spider被开启时,这个方法被调用。

    def close_spider(self, spider):
        # spider (Spider 对象) – 被关闭的spider
        # 可选实现,当spider被关闭时,这个方法被调用

启用一个Item Pipeline组件

为了启用Item Pipeline组件,必须将它的类添加到 settings.py文件ITEM_PIPELINES 配置,就像下面这个例子:

# Configure item pipelines
# See http://scrapy.readthedocs.org/en/latest/topics/item-pipeline.html
ITEM_PIPELINES = {
    #'mySpider.pipelines.SomePipeline': 300,
    "mySpider.pipelines.JsonPipeline":300
}

分配给每个类的整型值,确定了他们运行的顺序,item按数字从低到高的顺序,通过pipeline,通常将这些数字定义在0-1000范围内(0-1000随意设置,数值越低,组件的优先级越高)

2、Logging配置

Scrapy提供了log功能,可以通过 logging 模块使用。

可以修改配置文件settings.py,任意位置添加下面两行,效果会清爽很多。

LOG_FILE = "xxx.log" #指定login保存文件
LOG_LEVEL = "INFO"   #指定login信息输出等级

四、Spider

Spider类定义了如何爬取某个(或某些)网站。包括了爬取的动作(例如:是否跟进链接)以及如何从网页的内容中提取结构化数据(爬取item)。 换句话说,Spider就是您定义爬取的动作及分析某个网页(或者是有些网页)的地方。

class scrapy.Spider是最基本的类,所有编写的爬虫必须继承这个类。

主要用到的函数及调用顺序为:

__init__() : 初始化爬虫名字和start_urls列表

start_requests() 调用make_requests_from url():生成Requests对象交给Scrapy下载并返回response

parse() : 解析response,并返回Item或Requests(需指定回调函数)。Item传给Item pipline持久化 , 而Requests交由Scrapy下载,并由指定的回调函数处理(默认parse()),一直进行循环,直到处理完所有的数据为止。

源码参考

#所有爬虫的基类,用户定义的爬虫必须从这个类继承
class Spider(object_ref):

    #定义spider名字的字符串(string)。spider的名字定义了Scrapy如何定位(并初始化)spider,所以其必须是唯一的。
    #name是spider最重要的属性,而且是必须的。
    #一般做法是以该网站(domain)(加或不加 后缀 )来命名spider。 例如,如果spider爬取 mywebsite.com ,该spider通常会被命名为 mywebsite
    name = None

    #初始化,提取爬虫名字,start_ruls
    def __init__(self, name=None, **kwargs):
        if name is not None:
            self.name = name
        # 如果爬虫没有名字,中断后续操作则报错
        elif not getattr(self, 'name', None):
            raise ValueError("%s must have a name" % type(self).__name__)

        # python 对象或类型通过内置成员__dict__来存储成员信息
        self.__dict__.update(kwargs)

        #URL列表。当没有指定的URL时,spider将从该列表中开始进行爬取。 因此,第一个被获取到的页面的URL将是该列表之一。 后续的URL将会从获取到的数据中提取。
        if not hasattr(self, 'start_urls'):
            self.start_urls = []

    # 打印Scrapy执行后的log信息
    def log(self, message, level=log.DEBUG, **kw):
        log.msg(message, spider=self, level=level, **kw)

    # 判断对象object的属性是否存在,不存在做断言处理
    def set_crawler(self, crawler):
        assert not hasattr(self, '_crawler'), "Spider already bounded to %s" % crawler
        self._crawler = crawler

    @property
    def crawler(self):
        assert hasattr(self, '_crawler'), "Spider not bounded to any crawler"
        return self._crawler

    @property
    def settings(self):
        return self.crawler.settings

    #该方法将读取start_urls内的地址,并为每一个地址生成一个Request对象,交给Scrapy下载并返回Response
    #该方法仅调用一次
    def start_requests(self):
        for url in self.start_urls:
            yield self.make_requests_from_url(url)

    #start_requests()中调用,实际生成Request的函数。
    #Request对象默认的回调函数为parse(),提交的方式为get
    def make_requests_from_url(self, url):
        return Request(url, dont_filter=True)

    #默认的Request对象回调函数,处理返回的response。
    #生成Item或者Request对象。用户必须实现这个类
    def parse(self, response):
        raise NotImplementedError

    @classmethod
    def handles_request(cls, request):
        return url_is_from_spider(request.url, cls)

    def __str__(self):
        return "<%s %r at 0x%0x>" % (type(self).__name__, self.name, id(self))

    __repr__ = __str__

1、主要属性和方法

  • name

    定义spider名字的字符串。

    例如,如果spider爬取 mywebsite.com ,该spider通常会被命名为 mywebsite

  • allowed_domains

    包含了spider允许爬取的域名(domain)的列表,可选。

  • start_urls

    初始URL元祖/列表。当没有制定特定的URL时,spider将从该列表中开始进行爬取。

  • start_requests(self)

    该方法必须返回一个可迭代对象(iterable)。该对象包含了spider用于爬取(默认实现是使用 start_urls 的url)的第一个Request。

    当spider启动爬取并且未指定start_urls时,该方法被调用。

  • parse(self, response)

    当请求url返回网页没有指定回调函数时,默认的Request对象回调函数。用来处理网页返回的response,以及生成Item或者Request对象。

  • log(self, message[, level, component])

    使用 scrapy.log.msg() 方法记录(log)message。 更多数据请参见 logging

2、案例:自动翻页采集

  • 创建一个新的爬虫:
scrapy genspider tencent "tencent.com"

获取职位名称、详细信息、

class TencentItem(scrapy.Item):
    name = scrapy.Field()
    detailLink = scrapy.Field()
    positionInfo = scrapy.Field()
    peopleNumber = scrapy.Field()
    workLocation = scrapy.Field()
    publishTime = scrapy.Field()
# tencent.py

from mySpider.items import TencentItem
import scrapy
import re

class TencentSpider(scrapy.Spider):
    name = "tencent"
    allowed_domains = ["hr.tencent.com"]
    start_urls = [
        "http://hr.tencent.com/position.php?&start=0#a"
    ]

    def parse(self, response):
    items = response.xpath('//*[contains(@class,"odd") or contains(@class,"even")]')
    for item in items:
        temp = dict(
            name=item.xpath("./td[1]/a/text()").extract()[0],
            detailLink="http://hr.tencent.com/"+item.xpath("./td[1]/a/@href").extract()[0],
            positionInfo=item.xpath('./td[2]/text()').extract()[0] if len(item.xpath('./td[2]/text()').extract())>0 else None,
            peopleNumber=item.xpath('./td[3]/text()').extract()[0],
            workLocation=item.xpath('./td[4]/text()').extract()[0],
            publishTime=item.xpath('./td[5]/text()').extract()[0]
        )
        yield temp

    now_page = int(re.search(r"\d+", response.url).group(0))
    print("*" * 100)
    if now_page < 216:
        url = re.sub(r"\d+", str(now_page + 10), response.url)
        print("this is next page url:", url)
        print("*" * 100)
        yield scrapy.Request(url, callback=self.parse)
  • 编写pipeline.py文件
import json

#class ItcastJsonPipeline(object):
class TencentJsonPipeline(object):

    def __init__(self):
        #self.file = open('teacher.json', 'wb')
        self.file = open('tencent.json', 'wb')

    def process_item(self, item, spider):
        content = json.dumps(dict(item), ensure_ascii=False) + "\n"
        self.file.write(content)
        return item

    def close_spider(self, spider):
        self.file.close()
ITEM_PIPELINES = {
    #'mySpider.pipelines.SomePipeline': 300,
    "mySpider.pipelines.TencentJsonPipeline":300
}
  • 执行爬虫:scrapy crawl tencent

3、请思考 parse()方法的工作机制:

1. 因为使用的yield,而不是return。parse函数将会被当做一个生成器使用。scrapy会逐一获取parse方法中生成的结果,并判断该结果是一个什么样的类型;
2. 如果是request则加入爬取队列,如果是item类型则使用pipeline处理,其他类型则返回错误信息。
3. scrapy取到第一部分的request不会立马就去发送这个request,只是把这个request放到队列里,然后接着从生成器里获取;
4. 取尽第一部分的request,然后再获取第二部分的item,取到item了,就会放到对应的pipeline里处理;
5. parse()方法作为回调函数(callback)赋值给了Request,指定parse()方法来处理这些请求 scrapy.Request(url, callback=self.parse)
6. Request对象经过调度,执行生成 scrapy.http.response()的响应对象,并送回给parse()方法,直到调度器中没有Request(递归的思路)
7. 取尽之后,parse()工作结束,引擎再根据队列和pipelines中的内容去执行相应的操作;
8. 程序在取得各个页面的items前,会先处理完之前所有的request队列里的请求,然后再提取items。
7. 这一切的一切,Scrapy引擎和调度器将负责到底。

五、Request对象

Request 部分源码:

# 部分代码
class Request(object_ref):

    def __init__(self, url, callback=None, method='GET', headers=None, body=None, 
                 cookies=None, meta=None, encoding='utf-8', priority=0,
                 dont_filter=False, errback=None):

        self._encoding = encoding  # this one has to be set first
        self.method = str(method).upper()
        self._set_url(url)
        self._set_body(body)
        assert isinstance(priority, int), "Request priority not an integer: %r" % priority
        self.priority = priority

        assert callback or not errback, "Cannot use errback without a callback"
        self.callback = callback
        self.errback = errback

        self.cookies = cookies or {}
        self.headers = Headers(headers or {}, encoding=encoding)
        self.dont_filter = dont_filter

        self._meta = dict(meta) if meta else None

    @property
    def meta(self):
        if self._meta is None:
            self._meta = {}
        return self._meta

其中,比较常用的参数:

url: 就是需要请求,并进行下一步处理的url

callback: 指定该请求返回的Response,由那个函数来处理。

method: 请求一般不需要指定,默认GET方法,可设置为"GET", "POST", "PUT"等,且保证字符串大写

headers: 请求时,包含的头文件。一般不需要。内容一般如下:
        # 自己写过爬虫的肯定知道
        Host: media.readthedocs.org
        User-Agent: Mozilla/5.0 (Windows NT 6.2; WOW64; rv:33.0) Gecko/20100101 Firefox/33.0
        Accept: text/css,*/*;q=0.1
        Accept-Language: zh-cn,zh;q=0.8,en-us;q=0.5,en;q=0.3
        Accept-Encoding: gzip, deflate
        Referer: http://scrapy-chs.readthedocs.org/zh_CN/0.24/
        Cookie: _ga=GA1.2.1612165614.1415584110;
        Connection: keep-alive
        If-Modified-Since: Mon, 25 Aug 2014 21:59:35 GMT
        Cache-Control: max-age=0

meta: 比较常用,在不同的请求之间传递数据使用的。字典dict型

        request_with_cookies = Request(
            url="http://www.example.com",
            cookies={'currency': 'USD', 'country': 'UY'},
            meta={'dont_merge_cookies': True}
        )

encoding: 使用默认的 'utf-8' 就行。

dont_filter: 表明该请求不由调度器过滤。这是当你想使用多次执行相同的请求,忽略重复的过滤器。默认为False。

errback: 指定错误处理函数

六、Response对象

# 部分代码
class Response(object_ref):
    def __init__(self, url, status=200, headers=None, body='', flags=None, request=None):
        self.headers = Headers(headers or {})
        self.status = int(status)
        self._set_body(body)
        self._set_url(url)
        self.request = request
        self.flags = [] if flags is None else list(flags)

    @property
    def meta(self):
        try:
            return self.request.meta
        except AttributeError:
            raise AttributeError("Response.meta not available, this response " \
                "is not tied to any request")

大部分参数和上面的差不多:

status: #响应码
_set_body(body): 响应体
_set_url(url):响应url
self.request = request

1、post模拟登录

方式一:解析登录请求参数发送请求登录

可以使用 yield scrapy.FormRequest(url, formdata, callback)方法发送POST请求。

# -*- coding: utf-8 -*-
import scrapy
import re

class GithubSpider(scrapy.Spider):
    name = 'github'
    allowed_domains = ['github.com']
    start_urls = ['https://github.com/login']

    def parse(self, response):
        #构造请求参数
        authenticity_token = response.xpath("//input[@name='authenticity_token']/@value").extract_first()
        utf8 = response.xpath("//input[@name='utf8']/@value").extract_first()
        commit = response.xpath("//input[@name='commit']/@value").extract_first()
        post_data = dict(
            login="121292679@qq.com",
            password="a546245426",
            authenticity_token=authenticity_token,
            utf8=utf8,
            commit=commit
        )
        yield scrapy.FormRequest(
            "https://github.com/session",
            formdata=post_data,
            callback=self.login_parse
        )

    def login_parse(self,response):
       
        print(re.findall("zengyanzhi",response.body.decode()))

方式二:通过预定义表单数据登录

使用FormRequest.from_response()方法模拟用户登录

通常网站通过 实现对某些表单字段(如数据或是登录界面中的认证令牌等)的预填充。

使用Scrapy抓取网页时,如果想要预填充或重写像用户名、用户密码这些表单字段, 可以使用 FormRequest.from_response() 方法实现。

import scrapy
import re


class Github2Spider(scrapy.Spider):
    name = 'github2'
    allowed_domains = ['github.com']
    start_urls = ['https://github.com/login']

    def parse(self, response):
        yield scrapy.FormRequest.from_response(
            response, #自动的从response中寻找from表单
            formdata={"login":"121292679@qq.com","password":"a546245426"},
            callback = self.after_login
        )

    def after_login(self,response):
        print(re.findall("zengyanzhi",response.body.decode()

方式三:通过重写strat_request方法,加入cookie请求登录后的页面

如果希望程序执行一开始就发送POST请求,可以重写Spider类的start_requests(self) 方法,并且不再调用start_urls里的url。

class mySpider(scrapy.Spider):
    name = 'github2'
    allowed_domains = ['github.com']
    start_urls = ['https://github.com/login']

    def start_requests(self):
        # FormRequest 是Scrapy发送POST请求的方法
        cookies = {''}  #cookies   字典的形式
        yield scrapy.Request(
            url = strat_url[0]
          	cookies=cookies
            callback = self.parse_login
        )
    def parse_login(self, response):
        print(re.findall("zengyanzhi",response.body.decode()
        

七、中间键

1、设置下载中间件

下载中间件(Downloader Middlewares)是处于引擎(crawler.engine)和下载器(crawler.engine.download())之间的一层组件,可以有多个下载中间件被加载运行。

  1. 当引擎传递请求给下载器的过程中,下载中间件可以对请求进行处理 (例如增加http header信息,增加proxy信息等);
  2. 在下载器完成http请求,传递响应给引擎的过程中, 下载中间件可以对响应进行处理(例如进行gzip的解压等)

要激活下载器中间件组件,将其加入到 DOWNLOADER_MIDDLEWARES 设置中。 该设置是一个字典(dict),键为中间件类的路径,值为其中间件的顺序(order)。

这里是一个例子:

DOWNLOADER_MIDDLEWARES = {
    'mySpider.middlewares.MyDownloaderMiddleware': 543,
}

编写下载器中间件十分简单。每个中间件组件是一个定义了以下一个或多个方法的Python类:

class scrapy.contrib.downloadermiddleware.DownloaderMiddleware

2、process_request(self, request, spider)

  • 当每个request通过下载中间件时,该方法被调用。
  • process_request() 必须返回以下其中之一:一个 None 、一个 Request 对象或 raise IgnoreRequest:
    • 如果其返回 None ,Scrapy将继续处理该request,执行其他的中间件的相应方法,直到合适的下载器处理函数(download handler)被调用, 该request被执行(其response被下载)。
    • 如果其返回 Request 对象,Scrapy则停止调用 process_request方法并重新调度返回的request。当新返回的request被执行后, 相应地中间件链将会根据下载的response被调用。
    • 如果其raise一个 IgnoreRequest 异常,则安装的下载中间件的 process_exception() 方法会被调用。如果没有任何一个方法处理该异常, 则request的errback(Request.errback)方法会被调用。如果没有代码处理抛出的异常, 则该异常被忽略且不记录(不同于其他异常那样)。
  • 参数:
    • request (Request 对象) – 处理的request
    • spider (Spider 对象) – 该request对应的spider

2、process_response(self, request, response, spider)

当下载器完成http请求,传递响应给引擎的时候调用

  • process_request() 必须返回以下其中之一: 返回一个 Response 对象、 返回一个 Request 对象或raise一个 IgnoreRequest 异常。
    • 如果其返回一个 Response (可以与传入的response相同,也可以是全新的对象), 该response会被在链中的其他中间件的 process_response() 方法处理。
    • 如果其返回一个 Request 对象,则中间件链停止, 返回的request会被重新调度下载。处理类似于 process_request() 返回request所做的那样。
    • 如果其抛出一个 IgnoreRequest 异常,则调用request的errback(Request.errback)。 如果没有代码处理抛出的异常,则该异常被忽略且不记录(不同于其他异常那样)。
  • 参数:
    • request (Request 对象) – response所对应的request
    • response (Response 对象) – 被处理的response
    • spider (Spider 对象) – response所对应的spider

2、设置随机代理和user-agnet

通过中间键设置代理

import random

class RandomUserAgentMiddleware:
    def process_request(self,request,spider):
        user_agnet = random.choice(spider.settings.get("USER_AGENTS_LIST"))
        request.headers["User-Agent"] = user_agnet


class PrintUserAgent:
    def process_response(self,request,response,spider):
        #打印Useragent
        print(request.headers["User-Agent"])
        return response

通过中间键设置user-agent


class RandomProxyMiddleware:
    def process_request(self,request,spider):
        #通过meta属性加入代理
        request.meta['proxy'] = 'http://129.232.22.9:8800'
       

八、CrawlSpiders

通过下面的命令可以快速创建 CrawlSpider模板 的代码:

scrapy genspider -t crawl tencent tencent.com

上一个案例中,我们通过正则表达式,制作了新的url作为Request请求参数,现在我们可以换个花样…

class scrapy.spiders.CrawlSpider

它是Spider的派生类,Spider类的设计原则是只爬取start_url列表中的网页,而CrawlSpider类定义了一些规则(rule)来提供跟进link的方便的机制,从爬取的网页中获取link并继续爬取的工作更适合。

CrawlSpider继承于Spider类,除了继承过来的属性外(name、allow_domains),还提供了新的属性和方法:

1、rules

CrawlSpider使用rules来决定爬虫的爬取规则,并将匹配后的url请求提交给引擎。所以在正常情况下,CrawlSpider不需要单独手动返回请求了。

在rules中包含一个或多个Rule对象,每个Rule对爬取网站的动作定义了某种特定操作,比如提取当前相应内容里的特定链接,是否对提取的链接跟进爬取,对提交的请求设置回调函数等。

如果多个rule匹配了相同的链接,则根据规则在本集合中被定义的顺序,第一个会被使用。

class scrapy.spiders.Rule(
        link_extractor,
        callback = None,
        cb_kwargs = None,
        follow = None,
        process_links = None,
        process_request = None
)
  • link_extractor:是一个Link Extractor对象,用于定义需要提取的链接。

  • callback: 从link_extractor中每获取到链接时,参数所指定的值作为回调函数,该回调函数接受一个response作为其第一个参数。

    注意:当编写爬虫规则时,避免使用parse作为回调函数。由于CrawlSpider使用parse方法来实现其逻辑,如果覆盖了 parse方法,crawl spider将会运行失败。

  • follow:是一个布尔(boolean)值,指定了根据该规则从response提取的链接是否需要跟进。 如果callback为None,follow 默认设置为True ,否则默认为False。

  • process_links:指定该spider中哪个的函数将会被调用,从link_extractor中获取到链接列表时将会调用该函数。该方法主要用来过滤。

  • process_request:指定该spider中哪个的函数将会被调用, 该规则提取到每个request时都会调用该函数。 (用来过滤request)

2、LinkExtractors

class scrapy.linkextractors.LinkExtractor

Link Extractors 的目的很简单: 提取链接。

每个LinkExtractor有唯一的公共方法是 extract_links(),它接收一个 Response 对象,并返回一个 scrapy.link.Link 对象。

Link Extractors要实例化一次,并且 extract_links 方法会根据不同的 response 调用多次提取链接。

class scrapy.linkextractors.LinkExtractor(
    allow = (),
    deny = (),
    allow_domains = (),
    deny_domains = (),
    deny_extensions = None,
    restrict_xpaths = (),
    tags = ('a','area'),
    attrs = ('href'),
    canonicalize = True,
    unique = True,
    process_value = None
)

主要参数:

  • allow:满足括号中“正则表达式”的URL会被提取,如果为空,则全部匹配。
  • deny:满足括号中“正则表达式”的URL一定不提取(优先级高于allow)。
  • allow_domains:会被提取的链接的domains。
  • deny_domains:一定不会被提取链接的domains。
  • restrict_xpaths:使用xpath表达式,和allow共同作用过滤链接。
#通过xpath获取到连接所在的标签,或scrapy自动获取
Rule(LinkExtractor(restrict_xpaths = '//table[@class="tablelist"]/tr/td/a'), callback='parse_item2', follow=False),

3、爬取规则(Crawling rules)

继续用腾讯招聘为例,给出配合rule使用CrawlSpider的例子:

  1. 首先运行

     scrapy shell "http://hr.tencent.com/position.php?&start=0#a"
    
  2. 导入LinkExtractor,创建LinkExtractor实例对象。:

     from scrapy.linkextractors import LinkExtractor
    
     page_lx = LinkExtractor(allow=('position.php?&start=\d+'))
    

    allow : LinkExtractor对象最重要的参数之一,这是一个正则表达式,必须要匹配这个正则表达式(或正则表达式列表)的URL才会被提取,如果没有给出(或为空), 它会匹配所有的链接。

    deny : 用法同allow,只不过与这个正则表达式匹配的URL不会被提取)。它的优先级高于 allow 的参数,如果没有给出(或None), 将不排除任何链接。

  3. 调用LinkExtractor实例的extract_links()方法查询匹配结果:

     page_lx.extract_links(response)
    
  4. 没有查到:

  5. 注意转义字符的问题,继续重新匹配:

     page_lx = LinkExtractor(allow=('position\.php\?&start=\d+'))
     # page_lx = LinkExtractor(allow = ('start=\d+'))
    
     page_lx.extract_links(response)
    

4、CrawlSpider 版本

那么,scrapy shell测试完成之后,修改以下代码

#提取匹配 'http://hr.tencent.com/position.php?&start=\d+'的链接
page_lx = LinkExtractor(allow = ('start=\d+'))

rules = [
    #提取匹配,并使用spider的parse方法进行分析;并跟进链接(没有callback意味着follow默认为True)
    Rule(page_lx, callback = 'parse', follow = True)
]

这么写对吗?

不对!千万记住 callback 千万不能写 parse,再次强调:由于CrawlSpider使用parse方法来实现其逻辑,如果覆盖了 parse方法,crawl spider将会运行失败。

import scrapy
from scrapy.linkextractors import LinkExtractor
from scrapy.spiders import CrawlSpider, Rule


class TecentSpider(CrawlSpider):
    name = 'tecent'
    allowed_domains = ['hr.tencent.com']
    start_urls = ['http://hr.tencent.com/position.php?&start=0']
    page_lx = LinkExtractor(allow=r'start=\d+')
    #position.php?&start=10#a
    rules = (
        Rule(page_lx, callback='parse_item', follow=True),
    )

    def parse_item(self, response):
        items = response.xpath('//*[contains(@class,"odd") or contains(@class,"even")]')
        for item in items:
            temp = dict(
                position=item.xpath("./td[1]/a/text()").extract()[0],
                detailLink="http://hr.tencent.com/" + item.xpath("./td[1]/a/@href").extract()[0],
                type=item.xpath('./td[2]/text()').extract()[0] if len(
                    item.xpath('./td[2]/text()').extract()) > 0 else None,
                need_num=item.xpath('./td[3]/text()').extract()[0],
                location=item.xpath('./td[4]/text()').extract()[0],
                publish_time=item.xpath('./td[5]/text()').extract()[0]
            )
            print(temp)
            yield temp

    # parse() 方法不需要重写     
    # def parse(self, response):                                              
    #     pass

运行: scrapy crawl tencent

5、crawlspider案列

瓜子二手车数据分品牌爬取

爬取目标,所有地区,所有车辆

爬取数据

车量信息:vehicle_info
上牌时间:ttime
地区:addr
价格:price
里程:mileage

参考案列:京东图书整站爬取

class JdSpider(scrapy.Spider):
    name = 'jd'
    allowed_domains = ['jd.com','p.3.cn']
    start_urls = ['https://book.jd.com/booksort.html']

    def parse(self, response):
        dt_list = response.xpath("//div[@class='mc']/dl/dt") #大分类列表
        for dt in dt_list:
            item = {}
            item["b_cate"] = dt.xpath("./a/text()").extract_first()
            em_list = dt.xpath("./following-sibling::dd[1]/em") #小分类列表
            for em in em_list:
                item["s_href"] = em.xpath("./a/@href").extract_first()
                item["s_cate"] = em.xpath("./a/text()").extract_first()
                if item["s_href"] is not None:
                    item["s_href"] = "https:" + item["s_href"]
                    yield scrapy.Request(
                        item["s_href"],
                        callback=self.parse_book_list,
                        meta = {"item":deepcopy(item)}
                    )

    def parse_book_list(self,response): #解析列表页
        item = response.meta["item"]
        li_list = response.xpath("//div[@id='plist']/ul/li")
        for li in li_list:
            item["book_img"] = li.xpath(".//div[@class='p-img']//img/@src").extract_first()
            if item["book_img"] is None:
                item["book_img"] = li.xpath(".//div[@class='p-img']//img/@data-lazy-img").extract_first()
            item["book_img"]="https:"+item["book_img"] if item["book_img"] is not None else None
            item["book_name"] = li.xpath(".//div[@class='p-name']/a/em/text()").extract_first().strip()
            item["book_author"] = li.xpath(".//span[@class='author_type_1']/a/text()").extract()
            item["book_press"]= li.xpath(".//span[@class='p-bi-store']/a/@title").extract_first()
            item["book_publish_date"] = li.xpath(".//span[@class='p-bi-date']/text()").extract_first().strip()
            item["book_sku"] = li.xpath("./div/@data-sku").extract_first()
            yield scrapy.Request(
                "https://p.3.cn/prices/mgets?skuIds=J_{}".format(item["book_sku"]),
                callback=self.parse_book_price,
                meta = {"item":deepcopy(item)}
            )

        #列表页翻页
        next_url = response.xpath("//a[@class='pn-next']/@href").extract_first()
        if next_url is not None:
            next_url = urllib.parse.urljoin(response.url,next_url)
            yield scrapy.Request(
                next_url,
                callback=self.parse_book_list,
                meta = {"item":item}
            )


    def parse_book_price(self,response):
        item = response.meta["item"]
        item["book_price"] = json.loads(response.body.decode())[0]["op"]
        print(item)

九、scrapy对接selenium

在之前的案例中我们通过scrapy来爬取的都是静态的html页面,那么如果遇到动态加载或者是发送请求无法直接获取数据的时候我们应该怎么办,在之前我们学习过了通过selenium来抓取动态加载的页面,如果我们要通过scrapy对接selenium,应该怎么做呢?

这个时候我们可以通过下载中间键键来处理,我们可以在下载中间键中自定义请求页面的方式,完成发起请求页面获取数据的过程,然后返回response,

创建好爬虫之后,打开middewares文件


from selenium import webdriver
from selenium.common.exceptions import TimeoutException
from scrapy.http import HtmlResponse
from selenium.webdriver.chrome.options import Options

class SeleniumMiddleware(object):
    def __init__(self):
        
        chrome_option = Options()
		#设为无头模式
		chrome_option.add_argument('-headless')
        #创建浏览器
		browser = webdriver.Chrome(chrome_options=chrome_option)

    def process_request(self, request, spider):
        try:
            #发送请求
            self.browser.get(request.url)
            #返回页面数据
            return HtmlResponse(url=request.url, body=self.browser.page_source, request=request, encoding='utf-8',status=200)
        except TimeoutException:
            #出现异常则返回异常信息
            return HtmlResponse(url=request.url, status=500, request=request)

    def __del__(self):
        #关闭浏览器
        self.browser.close()

十、setting相关配置项

# Crawl responsibly by identifying yourself (and your website) on the user-agent
#设置user-agent
USER_AGENT = 'github (+http://www.yourdomain.com)'

#是否开启roboots协议
# Obey robots.txt rules
ROBOTSTXT_OBEY = False

#设置最大的并发请求的数量
CONCURRENT_REQUESTS = 32

#设置同一个域名(网站)请求延迟时间
DOWNLOAD_DELAY = 3

#设置每个网站的最大并发请求数量
CONCURRENT_REQUESTS_PER_DOMAIN = 16

#设置每个IP的最大并发请求数量
CONCURRENT_REQUESTS_PER_IP = 16

#禁用cookie
COOKIES_ENABLED = False

#禁用远程控制台
TELNETCONSOLE_ENABLED = False

#设置默认的请求头
DEFAULT_REQUEST_HEADERS = {
   'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
   'Accept-Language': 'en',
   "User-Agent": "Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3538.110 Safari/537.36"
}

#启用爬虫中间件
 SPIDER_MIDDLEWARES = {
    'github.middlewares.GithubSpiderMiddleware': 543,
 }

#启用下载中间件
DOWNLOADER_MIDDLEWARES = {
   'github.middlewares.GitDownloaderMiddleware': 543,
   'github.middlewares.GitProxy':566
}

#启用item_pipelines管道
ITEM_PIPELINES = {
    'github.pipelines.GithubPipeline': 300,
}


#初始下载延迟时间
AUTOTHROTTLE_START_DELAY = 5

#设置的最大下载延迟的时间
AUTOTHROTTLE_MAX_DELAY = 60

#Http缓存的配置
#HTTPCACHE_ENABLED = True
#HTTPCACHE_EXPIRATION_SECS = 0
#HTTPCACHE_DIR = 'httpcache'
#HTTPCACHE_IGNORE_HTTP_CODES = []
#HTTPCACHE_STORAGE = 'scrapy.extensions.httpcache.FilesystemCacheStorage'

十一、scrapy-redis实现分布式爬虫

1、安装scrapy-redis

pip install scrapy-redis

2、使用scrapy-redis实现分布式

1、创建项目
scrapy startproject 项目名
2、创建爬虫
scrapy genspider  爬虫名  域名
3、修改settings中配置
#确保所有爬虫通过redis共享相同的重复过滤器。
DUPEFILTER_CLASS = "scrapy_redis.dupefilter.RFPDupeFilter"
#在redis中启用调度存储请求队列。
SCHEDULER = "scrapy_redis.scheduler.Scheduler"
#不要清理redis队列,允许暂停/恢复抓取。
SCHEDULER_PERSIST = True
#指定redir服务器的地址
REDIS_URL = "redis://192.168.0.103:6379"
4、修改爬虫的继承类
方式一:scrapy.Spider类的爬虫
#从scrapy_redis.spiders导入RedisSpider这个类
from scrapy_redis.spiders import RedisSpider

#修改爬虫的继承类
class XXXSpider(RedisSpider):
    name = 'xx'
    allowed_domains = ['XX.com']
    #把strat_url注释
    # start_urls = ['xxxxx']
    
    #设置该爬虫在redis中的键名,一般选择用爬虫名
    redis_key = "爬虫名"
   
	#其他部分没有任何变化还是和原来一样的写法
    
    

方式二:CrawlSpider类型爬虫
#从scrapy_redis.spiders导入RedisSpider这个类
from scrapy_redis.spiders import RedisCrawlSpider
#修改爬虫的继承类
class AmazonSpider(RedisCrawlSpider):
    name = 'XXX'
    allowed_domains = ['xxx.cn']
    #把strat_url注释
    # start_urls = ['xxxxxxxx']
    
    #设置该爬虫在redis中的键名,一般选择用爬虫名
    redis_key = "xxx"
    
    rules = (
        Rule(LinkExtractor(restrict_xpaths=("",)), follow=True),
    )
    #其他部分没有任何变化还是和原来一样的写法

5、启动爬虫
scrapy crawl 爬虫名
6、在redis中插入爬虫的start_url地址

启动爬虫之后爬虫没有start_url地址,并不会直接运行,需要我们在redis中往redis_key这个键中加入进去第一条url地址,这个时候爬虫才会开始运行

#进入redis中
lpush  redis_key的值   初始的url地址

#例:爬虫类中的redis_key为:gauzi  第一个需要请求的url为:https://www.guazi.com/cs/buy

127.0.0.1:6369> lpush guazi https://www.guazi.com/cs/buy/

当在redis中加入上述的url地址之后 我们的爬虫会立马开始执行

爬虫启动后 keys * 查看redis 数据库中的键

192.168.0.103:6379> keys *
1) "guazi:dupefilter"
2) "guazi:requests"

guazi:dupefilter :集合类型(set)

里面存放点的是所有往调度器中添加的所有url指纹数据

#查看所有元素
smembers guazi:dupefilter
#查看元素个数
scard guazi:dupefilter

guazi:requests:有序集合类型(zset)

里面存放的是所有request请求的对象(经过处理过的)

#查看所有元素
zrange guazi:requests start stop
zcard guazi:requests

扩展:scrapy-redis关于url的去重原理

对于每一个url的请求,调度器都会根据请求得相关信息加密得到一个指纹信息,

并且将指纹信息和set()集合中的指纹信息进行比对,

如果set()集合中已经存在这个数据,就不在将这个Request放入队列中。

如果set()集合中没有存在这个加密后的数据,就将这个Request对象放入队列中,等待被调度

十二、反反爬虫相关机制

(有些些网站使用特定的不同程度的复杂性规则防止爬虫访问,绕过这些规则是困难和复杂的,有时可能需要特殊的基础设施,如果有疑问,请联系商业支持。)

来自于Scrapy官方文档描述:http://doc.scrapy.org/en/master/topics/practices.html#avoiding-getting-banned

通常防止爬虫被反主要有以下几个策略:

一.BAN IP

网页的运维人员通过分析日志发现最近某一个IP访问量特别特别大,某一段时间内访问了无数次的网页,则运维人员判断此种访问行为并非正常人的行为,于是直接在服务器上封杀了此人IP(我刚爬取的网站的维护人员可能对我实施了这种手段…)。

解决方法:此种方法极其容易误伤其他正常用户,因为某一片区域的其他用户可能有着相同的IP,导致服务器少了许多正常用户的访问,所以一般运维人员不会通过此种方法来限制爬虫。不过面对许多大量的访问,服务器还是会偶尔把该IP放入黑名单,过一段时间再将其放出来,但我们可以通过分布式爬虫以及购买代理IP也能很好的解决,只不过爬虫的成本提高了。

二.BAN USERAGENT

很多的爬虫请求头就是默认的一些很明显的爬虫头python-requests/2.18.4,诸如此类,当运维人员发现携带有这类headers的数据包,直接拒绝访问,返回403错误

解决方法:直接r=requests.get(url,headers={‘User-Agent’:‘XXXspider’})把爬虫请求headers伪装成其他爬虫或者其他浏览器头就行了。

案例:雪球网

三.BAN COOKIES

服务器对每一个访问网页的人都set-cookie,给其一个cookies,当该cookies访问超过某一个阀值时就BAN掉该COOKIE,过一段时间再放出来,当然一般爬虫都是不带COOKIE进行访问的,可是网页上有一部分内容如新浪微博是需要用户登录才能查看更多内容(我已经中招了)。

解决办法:控制访问速度,或者某些需要登录的如新浪微博,在某宝上买多个账号,生成多个cookies,在每一次访问时带上cookies

案例:蚂蜂窝

四.验证码验证

当某一用户访问次数过多后,就自动让请求跳转到一个验证码页面,只有在输入正确的验证码之后才能继续访问网站

解决办法:python可以通过一些第三方库如(pytesser,PIL)来对验证码进行处理,识别出正确的验证码,复杂的验证码可以通过机器学习让爬虫自动识别复杂验证码,让程序自动识别验证码并自动输入验证码继续抓取

五.javascript渲染

网页开发者将重要信息放在网页中但不写入html标签中,而浏览器会自动渲染

解决办法:通过分析提取script中的js代码来通过正则匹配提取信息内容或通过webdriver+phantomjs直接进行无头浏览器渲染网页。

案例:前程无忧网

随便打开一个前程无忧工作界面,直接用requests.get对其进行访问,可以得到一页的20个左右数据,显然得到的不全,而用webdriver访问同样的页面可以得到50个完整的工作信息。

六.ajax异步传输

访问网页的时候服务器将网页框架返回给客户端,在与客户端交互的过程中通过异步ajax技术传输数据包到客户端,呈现在网页上,爬虫直接抓取的话信息为空

解决办法:通过fiddler或是wireshark抓包分析ajax请求的界面,然后自己通过规律仿造服务器构造一个请求访问服务器得到返回的真实数据包。

案例:拉勾网

打开拉勾网的某一个工作招聘页,可以看到许许多多的招聘信息数据,点击下一页后发现页面框架不变化,url地址不变,而其中的每个招聘数据发生了变化,通过chrome开发者工具抓包找到了一个叫请求了一个叫做http://www.lagou.com/zhaopin/Java/2/?filterOption=3的网页,打开改网页发现为第二页真正的数据源,通过仿造请求可以抓取每一页的数据。

  • 0
    点赞
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值