Przedmioty do ładowarek itemów w złomowaniu

Question

Jestem całkiem nowy w złomowaniu, wiem, że przedmioty są używane do zapełniania skradzionych danych, ale nie mogę zrozumieć różnicy między przedmiotami a ładowarkami przedmiotów. Próbowałem przeczytać niektóre przykładowe kody, zamiast przedmiotów używałem do ładowania przedmiotów i nie rozumiem, dlaczego. Dokumentacja Scrapy nie była dla mnie wystarczająco jasna. Czy ktoś może podać proste wyjaśnienie (lepiej z przykładem) o tym, kiedy używane są ładowarki przedmiotów i jakie dodatkowe udogodnienia zapewniają im przedmioty?

Answer 1

bardzo podoba mi się oficjalnego wyjaśnienia w docs:

pozycji Ładowarki zapewniają wygodny mechanizm wypełniania ociera przedmioty. Mimo że elementy można zapełniać za pomocą ich własnego interfejsu API podobnego do języka , funkcja ładowania elementów zapewnia znacznie wygodniejszy interfejs API do wypełniania ich przez proces skrobania, automatyzując niektóre typowe zadania, takie jak analizowanie wyodrębnionych danych przed ich przypisaniem.

Innymi słowy, Przedmioty zapewniają pojemnik na skradzione dane, natomiast Przedmioty do załadunku towarów zapewniają mechanizm do wypełnienia tego kontenera.

Ostatni akapit powinien odpowiedzieć na twoje pytanie.
Ładowarki do ładowarek są świetne, ponieważ pozwalają na korzystanie z wielu skrótów do przetwarzania i wielokrotne użycie kodu, aby wszystko było uporządkowane, czyste i zrozumiałe.

Przykładowy przykład porównania. Powiedzmy chcemy zeskrobać tej pozycji:

class MyItem(Item): 
    full_name = Field() 
    bio = Field() 
    age = Field() 
    weight = Field() 
    height = Field() 

Item tylko podejście mogłoby wyglądać tak:

def parse(self, response): 
    full_name = response.xpath("//div[contains(@class,'name')]/text()").extract() 
    # i.e. returns ugly ['John\n', '\n\t ', ' Snow'] 
    item['full_name'] = ' '.join(i.strip() for i in full_name if i.strip()) 
    bio = response.xpath("//div[contains(@class,'bio')]/text()").extract() 
    item['bio'] = ' '.join(i.strip() for i in full_name if i.strip()) 
    age = response.xpath("//div[@class='age']/text()").extract_first(0) 
    item['age'] = int(age) 
    weight = response.xpath("//div[@class='weight']/text()").extract_first(0) 
    item['weight'] = int(age) 
    height = response.xpath("//div[@class='height']/text()").extract_first(0) 
    item['height'] = int(age) 
    return item 

vs Ładowarki poz podejść:

# define once in items.py 
from scrapy.loader.processors import Compose, MapCompose, Join, TakeFirst 
clean_text = Compose(MapCompose(lambda v: v.strip()), Join()) 
to_int = Compose(TakeFirst(), int) 

class MyItemLoader(ItemLoader): 
    default_item_class = MyItem 
    full_name_out = clean_text 
    bio_out = clean_text 
    age_out = to_int 
    weight_out = to_int 
    height_out = to_int 

# parse as many different places and times as you want 
def parse(self, response): 
    loader = MyItemLoader(selector=response) 
    loader.add_xpath('full_name', "//div[contains(@class,'name')]/text()") 
    loader.add_xpath('bio', "//div[contains(@class,'bio')]/text()") 
    loader.add_xpath('age', "//div[@class='age']/text()") 
    loader.add_xpath('weight', "//div[@class='weight']/text()") 
    loader.add_xpath('height', "//div[@class='height']/text()") 
    return loader.load_item() 

Jak widać ten produkt Ładowarka jest o wiele czystsza i łatwiejsza do skalowania. Załóżmy, że masz jeszcze 20 pól, z których wiele dzieli ta sama logika przetwarzania, byłoby to samobójstwem, aby zrobić to bez elementów ładujących. Ładowarki do przedmiotów są niesamowite i powinieneś z nich korzystać!