目錄

專案載入器

巢狀裝載器

開發環境： 
Python 3.6.0 版本 （當前最新） 
Scrapy 1.3.2 版本 （當前最新）

專案載入器

專案載入器提供了一種方便的機制來填充抓取的專案。即使可以使用自己的類似字典的API填充專案，專案載入器提供了一個更方便的API，通過自動化一些常見的任務，如解析原始提取的資料，然後分配它從剪貼過程中填充他們。

換句話說，Items提供了抓取資料的容器，而Item Loader提供了填充該容器的機制。

專案載入器旨在提供一種靈活，高效和容易的機制，通過爬蟲或源格式（HTML，XML等）擴充套件和覆蓋不同的欄位解析規則，而不會成為維護的噩夢。

使用裝載機專案來填充的專案

要使用專案載入器，您必須首先例項化它。您可以使用類似dict的物件（例如Item或dict）例項化它，也可以不使用它，在這種情況下，專案將在Item Loader建構函式中使用屬性中指定的Item類自動ItemLoader.default_item_class 例項化。

然後，您開始收集值到項裝載程式，通常使用選擇器。您可以向同一專案欄位新增多個值; 專案載入器將知道如何使用適當的處理函式“加入”這些值。

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()
 

通過快速檢視該程式碼，我們可以看到該name欄位正從頁面中兩個不同的XPath位置提取：

1. //div[@class="product_name"]
2. //div[@class="product_title"] 
   換句話說，通過使用add_xpath()方法從兩個XPath位置提取資料來收集資料。這是稍後將分配給name欄位的資料。

之後，類似的呼叫用於price和stock欄位（後者使用帶有add_css()方法的CSS選擇器），最後使用不同的方法last_update直接使用文字值（today）填充欄位add_value()。

最後，收集的所有資料時，該ItemLoader.load_item()

方法被稱為實際上返回填充先前提取並與收集到的資料的專案add_xpath()， add_css()和add_value()呼叫。

輸入和輸出處理器

專案載入器對於每個（專案）欄位包含一個輸入處理器和一個輸出處理器。輸入處理器只要它的接收處理所提取的資料（通過add_xpath()，add_css()或 add_value()方法）和輸入處理器的結果被收集並保持ItemLoader內部。收集所有資料後，ItemLoader.load_item()呼叫該 方法來填充和獲取填充 Item物件。這是當輸出處理器使用先前收集的資料（並使用輸入處理器處理）呼叫時。輸出處理器的結果是分配給專案的最終值。

讓我們看一個例子來說明如何為特定欄位呼叫輸入和輸出處理器（同樣適用於任何其他欄位）：

l = ItemLoader(Product(), some_selector)
l.add_xpath('name', xpath1) # (1)
l.add_xpath('name', xpath2) # (2)
l.add_css('name', css) # (3)
l.add_value('name', 'test') # (4)
return l.load_item() # (5)

所以會發生什麼：

1. 從資料xpath1提取出來，並通過所傳遞的輸入處理器的的name欄位。輸入處理器的結果被收集並儲存在專案載入器中（但尚未分配給專案）。
2. 從中xpath2提取資料，並通過（1）中使用的同一輸入處理器。輸入處理器的結果附加到（1）中收集的資料（如果有）。
3. 這種情況類似於先前的情況，除了資料從cssCSS選擇器提取，並且通過在（1）和（2）中使用的相同的輸入處理器。輸入處理器的結果附加到在（1）和（2）中收集的資料（如果有的話）。
4. 這種情況也與之前的類似，除了要收集的值直接分配，而不是從XPath表示式或CSS選擇器中提取。但是，該值仍然通過輸入處理器。在這種情況下，由於該值不可迭代，因此在將其傳遞給輸入處理器之前，它將轉換為單個元素的可迭代，因為輸入處理器總是接收迭代。
5. 在步驟（1），（2），（3）和（4）中收集的資料通過name欄位的輸出處理器。輸出處理器的結果是分配給name 專案中欄位的值。

值得注意的是，處理器只是可呼叫物件，它們使用要解析的資料呼叫，並返回解析的值。所以你可以使用任何功能作為輸入或輸出處理器。唯一的要求是它們必須接受一個（也只有一個）位置引數，這將是一個迭代器。

注意

輸入和輸出處理器都必須接收一個迭代器作為它們的第一個引數。這些函式的輸出可以是任何東西。輸入處理器的結果將附加到包含收集的值（對於該欄位）的內部列表（在載入程式中）。輸出處理器的結果是最終分配給專案的值。

