Python爬虫笔记（九）——Scrapy官方文档阅读——Itemloader

 

什么是itemloader

Itemloader提供了一种机制，可以很方便的填充item

使用ItemLoader填充item

首先需要初始化Itemloader，可以用字典或是item作为构造函数的参数，如果没有指定，Itemloader会自己自动初始化一个item（对应属性ItemLoader.default_item_class），下面是一个使用例子（使用之前构造好的Product类）：

from scrapy.loader import ItemLoader
from myproject.items import Product

def parse(self, response):
    l = ItemLoader(item=Product(), response=response)
    l.add_xpath('name', '//div[@class="product_name"]')
    l.add_xpath('name', '//div[@class="product_title"]')
    l.add_xpath('price', '//p[@id="price"]')
    l.add_css('stock', 'p#stock]')
    l.add_value('last_updated', 'today') # you can also use literal values
    return l.load_item()

最后，需要使用load_item（）方法返回item

输入和输出进程

Itemloader对于item的每一个Field都包含有一个输入进程和一个输出进程，当爬虫提取到数据后（通过前面提到的add_xpath()等方法），会调用输入进程。输入进程处理的结果将被保存（此时并未保存到item中），当调用load_item函数时，将会通过输出进程获得之前保存的填充的值，然后由load_item函数内部的逻辑进行item的填充，返回item，这里说的进程（包括下面说的）只是一个可调用模块，因此我们可以使用函数，但是函数必须接收一个迭代器

输入和输出进程的定义

可以定义在itemloader的定义中：

from scrapy.loader import ItemLoader
from scrapy.loader.processors import TakeFirst, MapCompose, Join

class ProductLoader(ItemLoader):

    default_output_processor = TakeFirst()

    name_in = MapCompose(unicode.title)
    name_out = Join()

    price_in = MapCompose(unicode.strip)

    # ...

_in后缀定义输入进程，_out后缀定义输出进程，ItemLoader.default_input_processor 与ItemLoader.default_output_processor属性表示默认的输入与输出进程，在定义item的field时，也可以指定输出与输入进程：

import scrapy
from scrapy.loader.processors import Join, MapCompose, TakeFirst
from w3lib.html import remove_tags

def filter_price(value):
    if value.isdigit():
        return value

class Product(scrapy.Item):
    name = scrapy.Field(
        input_processor=MapCompose(remove_tags),
        output_processor=Join(),
    )
    price = scrapy.Field(
        input_processor=MapCompose(remove_tags, filter_price),
        output_processor=TakeFirst(),
    )

由于定义输入与输出进程的方式有许多种，这些方式对应的优先级如下：

1、itemloader子类定义的_in和_out属性

2、Field方法声明的输入与输出进程

3、itemloader默认的输入输出进程

Item Loader的上下文

Item Loader的上下文是一个字典，可在输入与输出进程之间共享任意的键值对，相当于信息的共享区域，用于修改输入输出处理器的行为（这个东西文档本身解释也不是很清楚）

当我们的自定函数接收一个名为loader_context的参数时，Scrapy会自动将目前使用的上下文传递给loader_context

有三种方式可以修正item_loader上下文的值：

1、使用itemloader的context属性：

loader = ItemLoader(product)
loader.context['unit'] = 'cm'

2、初始化itemloader时：

loader = ItemLoader(product, unit='cm')

3、itemloader子类定义输入输出进程时：

class ProductLoader(ItemLoader):
    length_out = MapCompose(parse_length, unit='cm')

ItemLoader对象的API

一、__init__：初始化一个itemloader对象，可选参数：

       item：需要填充的item，selector（selector对象）：选择器，当使用add_xpath()、add_css()、add_value()时，使用selector提取数据，response（response对象）：若没有指定selector，response用于构建选择器，相当于选择器作用的对象，若没有指定selector，将使用default_selector_class

二、get_value(value, *processors, **kwargs)

       value通过processors和kwargs的处理后返回value，例子：  

>>> from scrapy.loader.processors import TakeFirst
>>> loader.get_value(u'name: foo', TakeFirst(), unicode.upper, re='name: (.+)')
'FOO`

三、add_value（field_name,value,*processors,**kwargs）

       将value通过*processors和**kwargs的处理后，添加到field_name区域，如果field_name区域早就存在了对应数据，新的数据将会覆盖旧的数据，field_name可以是None，但是value必须是字典，例子：

loader.add_value('name', u'Color TV')
loader.add_value('colours', [u'white', u'blue'])
loader.add_value('length', u'100')
loader.add_value('name', u'name: foo', TakeFirst(), re='name: (.+)')
loader.add_value(None, {'name': u'foo', 'sex': u'male'})

四、replace_value（field_name,value,*processors,**kwargs）

       和add_value（）类似，但是是替换已经存储的数据

五、get_xpath(xpath,*processors,**kwargs)

       传递给selector属性，然后使用这个spath提取数据，经过*processors和**kwargs的处理后返回，例子：

# HTML snippet: <p class="product-name">Color TV</p>
loader.get_xpath('//p[@class="product-name"]')
# HTML snippet: <p id="price">the price is $1200</p>
loader.get_xpath('//p[@id="price"]', TakeFirst(), re='the price is (.*)')

六、add_xpath(xpath,*processors,**kwargs)

       和add_value（）类似，不过是使用xpath提取数据后在处理保存，例子：

# HTML snippet: <p class="product-name">Color TV</p>
loader.add_xpath('name', '//p[@class="product-name"]')
# HTML snippet: <p id="price">the price is $1200</p>
loader.add_xpath('price', '//p[@id="price"]', re='the price is (.*)')

 

七、replace_xpath(field_name,xpath,*processors,**kwargs)

       和add_xpath（）类似，但是会替换field_name的值

八、get_css（css，*processors，**kwargs）

       和get_value类似，但是接收的是css选择器，例子：

# HTML snippet: <p class="product-name">Color TV</p>
loader.get_css('p.product-name')
# HTML snippet: <p id="price">the price is $1200</p>
loader.get_css('p#price', TakeFirst(), re='the price is (.*)')

九、add_css（field_name，css，*processors，**kwargs）

       使用css选择器去提取数据，通过processors和kwargs的处理后，存储到field_name

# HTML snippet: <p class="product-name">Color TV</p>
loader.add_css('name', 'p.product-name')
# HTML snippet: <p id="price">the price is $1200</p>
loader.add_css('price', 'p#price', re='the price is (.*)')

十、replace_css（field_name，css，*processors，**kwargs）

       和add_css（）类似，但是是替换而不是添加

十一、load_item（）

           用之前存储的数据（通过输出进程返回）填充item

十二、nested_xpath（xpath）

           根据xpath选择器创建Nested Loaders类的实例，该实例与调用者ItemLoader的item共用

十三、nested_css(css)

           根据css选择器创建Nested Loaders类的实例，该实例与调用者ItemLoader的item共用

十四、get_collected_values（field_name）

           返回field_name对应的存储区存储的值

十五、get_output_value(field_name)

           将field_name对应的存储区域存储的值经过输出进程处理后返回

十六、get_input_processor(field_name)

           返回field_name对应的输入进程

十七、get_output_processor(field_name)

           返回field_name对应的输出进程

Itemloader有如下属性：

1、item，2、context

3、default_item_class：当没有给定item时，使用这个属性实例化一个item

4、default_input_processor：默认的输入进程

5、default_output_processor：默认的输出进程

6、default_selector_class:当没有指定选择器时，使用这个属性构建选择器

7、selecor：用于提取数据的选择器

Nested Loaders

当提取的数据集中在html文档的一部分时，为了防止代码重复太多，使用Nested Loaders即可：

<footer>
    <a class="social" href="https://facebook.com/whatever">Like Us</a>
    <a class="social" href="https://twitter.com/whatever">Follow Us</a>
    <a class="email" href="mailto:[email protected]">Email Us</a>
</footer>

我们想提取上述例子的a元素的href属性的值