另一件需要記住的事情是，輸入處理器返回的值在內部（在列表中）收集，然後傳遞到輸出處理器以填充欄位。

最後，但並非最不重要的是，Scrapy自帶一些常用的處理器內建的方便。

宣告專案載入器

專案載入器通過使用類定義語法宣告為Items。這裡是一個例子：

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 Loader定義中宣告，這種方式宣告輸入處理器是很常見的。但是，還有一個地方可以指定要使用的輸入和輸出處理器：在專案欄位 元資料中。這裡是一個例子：

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(),
    )

>>> from scrapy.loader import ItemLoader
>>> il = ItemLoader(item=Product())
>>> il.add_value('name', [u'Welcome to my', u'<strong>website</strong>'])
>>> il.add_value('price', [u'&euro;', u'<span>1000</span>'])
>>> il.load_item()
{'name': u'Welcome to my website', 'price': u'1000'}

輸入和輸出處理器的優先順序順序如下：

1. 專案載入程式欄位特定屬性：field_in和field_out（最高優先順序）
2. 欄位元資料（input_processor和output_processor鍵）
3. 專案載入器預設值：ItemLoader.default_input_processor()和 ItemLoader.default_output_processor()（最低優先順序）

專案載入器上下文

專案載入器上下文是在專案載入器中的所有輸入和輸出處理器之間共享的任意鍵/值的dict。它可以在宣告，例項化或使用Item Loader時傳遞。它們用於修改輸入/輸出處理器的行為。

例如，假設您有一個parse_length接收文字值並從中提取長度的函式：

def  parse_length （text ， loader_context ）：
    unit  =  loader_context 。get （'unit' ， 'm' ）
    ＃...長度解析程式碼在這裡... 
    return  parsed_length

通過接受一個loader_context引數，該函式顯式地告訴Item Loader它能夠接收一個Item Loader上下文，因此Item Loader在呼叫它時傳遞當前活動的上下文，因此處理器功能（parse_length在這種情況下）可以使用它們。

有幾種方法可以修改Item Loader上下文值：

1. 通過修改當前活動的Item Loader上下文（context屬性）：

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

2. On Item Loader例項化（Item Loader建構函式的關鍵字引數儲存在Item Loader上下文中）：

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

3. On Item Loader宣告，對於那些支援使用Item Loader上下文例項化的輸入/輸出處理器。MapCompose是其中之一：

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

ItemLoader物件

class scrapy.loader.ItemLoader([item, selector, response, ]**kwargs)

• 1

返回一個新的Item Loader來填充給定的Item。如果沒有給出專案，則使用中的類自動例項化 default_item_class。

當使用選擇器或響應引數例項化時，ItemLoader類提供了使用選擇器從網頁提取資料的方便的機制。

引數：

• item（Item物件）-專案例項來填充用以後呼叫 add_xpath()，add_css()或add_value()。
• selector（Selectorobject） - 當使用add_xpath()（或。add_css()）或replace_xpath() （或replace_css()）方法時，從中提取資料的選擇器 。
• response（Responseobject） - 用於使用構造選擇器的響應 default_selector_class，除非給出選擇器引數，在這種情況下，將忽略此引數。 
  專案，選擇器，響應和剩餘的關鍵字引數被分配給Loader上下文（可通過context屬性訪問）。

ItemLoader 例項有以下方法：

get_value（value，* processors，** kwargs ） 
處理給定value的給定processors和關鍵字引數。

可用的關鍵字引數：

引數： re（str 或compiled regex） 
一個正則表示式extract_regex()，用於使用方法從給定值提取資料，在處理器之前應用 
例子：

>>> 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定欄位的給定。

該值首先通過get_value()賦予 processors和kwargs，然後通過 欄位輸入處理器及其結果追加到為該欄位收集的資料。如果欄位已包含收集的資料，則會新增新資料。

給定field_name可以是None，在這種情況下可以新增多個欄位的值。並且已處理的值應為一個欄位，其中field_name對映到值。

例子：

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 ） 
類似於ItemLoader.get_value()但接收XPath而不是值，用於從與此相關聯的選擇器提取unicode字串的列表ItemLoader。

引數：

• xpath（str） - 從中​​提取資料的XPath
• re（str 或compiled regex） - 用於從所選XPath區域提取資料的正則表示式 
  例子：