loader = ItemLoader(item=Item())
# load stuff not in the footer
loader.add_xpath('social', '//footer/a[@class = "social"]/@href')
loader.add_xpath('email', '//footer/a[@class = "email"]/@href')
loader.load_item()

可以看到有一部分代码重复了，如果footer在html文档树的较深处，为了提取a元素的href，将会有大量重复的xpath需要书写，这个时候可以使用nested— loader：

loader = ItemLoader(item=Item())
# load stuff not in the footer
footer_loader = loader.nested_xpath('//footer')
footer_loader.add_xpath('social', 'a[@class = "social"]/@href')
footer_loader.add_xpath('email', 'a[@class = "email"]/@href')
# no need to call footer_loader.load_item()
loader.load_item()

Itemloader允许被继承并覆盖其中的某些属性和方法

Scrapy自定义的可使用的输入输出进程

scrapy.loader.processors.Identity：最简单的进程，不做任何事，只是简单的返回接收到的值，构造它不需要任何参数

>>> from scrapy.loader.processors import Identity
>>> proc = Identity()
>>> proc(['one', 'two', 'three'])
['one', 'two', 'three']

scrapy.loader.processors.TakeFirst：返回迭代器中第一个不为null，不为空的值，构造它不需要任何参数

>>> from scrapy.loader.processors import TakeFirst
>>> proc = TakeFirst()
>>> proc(['', 'one', 'two', 'three'])
'one'

scrapy.loader.processors.Join：根据构造函数中给出的分割符（如果不指定，默认为空格），连接迭代器的各种值

>>> from scrapy.loader.processors import Join
>>> proc = Join()
>>> proc(['one', 'two', 'three'])
u'one two three'
>>> proc = Join('<br>')
>>> proc(['one', 'two', 'three'])
u'one<br>two<br>three'

scrapy.loader.processors.Compose(*functions,**default_loader_context)：一系列函数组成的处理器，第一个函数处理的结果会交给第二个函数处理。直到最后一个函数处理完，默认情况下，处理器处理到None时会停止，将stop_on_none置为False可以防止这种情况出现，default_loader_context用做上下文，由itemloader.context（）给定，用于多个函数之间信息的共享

>>> from scrapy.loader.processors import Compose
>>> proc = Compose(lambda v: v[0], str.upper)
>>> proc(['hello', 'world'])
'HELLO'

scrapy.loader.processors.MapCompose(*functions,**default_loader_context)：和Compose类似，但是内部处理方式不一样，对于输入的迭代器，第一个函数应用于所有迭代器的值，所有值经过处理后，组织成新的迭代器，交给第二个函数，依次进行下去，每个函数可以返回一个值，也可以返回一个列表，也可以返回None，这也意味着函数处理链后续不会处理对应的值：

>>> def filter_world(x):
...     return None if x == 'world' else x
...
>>> from scrapy.loader.processors import MapCompose
>>> proc = MapCompose(filter_world, unicode.upper)
>>> proc([u'hello', u'world', u'this', u'is', u'scrapy'])
[u'HELLO, u'THIS', u'IS', u'SCRAPY']

MapCompose常用做输入进程，default_loader_context用做上下文，由itemloader.context（）给定，用于多个函数之间信息的共享

scrapy.loader.processors.SelectJmes(json_path)：从给定的json路径开始查询，返回对应的值，需要运行jmespath，该处理器一次只需要一个输入：

>>> from scrapy.loader.processors import SelectJmes, Compose, MapCompose
>>> proc = SelectJmes("foo") #for direct use on lists and dictionaries
>>> proc({'foo': 'bar'})
'bar'
>>> proc({'foo': {'bar': 'baz'}})
{'bar': 'baz'}

上述例子将从foo开始查询，获取其中的值

使用json模块：

>>> import json
>>> proc_single_json_str = Compose(json.loads, SelectJmes("foo"))
>>> proc_single_json_str('{"foo": "bar"}')
u'bar'
>>> proc_json_list = Compose(json.loads, MapCompose(SelectJmes('foo')))
>>> proc_json_list('[{"foo":"bar"}, {"baz":"tar"}]')
[u'bar']