# 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（field_name，xpath，* processor，** kwargs ） 
類似於ItemLoader.add_value()但接收XPath而不是值，用於從與此相關聯的選擇器提取unicode字串的列表ItemLoader。

見get_xpath()的kwargs。

引數： 
xpath（str） - 從中​​提取資料的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，* processor，** kwargs ） 
類似於add_xpath()但替換收集的資料，而不是新增它。

get_css（css，* processors，** kwargs ） 
類似於ItemLoader.get_value()但接收一個CSS選擇器而不是一個值，用於從與此相關的選擇器提取一個unicode字串列表ItemLoader。

引數：

• css（str） - 從中​​提取資料的CSS選擇器
• re（str 或compiled regex） - 用於從所選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 ） 
類似於ItemLoader.add_value()但接收一個CSS選擇器而不是一個值，用於從與此相關的選擇器提取一個unicode字串列表ItemLoader。

見get_css()的kwargs。

引數： 
css（str） - 從中​​提取資料的CSS選擇器 
例子：

# 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（） 
使用目前收集的資料填充專案，並返回。收集的資料首先通過輸出處理器，以獲得要分配給每個專案欄位的最終值。

nested_xpath（xpath ） 
使用xpath選擇器建立巢狀載入器。所提供的選擇器應用於與此相關的選擇器ItemLoader。巢狀裝載機股份Item 與母公司ItemLoader這麼呼叫add_xpath()， add_value()，replace_value()等會像預期的那樣。

nested_css（css ） 
使用css選擇器建立巢狀載入器。所提供的選擇器應用於與此相關的選擇器ItemLoader。巢狀裝載機股份Item 與母公司ItemLoader這麼呼叫add_xpath()， add_value()，replace_value()等會像預期的那樣。

get_collected_values（field_name ） 
返回給定欄位的收集值。

get_output_value（field_name ） 
返回給定欄位使用輸出處理器解析的收集值。此方法根本不填充或修改專案。

get_input_processor（field_name ） 
返回給定欄位的輸入處理器。

get_output_processor（field_name ） 
返回給定欄位的輸出處理器。

ItemLoader 例項具有以下屬性：

item 
Item此專案載入器解析的物件。

context 
此專案Loader 的當前活動上下文。

default_item_class 
Item類（或工廠），用於在建構函式中未給出時例項化項。

default_input_processor 
用於不指定一個欄位的欄位的預設輸入處理器。

default_output_processor 
用於不指定一個欄位的欄位的預設輸出處理器。

default_selector_class 
所使用的類構造selector的此 ItemLoader，如果只響應在建構函式給出。如果在建構函式中給出了選擇器，則忽略此屬性。此屬性有時在子類中被覆蓋。

selector 
Selector從中提取資料的物件。它是在建構函式中給出的選擇器，或者是從建構函式中使用的給定的響應建立的 default_selector_class。此屬性意味著是隻讀的。

巢狀裝載器

當解析來自文件的子部分的相關值時，建立巢狀載入器可能是有用的。假設您從頁面的頁尾中提取細節，看起來像：

例：

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

如果沒有巢狀載入器，則需要為要提取的每個值指定完整的xpath（或css）。

例：

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()

相反，您可以使用頁尾選擇器建立巢狀載入器，並相對於頁尾新增值。功能是相同的，但您避免重複頁尾選擇器。

例：

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()

您可以任意巢狀載入器，並且可以使用xpath或css選擇器。作為一般的指導原則，當他們使你的程式碼更簡單，但不要超越巢狀或使用解析器可能變得難以閱讀使用巢狀載入程式。

重用和擴充套件專案載入器

隨著你的專案越來越大，越來越多的爬蟲，維護成為一個根本的問題，特別是當你必須處理每個爬蟲的許多不同的解析規則，有很多異常，但也想重用公共處理器。

專案載入器旨在減輕解析規則的維護負擔，同時不會失去靈活性，同時提供了擴充套件和覆蓋它們的方便的機制。因此，專案載入器支援傳統的Python類繼承，以處理特定爬蟲（或爬蟲組）的差異。

例如，假設某個特定站點以三個短劃線（例如）包含其產品名稱，並且您不希望最終在最終產品名稱中刪除那些破折號。—Plasma TV—

以下是如何通過重用和擴充套件預設產品專案Loader（ProductLoader）來刪除這些破折號：

from scrapy.loader.processors import MapCompose
from myproject.ItemLoaders import ProductLoader

def strip_dashes(x):
    return x.strip('-')

class SiteSpecificLoader(ProductLoader):
    name_in = MapCompose(strip_dashes, ProductLoader.name_in)

另一種擴充套件專案載入器可能非常有用的情況是，當您有多種源格式，例如XML和HTML。在XML版本中，您可能想要刪除CDATA事件。下面是一個如何做的例子：

from scrapy.loader.processors import MapCompose
from myproject.ItemLoaders import ProductLoader
from myproject.utils.xml import remove_cdata

class XmlProductLoader(ProductLoader):
    name_in = MapCompose(remove_cdata, ProductLoader.name_in)

這就是你通常擴充套件輸入處理器的方式。

對於輸出處理器，更常見的是在欄位元資料中宣告它們，因為它們通常僅依賴於欄位而不是每個特定站點解析規則（如輸入處理器）。另請參見： 宣告輸入和輸出處理器。

還有許多其他可能的方法來擴充套件，繼承和覆蓋您的專案載入器，不同的專案載入器層次結構可能更適合不同的專案。Scrapy只提供了機制; 它不強加任何特定的組織你的Loader集合 - 這取決於你和你的專案的需要。

可用內建處理器

即使您可以使用任何可呼叫函式作為輸入和輸出處理器，Scrapy也提供了一些常用的處理器，如下所述。其中一些，像MapCompose（通常用作輸入處理器）組成按順序執行的幾個函式的輸出，以產生最終的解析值。

下面是所有內建處理器的列表：

class scrapy.loader.processors.Identity

最簡單的處理器，什麼都不做。它返回原始值不變。它不接收任何建構函式引數，也不接受Loader上下文。

例：

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

class scrapy.loader.processors.TakeFirst

從接收到的值中返回第一個非空值/非空值，因此它通常用作單值欄位的輸出處理器。它不接收任何建構函式引數，也不接受Loader上下文。

例：

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

class scrapy.loader.processors.Join(separator=u' ')

返回與建構函式中給定的分隔符聯接的值，預設為。它不接受載入器上下文。u’ ‘

當使用預設分隔符時，此處理器相當於以下功能： u’ ‘.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'

class scrapy.loader.processors.Compose(*functions, **default_loader_context)

由給定函式的組合構成的處理器。這意味著該處理器的每個輸入值都被傳遞給第一個函式，並且該函式的結果被傳遞給第二個函式，依此類推，直到最後一個函式返回該處理器的輸出值。

預設情況下，停止程序None值。可以通過傳遞關鍵字引數來更改此行為stop_on_none=False。

例：

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

每個功能可以可選地接收loader_context引數。對於那些處理器，這個處理器將通過該引數傳遞當前活動的Loader上下文。

在建構函式中傳遞的關鍵字引數用作傳遞給每個函式呼叫的預設Loader上下文值。但是，傳遞給函式的最後一個Loader上下文值將被當前可用該屬性訪問的當前活動Loader上下文ItemLoader.context() 覆蓋。

class scrapy.loader.processors.MapCompose(*functions, **default_loader_context)

與處理器類似，由給定功能的組成構成的Compose處理器。與此處理器的區別在於內部結果在函式之間傳遞的方式，如下所示：

該處理器的輸入值被迭代，並且第一函式被應用於每個元素。這些函式呼叫的結果（每個元素一個）被連線以構造新的迭代，然後用於應用​​第二個函式，等等，直到最後一個函式被應用於收集的值列表的每個值遠。最後一個函式的輸出值被連線在一起以產生該處理器的輸出。

每個特定函式可以返回值或值列表，這些值通過應用於其他輸入值的相同函式返回的值列表展平。函式也可以返回None，在這種情況下，該函式的輸出將被忽略，以便在鏈上進行進一步處理。

此處理器提供了一種方便的方法來組合只使用單個值（而不是iterables）的函式。由於這個原因， MapCompose處理器通常用作輸入處理器，因為資料通常使用選擇器的 extract()方法提取，選擇器返回unicode字串的列表。

下面的例子應該說明它是如何工作的：

>>> 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']

與Compose處理器一樣，函式可以接收Loader上下文，並且建構函式關鍵字引數用作預設上下文值。有關Compose更多資訊，請參閱 處理器。

class scrapy.loader.processors.SelectJmes(json_path)

例：

>>> 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'}

使用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']