Scrapy - Szybki przewodnik

Scrapy to szybka platforma do indeksowania stron internetowych typu open source napisana w języku Python, używana do wyodrębniania danych ze strony internetowej za pomocą selektorów opartych na XPath.

Scrapy został wydany po raz pierwszy 26 czerwca 2008 roku na licencji BSD, a kamień milowy 1.0 został wydany w czerwcu 2015 roku.

Dlaczego warto używać Scrapy?

  • Tworzenie i skalowanie dużych projektów indeksowania jest łatwiejsze.

  • Posiada wbudowany mechanizm o nazwie Selektory, służący do wyodrębniania danych ze stron internetowych.

  • Obsługuje żądania asynchronicznie i jest szybki.

  • Automatycznie dostosowuje prędkość pełzania za pomocą mechanizmu Auto-throttling .

  • Zapewnia dostępność dla programistów.

Funkcje Scrapy

  • Scrapy to open source i darmowy framework do indeksowania sieci.

  • Scrapy generuje eksport kanałów w formatach takich jak JSON, CSV i XML.

  • Scrapy ma wbudowaną obsługę wybierania i wyodrębniania danych ze źródeł za pomocą wyrażeń XPath lub CSS.

  • Scrapy oparty na crawlerze umożliwia automatyczne wydobywanie danych ze stron internetowych.

Zalety

  • Scrapy jest łatwo rozszerzalny, szybki i potężny.

  • Jest to wieloplatformowy framework aplikacji (Windows, Linux, Mac OS i BSD).

  • Żądania Scrapy są planowane i przetwarzane asynchronicznie.

  • Scrapy ma wbudowaną usługę o nazwie Scrapyd który umożliwia przesyłanie projektów i sterowanie pająkami za pomocą usługi internetowej JSON.

  • Możliwe jest odrzucenie dowolnej witryny internetowej, chociaż ta witryna nie ma interfejsu API do dostępu do surowych danych.

Niedogodności

  • Scrapy jest dostępny tylko dla Pythona 2.7. +

  • Instalacja przebiega inaczej w różnych systemach operacyjnych.

W tym rozdziale omówimy, jak zainstalować i skonfigurować Scrapy. Scrapy musi być zainstalowany wraz z Pythonem.

Scrapy można zainstalować za pomocą pip. Aby zainstalować, uruchom następujące polecenie -

pip install Scrapy

Windows

Note - Python 3 nie jest obsługiwany w systemie operacyjnym Windows.

Step 1- Zainstaluj Python 2.7 z Pythona

Ustaw zmienne środowiskowe, dodając następujące ścieżki do PATH -

C:\Python27\;C:\Python27\Scripts\;

Możesz sprawdzić wersję Pythona za pomocą następującego polecenia -

python --version

Step 2- Zainstaluj OpenSSL .

Dodaj C: \ OpenSSL-Win32 \ bin do zmiennych środowiskowych.

Note - OpenSSL jest preinstalowany we wszystkich systemach operacyjnych z wyjątkiem Windows.

Step 3- Zainstaluj pakiety redystrybucyjne Visual C ++ 2008 .

Step 4- Zainstaluj pywin32 .

Step 5- Zainstaluj pip dla wersji Pythona starszych niż 2.7.9.

Możesz sprawdzić wersję pip za pomocą następującego polecenia -

pip --version

Step 6 - Aby zainstalować scrapy, uruchom następujące polecenie -

pip install Scrapy

Anakonda

Jeśli masz zainstalowaną anakondę lub minicondę na swoim komputerze, uruchom poniższe polecenie, aby zainstalować Scrapy za pomocą conda -

conda install -c scrapinghub scrapy

Scrapinghub firma wspiera oficjalne pakiety Conda dla Linux, Windows i OS X.

Note - Zaleca się zainstalowanie Scrapy za pomocą powyższego polecenia, jeśli masz problemy z instalacją przez pip.

Ubuntu 9.10 lub nowszy

Najnowsza wersja języka Python jest preinstalowana w systemie operacyjnym Ubuntu. Użyj pakietów Ubuntu aptgettable dostarczonych przez Scrapinghub. Aby skorzystać z pakietów -

Step 1 - Musisz zaimportować klucz GPG używany do podpisywania pakietów Scrapy do pęku kluczy APT -

sudo apt-key adv --keyserver hkp://keyserver.ubuntu.com:80 --recv 627220E7

Step 2 - Następnie użyj następującego polecenia, aby utworzyć plik /etc/apt/sources.list.d/scrapy.list -

echo 'deb http://archive.scrapy.org/ubuntu scrapy main' | sudo tee 
/etc/apt/sources.list.d/scrapy.list

Step 3 - Zaktualizuj listę pakietów i zainstaluj scrapy -

sudo apt-get update && sudo apt-get install scrapy

Archlinux

Możesz zainstalować Scrapy z pakietu AUR Scrapy za pomocą następującego polecenia -

yaourt -S scrapy

Mac OS X

Użyj następującego polecenia, aby zainstalować narzędzia wiersza poleceń Xcode -

xcode-select --install

Zamiast używać systemowego języka Python, zainstaluj nową zaktualizowaną wersję, która nie koliduje z resztą systemu.

Step 1- Zainstaluj homebrew .

Step 2 - Ustaw zmienną środowiskową PATH, aby określić, że pakiety homebrew powinny być używane przed pakietami systemowymi -

echo "export PATH = /usr/local/bin:/usr/local/sbin:$PATH" >> ~/.bashrc

Step 3 - Aby upewnić się, że zmiany zostały wprowadzone, załaduj ponownie .bashrc używając następującego polecenia -

source ~/.bashrc

Step 4 - Następnie zainstaluj Python za pomocą następującego polecenia -

brew install python

Step 5 - Zainstaluj Scrapy za pomocą następującego polecenia -

pip install Scrapy

Opis

Narzędzie wiersza poleceń Scrapy służy do kontrolowania Scrapy, co często jest nazywane 'Scrapy tool'. Zawiera polecenia dla różnych obiektów z grupą argumentów i opcji.

Ustawienia konfiguracji

Scrapy znajdzie ustawienia konfiguracyjne w scrapy.cfgplik. Oto kilka lokalizacji -

  • C: \ scrapy (folder projektu) \ scrapy.cfg w systemie

  • ~ / .config / scrapy.cfg ($ XDG_CONFIG_HOME) i ~ / .scrapy.cfg ($ HOME) dla ustawień globalnych

  • Możesz znaleźć scrapy.cfg w katalogu głównym projektu.

Scrapy można również skonfigurować przy użyciu następujących zmiennych środowiskowych -

  • SCRAPY_SETTINGS_MODULE
  • SCRAPY_PROJECT
  • SCRAPY_PYTHON_SHELL

Domyślny projekt złomowania struktury

Poniższa struktura przedstawia domyślną strukturę plików projektu Scrapy.

scrapy.cfg                - Deploy the configuration file
project_name/             - Name of the project
   _init_.py
   items.py               - It is project's items file
   pipelines.py           - It is project's pipelines file
   settings.py            - It is project's settings file
   spiders                - It is the spiders directory
      _init_.py
      spider_name.py
      . . .

Plik scrapy.cfgplik to katalog główny projektu, który zawiera nazwę projektu z ustawieniami projektu. Na przykład -

[settings] 
default = [name of the project].settings  

[deploy] 
#url = http://localhost:6800/ 
project = [name of the project]

Korzystanie z narzędzia Scrapy

Narzędzie Scrapy zapewnia niektóre zastosowania i dostępne polecenia w następujący sposób -

Scrapy X.Y  - no active project 
Usage: 
   scrapy  [options] [arguments] 
Available commands: 
   crawl      It puts spider (handle the URL) to work for crawling data 
   fetch      It fetches the response from the given URL

Tworzenie projektu

Możesz użyć następującego polecenia, aby utworzyć projekt w Scrapy -

scrapy startproject project_name

Spowoduje to utworzenie projektu o nazwie project_nameinformator. Następnie przejdź do nowo utworzonego projektu, używając następującego polecenia -

cd  project_name

Kontrolowanie projektów

Możesz kontrolować projekt i zarządzać nim za pomocą narzędzia Scrapy, a także stworzyć nowego pająka, używając następującego polecenia -

scrapy genspider mydomain mydomain.com

Polecenia takie jak indeksowanie itp. Muszą być używane w projekcie Scrapy. W następnej sekcji dowiesz się, które polecenia muszą być uruchamiane w projekcie Scrapy.

Scrapy zawiera kilka wbudowanych poleceń, których można użyć w projekcie. Aby zobaczyć listę dostępnych poleceń, użyj następującego polecenia -

scrapy -h

Po uruchomieniu następującego polecenia Scrapy wyświetli listę dostępnych poleceń w postaci listy -

  • fetch - Pobiera adres URL za pomocą narzędzia do pobierania Scrapy.

  • runspider - Służy do uruchamiania samodzielnego pająka bez tworzenia projektu.

  • settings - Określa wartość ustawienia projektu.

  • shell - Jest to interaktywny moduł do skrobania podanego adresu URL.

  • startproject - Tworzy nowy projekt Scrapy.

  • version - Wyświetla wersję Scrapy.

  • view - Pobiera adres URL za pomocą narzędzia do pobierania Scrapy i wyświetla zawartość w przeglądarce.

Na liście może znajdować się kilka poleceń związanych z projektem -

  • crawl - Służy do indeksowania danych za pomocą pająka.

  • check - Sprawdza elementy zwrócone przez przeszukane polecenie.

  • list - Wyświetla listę dostępnych pająków obecnych w projekcie.

  • edit - Możesz edytować pająki za pomocą edytora.

  • parse - Analizuje podany adres URL za pomocą pająka.

  • bench - Służy do uruchamiania szybkiego testu porównawczego (Benchmark mówi, ile stron może zostać zindeksowanych na minutę przez Scrapy).

Niestandardowe polecenia projektu

Możesz zbudować niestandardowe polecenie projektu za pomocą COMMANDS_MODULEustawienie w projekcie Scrapy. Zawiera domyślny pusty ciąg w ustawieniu. Możesz dodać następujące niestandardowe polecenie -

COMMANDS_MODULE = 'mycmd.commands'

Polecenia Scrapy można dodać za pomocą sekcji scrapy.commands w pliku setup.py pokazanym w następujący sposób -

from setuptools import setup, find_packages  

setup(name = 'scrapy-module_demo', 
   entry_points = { 
      'scrapy.commands': [ 
         'cmd_demo = my_module.commands:CmdDemo', 
      ], 
   }, 
)

Powyższy kod dodaje cmd_demo polecenie w setup.py plik.

Opis

Spider to klasa odpowiedzialna za definiowanie sposobu podążania za linkami w witrynie i wyodrębniania informacji ze stron.

Domyślne pająki Scrapy są następujące -

scrapy.Spider

Jest to pająk, po którym muszą dziedziczyć wszystkie inne pająki. Ma następującą klasę -

class scrapy.spiders.Spider

Poniższa tabela przedstawia pola scrapy. Klasa pająka -

Sr.No Pole i opis
1

name

To imię twojego pająka.

2

allowed_domains

Jest to lista domen, po których czołgał się pająk.

3

start_urls

Jest to lista adresów URL, które będą korzeniami dla późniejszych indeksowań, z których pająk zacznie się czołgać.

4

custom_settings

Są to ustawienia, które podczas uruchamiania pająka zostaną nadpisane z konfiguracji całego projektu.

5

crawler

Jest to atrybut powiązany z obiektem Crawler, z którym jest powiązana instancja pająka.

6

settings

To są ustawienia do biegania pająka.

7

logger

Jest to logger Pythona używany do wysyłania komunikatów dziennika.

8

from_crawler(crawler,*args,**kwargs)

Jest to metoda klasowa, która tworzy twojego pająka. Parametry to -

  • crawler - Robot, do którego zostanie przypisana instancja pająka.

  • args(list)- Te argumenty są przekazywane do metody _init_ () .

  • kwargs(dict)- Te argumenty słów kluczowych są przekazywane do metody _init_ () .

9

start_requests()

Gdy nie określono konkretnego adresu URL i pająk jest otwarty do złomowania, Scrapy wywołuje metodę start_requests () .

10

make_requests_from_url(url)

Jest to metoda służąca do konwersji adresów URL na żądania.

11

parse(response)

Ta metoda przetwarza odpowiedź i zwraca odrzucone dane po kolejnych adresach URL.

12

log(message[,level,component])

Jest to metoda, która wysyła komunikat dziennika przez rejestrator pająków.

13

closed(reason)

Ta metoda jest wywoływana, gdy pająk się zamyka.

Argumenty pająka

Argumenty pająka służą do określania początkowych adresów URL i są przekazywane za pomocą polecenia indeksowania z -a opcja, pokazana w następujący sposób -

scrapy crawl first_scrapy -a group = accessories

Poniższy kod pokazuje, jak pająk otrzymuje argumenty -

import scrapy 

class FirstSpider(scrapy.Spider): 
   name = "first" 
   
   def __init__(self, group = None, *args, **kwargs): 
      super(FirstSpider, self).__init__(*args, **kwargs) 
      self.start_urls = ["http://www.example.com/group/%s" % group]

Ogólne pająki

Możesz użyć ogólnych pająków, aby podklasować swoje pająki z. Ich celem jest podążanie za wszystkimi linkami w witrynie na określonych zasadach w celu wyodrębnienia danych ze wszystkich stron.

W przypadku przykładów użytych w poniższych pająkach załóżmy, że mamy projekt z następującymi polami -

import scrapy 
from scrapy.item import Item, Field 
  
class First_scrapyItem(scrapy.Item): 
   product_title = Field() 
   product_link = Field() 
   product_description = Field()

CrawlSpider

CrawlSpider definiuje zestaw reguł podążania za linkami i wycinania więcej niż jednej strony. Ma następującą klasę -

class scrapy.spiders.CrawlSpider

Poniżej przedstawiono atrybuty klasy CrawlSpider -

zasady

Jest to lista obiektów reguł definiujących sposób, w jaki przeszukiwacz podąża za odsyłaczem.

Poniższa tabela przedstawia reguły klasy CrawlSpider -

Sr.No Reguła i opis
1

LinkExtractor

Określa, w jaki sposób pająk podąża za linkami i wyodrębnia dane.

2

callback

Ma być wywoływana po zeskrobaniu każdej strony.

3

follow

Określa, czy kontynuować korzystanie z łączy, czy nie.

parse_start_url (odpowiedź)

Zwraca element lub obiekt żądania, umożliwiając analizę początkowych odpowiedzi.

Note - Pamiętaj, aby podczas pisania reguł zmienić nazwę funkcji analizy na inną niż analiza, ponieważ funkcja analizy jest używana przez CrawlSpider do implementacji jej logiki.

Spójrzmy na poniższy przykład, w którym pająk zaczyna indeksować stronę główną demoexample.com, zbierając wszystkie strony, linki i analizuje za pomocą metody parse_items -

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

class DemoSpider(CrawlSpider):
   name = "demo"
   allowed_domains = ["www.demoexample.com"]
   start_urls = ["http://www.demoexample.com"]
      
   rules = ( 
      Rule(LinkExtractor(allow =(), restrict_xpaths = ("//div[@class = 'next']",)),
         callback = "parse_item", follow = True),
   )
   
   def parse_item(self, response):
      item = DemoItem()
      item["product_title"] = response.xpath("a/text()").extract()
      item["product_link"] = response.xpath("a/@href").extract()
      item["product_description"] = response.xpath("div[@class = 'desc']/text()").extract()
      return items

XMLFeedSpider

Jest to klasa bazowa dla pająków, które zgarniają z kanałów XML i iterują po węzłach. Ma następującą klasę -

class scrapy.spiders.XMLFeedSpider

W poniższej tabeli przedstawiono atrybuty klasy używane do ustawiania iteratora i nazwy znacznika -

Sr.No Atrybut i opis
1

iterator

Definiuje iterator, który ma być używany. Może to być iternodes, html lub xml . Domyślnie są to iternodes .

2

itertag

Jest to ciąg z nazwą węzła do iteracji.

3

namespaces

Jest definiowana przez listę krotek (prefiks, uri), które automatycznie rejestrują przestrzenie nazw przy użyciu metody register_namespace () .

4

adapt_response(response)

Otrzymuje odpowiedź i modyfikuje treść odpowiedzi, gdy tylko nadejdzie z oprogramowania pośredniczącego pająka, zanim pająk zacznie ją analizować.

5

parse_node(response,selector)

Otrzymuje odpowiedź i selektor po wywołaniu dla każdego węzła pasującego do podanej nazwy znacznika.

Note - Twój pająk nie zadziała, jeśli nie zastąpisz tej metody.

6

process_results(response,results)

Zwraca listę wyników i odpowiedzi zwróconych przez pająka.

CSVFeedSpider

Iteruje przez każdy ze swoich wierszy, otrzymuje plik CSV jako odpowiedź i wywołuje metodę parse_row () . Ma następującą klasę -

class scrapy.spiders.CSVFeedSpider

W poniższej tabeli przedstawiono opcje, które można ustawić w odniesieniu do pliku CSV -

Sr.No Opcja i opis
1

delimiter

Jest to ciąg zawierający separator przecinków („,”) dla każdego pola.

2

quotechar

Jest to ciąg znaków zawierający cudzysłów („”) dla każdego pola.

3

headers

Jest to lista wyciągów, z których można wyodrębnić pola.

4

parse_row(response,row)

Otrzymuje odpowiedź i każdy wiersz wraz z kluczem do nagłówka.

Przykład CSVFeedSpider

from scrapy.spiders import CSVFeedSpider
from demoproject.items import DemoItem  

class DemoSpider(CSVFeedSpider): 
   name = "demo" 
   allowed_domains = ["www.demoexample.com"] 
   start_urls = ["http://www.demoexample.com/feed.csv"] 
   delimiter = ";" 
   quotechar = "'" 
   headers = ["product_title", "product_link", "product_description"]  
   
   def parse_row(self, response, row): 
      self.logger.info("This is row: %r", row)  
      item = DemoItem() 
      item["product_title"] = row["product_title"] 
      item["product_link"] = row["product_link"] 
      item["product_description"] = row["product_description"] 
      return item

SitemapSpider

SitemapSpider z pomocą Sitemaps indeksuje witrynę, znajdując adresy URL z pliku robots.txt. Ma następującą klasę -

class scrapy.spiders.SitemapSpider

W poniższej tabeli przedstawiono pola SitemapSpider -

Sr.No Pole i opis
1

sitemap_urls

Lista adresów URL, które chcesz indeksować, wskazujących mapy witryn.

2

sitemap_rules

Jest to lista krotek (regex, callback), gdzie regex jest wyrażeniem regularnym, a callback służy do przetwarzania adresów URL pasujących do wyrażenia regularnego.

3

sitemap_follow

Jest to lista wyrażeń regularnych mapy witryny, których należy przestrzegać.

4

sitemap_alternate_links

Określa alternatywne linki, których należy użyć w przypadku pojedynczego adresu URL.

Przykład SitemapSpider

Następujący SitemapSpider przetwarza wszystkie adresy URL -

from scrapy.spiders import SitemapSpider  

class DemoSpider(SitemapSpider): 
   urls = ["http://www.demoexample.com/sitemap.xml"]  
   
   def parse(self, response): 
      # You can scrap items here

Następująca witryna SitemapSpider przetwarza niektóre adresy URL z wywołaniem zwrotnym -

from scrapy.spiders import SitemapSpider  

class DemoSpider(SitemapSpider): 
   urls = ["http://www.demoexample.com/sitemap.xml"] 
   
   rules = [ 
      ("/item/", "parse_item"), 
      ("/group/", "parse_group"), 
   ]  
   
   def parse_item(self, response): 
      # you can scrap item here  
   
   def parse_group(self, response): 
      # you can scrap group here

Poniższy kod przedstawia mapy witryn w pliku robots.txt, którego adres URL ma /sitemap_company -

from scrapy.spiders import SitemapSpider

class DemoSpider(SitemapSpider): 
   urls = ["http://www.demoexample.com/robots.txt"] 
   rules = [ 
      ("/company/", "parse_company"), 
   ] 
   sitemap_follow = ["/sitemap_company"]  
   
   def parse_company(self, response): 
      # you can scrap company here

Możesz nawet łączyć SitemapSpider z innymi adresami URL, jak pokazano w poniższym poleceniu.

from scrapy.spiders import SitemapSpider  

class DemoSpider(SitemapSpider): 
   urls = ["http://www.demoexample.com/robots.txt"] 
   rules = [ 
      ("/company/", "parse_company"), 
   ]  
   
   other_urls = ["http://www.demoexample.com/contact-us"] 
   def start_requests(self): 
      requests = list(super(DemoSpider, self).start_requests()) 
      requests += [scrapy.Request(x, self.parse_other) for x in self.other_urls] 
      return requests 

   def parse_company(self, response): 
      # you can scrap company here... 

   def parse_other(self, response): 
      # you can scrap other here...

Opis

Podczas skrobania stron internetowych musisz wyodrębnić określoną część źródła HTML za pomocą mechanizmu o nazwie selectors, osiągane za pomocą wyrażeń XPath lub CSS. Selektory są oparte na platformielxml biblioteka, która przetwarza XML i HTML w języku Python.

Użyj poniższego fragmentu kodu, aby zdefiniować różne koncepcje selektorów -

<html>
   <head>
      <title>My Website</title>
   </head>
   
   <body>
      <span>Hello world!!!</span>
      <div class = 'links'>
         <a href = 'one.html'>Link 1<img src = 'image1.jpg'/></a>
         <a href = 'two.html'>Link 2<img src = 'image2.jpg'/></a>
         <a href = 'three.html'>Link 3<img src = 'image3.jpg'/></a>
      </div>
   </body>
</html>

Konstruowanie selektorów

Możesz skonstruować instancje klasy selektora, przekazując text lub TextResponseobiekt. Na podstawie podanego typu wejścia selektor wybiera następujące reguły -

from scrapy.selector import Selector 
from scrapy.http import HtmlResponse

Korzystając z powyższego kodu, możesz skonstruować z tekstu jako -

Selector(text = body).xpath('//span/text()').extract()

Wyświetli wynik jako -

[u'Hello world!!!']

Możesz skonstruować z odpowiedzi jako -

response = HtmlResponse(url = 'http://mysite.com', body = body) 
Selector(response = response).xpath('//span/text()').extract()

Wyświetli wynik jako -

[u'Hello world!!!']

Korzystanie z selektorów

Korzystając z powyższego prostego fragmentu kodu, możesz skonstruować XPath w celu wybrania tekstu zdefiniowanego w tagu tytułu, jak pokazano poniżej -

>>response.selector.xpath('//title/text()')

Teraz możesz wyodrębnić dane tekstowe za pomocą .extract() metoda pokazana w następujący sposób -

>>response.xpath('//title/text()').extract()

Daje wynik jako -

[u'My Website']

Możesz wyświetlić nazwę wszystkich elementów pokazanych w następujący sposób -

>>response.xpath('//div[@class = "links"]/a/text()').extract()

Wyświetli elementy jako -

Link 1
Link 2
Link 3

Jeśli chcesz wyodrębnić pierwszy element, użyj metody .extract_first(), pokazane w następujący sposób -

>>response.xpath('//div[@class = "links"]/a/text()').extract_first()

Wyświetli element jako -

Link 1

Selektory zagnieżdżające

Korzystając z powyższego kodu, możesz zagnieździć selektory, aby wyświetlić łącze do strony i źródło obrazu przy użyciu rozszerzenia .xpath() metoda, pokazana w następujący sposób -

links = response.xpath('//a[contains(@href, "image")]') 

for index, link in enumerate(links): 
   args = (index, link.xpath('@href').extract(), link.xpath('img/@src').extract()) 
   print 'The link %d pointing to url %s and image %s' % args

Wyświetli wynik jako -

Link 1 pointing to url [u'one.html'] and image [u'image1.jpg']
Link 2 pointing to url [u'two.html'] and image [u'image2.jpg']
Link 3 pointing to url [u'three.html'] and image [u'image3.jpg']

Selektory wykorzystujące wyrażenia regularne

Scrapy umożliwia wyodrębnienie danych za pomocą wyrażeń regularnych, które wykorzystują rozszerzenie .re()metoda. Z powyższego kodu HTML wyodrębnimy nazwy obrazów pokazane w następujący sposób -

>>response.xpath('//a[contains(@href, "image")]/text()').re(r'Name:\s*(.*)')

Powyższa linia wyświetla nazwy obrazów jako -

[u'Link 1', 
u'Link 2', 
u'Link 3']

Korzystanie ze względnych ścieżek XPath

Podczas pracy z XPaths, które zaczynają się od /, zagnieżdżone selektory i XPath są powiązane ze ścieżką bezwzględną dokumentu, a nie ze ścieżką względną selektora.

Jeśli chcesz wyodrębnić plik <p> elementy, a następnie najpierw zdobądź wszystkie elementy div -

>>mydiv = response.xpath('//div')

Następnie możesz wyodrębnić wszystkie pliki 'p' elementy wewnątrz, poprzedzając XPath kropką jako .//p jak pokazano poniżej -

>>for p in mydiv.xpath('.//p').extract()

Korzystanie z rozszerzeń EXSLT

EXSLT to społeczność, która wydaje rozszerzenia do XSLT (Extensible Stylesheet Language Transformations), który konwertuje dokumenty XML na dokumenty XHTML. Możesz użyć rozszerzeń EXSLT z zarejestrowaną przestrzenią nazw w wyrażeniach XPath, jak pokazano w poniższej tabeli -

Sr.No Prefiks i użycie Przestrzeń nazw
1

re

wyrażenia regularne

http://exslt.org/regexp/index.html

2

set

manipulacja zestawem

http://exslt.org/set/index.html

Możesz sprawdzić prosty format kodu do wyodrębniania danych za pomocą wyrażeń regularnych w poprzedniej sekcji.

Istnieje kilka wskazówek dotyczących XPath, które są przydatne podczas używania XPath z selektorami Scrapy. Aby uzyskać więcej informacji, kliknij to łącze .

Opis

Proces Scrapy może być użyty do wyodrębnienia danych ze źródeł, takich jak strony internetowe za pomocą pająków. Zastosowania ScrapyItem klasy, aby wygenerować dane wyjściowe, których obiekty są używane do zbierania pobranych danych.

Deklarowanie pozycji

Możesz zadeklarować elementy przy użyciu składni definicji klasy wraz z obiektami pól pokazanymi w następujący sposób -

import scrapy 
class MyProducts(scrapy.Item): 
   productName = Field() 
   productLink = Field() 
   imageURL = Field() 
   price = Field() 
   size = Field()

Pola pozycji

Pola pozycji służą do wyświetlania metadanych dla każdego pola. Ponieważ nie ma ograniczeń co do wartości w obiektach pól, dostępne klucze metadanych nie zawierają żadnej listy referencyjnej metadanych. Obiekty pól służą do określania wszystkich metadanych pól i można określić dowolny inny klucz pola zgodnie z wymaganiami projektu. Dostęp do obiektów pól można uzyskać za pomocą atrybutu Item.fields.

Praca z przedmiotami

Istnieje kilka typowych funkcji, które można zdefiniować podczas pracy z elementami. Aby uzyskać więcej informacji, kliknij to łącze .

Przedmioty przedłużające

Pozycje można rozszerzyć, podając podklasę pierwotnej pozycji. Na przykład -

class MyProductDetails(Product): 
   original_rate = scrapy.Field(serializer = str) 
   discount_rate = scrapy.Field()

Możesz użyć istniejących metadanych pola, aby rozszerzyć metadane pola, dodając więcej wartości lub zmieniając istniejące wartości, jak pokazano w poniższym kodzie -

class MyProductPackage(Product): 
   name = scrapy.Field(Product.fields['name'], serializer = serializer_demo)

Obiekty przedmiotów

Obiekty pozycji można określić za pomocą następującej klasy, która dostarcza nowy zainicjowany element z podanego argumentu -

class scrapy.item.Item([arg])

Element zapewnia kopię konstruktora i zapewnia dodatkowy atrybut, który jest nadawany przez elementy w polach.

Obiekty polowe

Obiekty pola można określić za pomocą następującej klasy, w której klasa Field nie generuje dodatkowego procesu ani atrybutów -

class scrapy.item.Field([arg])

Opis

Moduły ładujące elementy zapewniają wygodny sposób wypełniania elementów, które są usuwane ze stron internetowych.

Deklarowanie programów ładujących przedmioty

Deklaracja osób ładujących przedmioty jest jak przedmioty.

Na przykład -

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

class DemoLoader(ItemLoader):  
   default_output_processor = TakeFirst()  
   title_in = MapCompose(unicode.title) 
   title_out = Join()  
   size_in = MapCompose(unicode.strip)  
   # you can continue scraping here

W powyższym kodzie widać, że procesory wejściowe są deklarowane przy użyciu _in przyrostek i procesory wyjściowe są deklarowane przy użyciu _out przyrostek.

Plik ItemLoader.default_input_processor i ItemLoader.default_output_processor atrybuty są używane do deklarowania domyślnych procesorów wejścia / wyjścia.

Używanie modułów ładowania przedmiotów do wypełniania pozycji

Aby użyć modułu ładującego elementy, najpierw utwórz instancję z obiektem podobnym do dict lub bez obiektu, w którym element używa klasy Item określonej w ItemLoader.default_item_class atrybut.

  • Możesz użyć selektorów, aby zebrać wartości do modułu ładowania przedmiotów.

  • Możesz dodać więcej wartości w tym samym polu przedmiotu, gdzie moduł ładujący użyje odpowiedniego modułu obsługi, aby dodać te wartości.

Poniższy kod ilustruje, jak pozycje są zapełniane przy użyciu modułów ładujących -

from scrapy.loader import ItemLoader 
from demoproject.items import Demo  

def parse(self, response): 
   l = ItemLoader(item = Product(), response = response)
   l.add_xpath("title", "//div[@class = 'product_title']")
   l.add_xpath("title", "//div[@class = 'product_name']")
   l.add_xpath("desc", "//div[@class = 'desc']")
   l.add_css("size", "div#size]")
   l.add_value("last_updated", "yesterday")
   return l.load_item()

Jak pokazano powyżej, istnieją dwie różne ścieżki XPath, z których title pole jest wyodrębniane za pomocą add_xpath() metoda -

1. //div[@class = "product_title"] 
2. //div[@class = "product_name"]

Następnie podobne żądanie jest używane do descpole. Dane o rozmiarze są wyodrębniane za pomocąadd_css() metoda i last_updated jest wypełniana wartością „wczoraj” za pomocą add_value() metoda.

Po zebraniu wszystkich danych zadzwoń ItemLoader.load_item() metoda, która zwraca elementy wypełnione danymi wyodrębnionymi za pomocą add_xpath(), add_css() i add_value() metody.

Procesory wejściowe i wyjściowe

Każde pole modułu ładującego elementy zawiera jeden procesor wejściowy i jeden procesor wyjściowy.

  • Po wyodrębnieniu danych procesor wejściowy przetwarza je, a jego wynik jest przechowywany w ItemLoader.

  • Następnie, po zebraniu danych, wywołaj metodę ItemLoader.load_item (), aby pobrać wypełniony obiekt Item.

  • Na koniec możesz przypisać wynik procesora wyjściowego do pozycji.

Poniższy kod ilustruje sposób wywoływania procesorów wejściowych i wyjściowych dla określonego pola -

l = ItemLoader(Product(), some_selector)
l.add_xpath("title", xpath1) # [1]
l.add_xpath("title", xpath2) # [2]
l.add_css("title", css)      # [3]
l.add_value("title", "demo") # [4]
return l.load_item()         # [5]

Line 1 - Dane tytułu są pobierane z xpath1 i przesyłane przez procesor wejściowy, a ich wynik jest gromadzony i zapisywany w ItemLoader.

Line 2 - Podobnie, tytuł jest wyodrębniany z xpath2 i przepuszczany przez ten sam procesor wejściowy, a jego wynik jest dodawany do danych zebranych dla [1].

Line 3 - Tytuł jest pobierany z selektora css i przepuszczany przez ten sam procesor wejściowy, a wynik jest dodawany do danych zebranych dla [1] i [2].

Line 4 - Następnie przypisywana jest wartość „demo” i przepuszczana przez procesory wejściowe.

Line 5 - Na koniec dane są zbierane wewnętrznie ze wszystkich pól i przekazywane do procesora wyjściowego, a ostateczna wartość jest przypisywana do elementu.

Deklarowanie procesorów wejściowych i wyjściowych

Procesory wejściowe i wyjściowe są zadeklarowane w definicji ItemLoader. Oprócz tego można je również określić w plikuItem Field metadane.

Na przykład -

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

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

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

>>> from scrapy.loader import ItemLoader 
>>> il = ItemLoader(item = Product()) 
>>> il.add_value('title', [u'Hello', u'<strong>world</strong>']) 
>>> il.add_value('size', [u'<span>100 kg</span>']) 
>>> il.load_item()

Wyświetla dane wyjściowe jako -

{'title': u'Hello world', 'size': u'100 kg'}

Kontekst modułu ładującego elementy

Kontekst modułu ładującego elementy jest zapisem arbitralnych wartości kluczowych współdzielonych między procesorami wejściowymi i wyjściowymi.

Na przykład załóżmy, że masz funkcję parse_length -

def parse_length(text, loader_context): 
   unit = loader_context.get('unit', 'cm') 
   
   # You can write parsing code of length here  
   return parsed_length

Otrzymując argumenty loader_context, informuje program ładujący elementy, że może odebrać kontekst modułu ładującego elementy. Istnieje kilka sposobów zmiany wartości kontekstu modułu ładującego elementy -

  • Modyfikuj bieżący kontekst aktywnego modułu ładowania elementów -

loader = ItemLoader (product)
loader.context ["unit"] = "mm"
  • Podczas tworzenia instancji modułu ładującego przedmioty -

loader = ItemLoader(product, unit = "mm")
  • W przypadku deklaracji modułu ładującego elementy dla procesorów wejścia / wyjścia, które tworzą instancję z kontekstem modułu ładującego elementy -

class ProductLoader(ItemLoader):
   length_out = MapCompose(parse_length, unit = "mm")

Obiekty ItemLoader

Jest to obiekt, który zwraca nowy program ładujący elementy, aby zapełnić dany element. Ma następującą klasę -

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

Poniższa tabela przedstawia parametry obiektów ItemLoader -

Sr.No Parametr i opis
1

item

Jest to pozycja do zapełnienia przez wywołanie add_xpath (), add_css () lub add_value ().

2

selector

Służy do pobierania danych ze stron internetowych.

3

response

Służy do konstruowania selektora przy użyciu default_selector_class.

Poniższa tabela przedstawia metody obiektów ItemLoader -

Sr.No Metoda i opis Przykład
1

get_value(value, *processors, **kwargs)

Wartość jest przetwarzana przez metodę get_value () przez podany procesor i argumenty słów kluczowych.

>>> from scrapy.loader.processors import TakeFirst
>>> loader.get_value(u'title: demoweb', TakeFirst(), 
unicode.upper, re = 'title: (.+)')
'DEMOWEB`
2

add_value(field_name, value, *processors, **kwargs)

Przetwarza wartość i dodaje ją do pola, w którym jest po raz pierwszy przekazywana przez get_value, podając procesory i argumenty słów kluczowych przed przejściem przez procesor wejściowy pola.

loader.add_value('title', u'DVD')
loader.add_value('colors', [u'black', u'white'])
loader.add_value('length', u'80')
loader.add_value('price', u'2500')
3

replace_value(field_name, value, *processors, **kwargs)

Zastępuje zebrane dane nową wartością.

loader.replace_value('title', u'DVD')
loader.replace_value('colors', [u'black', 
u'white'])
loader.replace_value('length', u'80')
loader.replace_value('price', u'2500')
4

get_xpath(xpath, *processors, **kwargs)

Służy do wyodrębniania ciągów znaków Unicode przez podanie procesorów i argumentów słów kluczowych poprzez odebranie XPath .

# HTML code: <div class = "item-name">DVD</div>
loader.get_xpath("//div[@class = 
'item-name']")

# HTML code: <div id = "length">the length is 
45cm</div>
loader.get_xpath("//div[@id = 'length']", TakeFirst(), 
re = "the length is (.*)")
5

add_xpath(field_name, xpath, *processors, **kwargs)

Otrzymuje XPath do pola, które wyodrębnia ciągi znaków Unicode.

# HTML code: <div class = "item-name">DVD</div>
loader.add_xpath('name', '//div
[@class = "item-name"]')

# HTML code: <div id = "length">the length is 
45cm</div>
loader.add_xpath('length', '//div[@id = "length"]',
 re = 'the length is (.*)')
6

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

Zastępuje zebrane dane za pomocą XPath z witryn.

# HTML code: <div class = "item-name">DVD</div>
loader.replace_xpath('name', '
//div[@class = "item-name"]')

# HTML code: <div id = "length">the length is
 45cm</div>
loader.replace_xpath('length', '
//div[@id = "length"]', re = 'the length is (.*)')
7

get_css(css, *processors, **kwargs)

Otrzymuje selektor CSS używany do wyodrębnienia ciągów znaków Unicode.

loader.get_css("div.item-name")
loader.get_css("div#length", TakeFirst(), 
re = "the length is (.*)")
8

add_css(field_name, css, *processors, **kwargs)

Jest podobna do metody add_value () z tą różnicą, że dodaje selektor CSS do pola.

loader.add_css('name', 'div.item-name')
loader.add_css('length', 'div#length', 
re = 'the length is (.*)')
9

replace_css(field_name, css, *processors, **kwargs)

Zastępuje wyodrębnione dane za pomocą selektora CSS.

loader.replace_css('name', 'div.item-name')
loader.replace_css('length', 'div#length',
 re = 'the length is (.*)')
10

load_item()

Po zebraniu danych ta metoda wypełnia pozycję zebranymi danymi i zwraca je.

def parse(self, response):
l = ItemLoader(item = Product(), 
response = response)
l.add_xpath('title', '//
div[@class = "product_title"]')
loader.load_item()
11

nested_xpath(xpath)

Służy do tworzenia zagnieżdżonych programów ładujących z selektorem XPath.

loader = ItemLoader(item = Item())
loader.add_xpath('social', '
a[@class = "social"]/@href')
loader.add_xpath('email', '
a[@class = "email"]/@href')
12

nested_css(css)

Służy do tworzenia zagnieżdżonych programów ładujących z selektorem CSS.

loader = ItemLoader(item = Item())
loader.add_css('social', 'a[@class = "social"]/@href')
loader.add_css('email', 'a[@class = "email"]/@href')

Poniższa tabela przedstawia atrybuty obiektów ItemLoader -

Sr.No Atrybut i opis
1

item

Jest to obiekt, na którym moduł ładujący przedmioty przeprowadza analizę.

2

context

Jest to bieżący kontekst programu ładującego elementy, który jest aktywny.

3

default_item_class

Służy do reprezentowania elementów, jeśli nie jest podany w konstruktorze.

4

default_input_processor

Pola, które nie określają procesora wejściowego, są jedynymi, dla których używane są default_input_processors.

5

default_output_processor

Pola, które nie określają procesora wyjściowego, są jedynymi, dla których używane są default_output_processors.

6

default_selector_class

Jest to klasa używana do konstruowania selektora, jeśli nie jest podana w konstruktorze.

7

selector

Jest to obiekt, którego można użyć do wyodrębnienia danych z witryn.

Ładowarki zagnieżdżone

Służy do tworzenia zagnieżdżonych programów ładujących podczas analizowania wartości z podsekcji dokumentu. Jeśli nie tworzysz zagnieżdżonych programów ładujących, musisz określić pełną XPath lub CSS dla każdej wartości, którą chcesz wyodrębnić.

Na przykład załóżmy, że dane są wyodrębniane ze strony nagłówkowej -

<header>
   <a class = "social" href = "http://facebook.com/whatever">facebook</a>
   <a class = "social" href = "http://twitter.com/whatever">twitter</a>
   <a class = "email" href = "mailto:[email protected]">send mail</a>
</header>

Następnie możesz utworzyć zagnieżdżony moduł ładujący z selektorem nagłówka, dodając powiązane wartości do nagłówka -

loader = ItemLoader(item = Item())
header_loader = loader.nested_xpath('//header')
header_loader.add_xpath('social', 'a[@class = "social"]/@href')
header_loader.add_xpath('email', 'a[@class = "email"]/@href')
loader.load_item()

Ponowne używanie i rozszerzanie programów ładujących przedmioty

Moduły ładujące przedmioty zostały zaprojektowane tak, aby odciążyć konserwację, co staje się podstawowym problemem, gdy do projektu przybywa więcej pająków.

Załóżmy na przykład, że witryna ma nazwę produktu zawartą w trzech myślnikach (np. --DVD ---). Możesz usunąć te myślniki, ponownie używając domyślnego modułu ładowania pozycji produktu, jeśli nie chcesz go w nazwach produktów końcowych, jak pokazano w poniższym kodzie -

from scrapy.loader.processors import MapCompose 
from demoproject.ItemLoaders import DemoLoader  

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

class SiteSpecificLoader(DemoLoader): 
   title_in = MapCompose(strip_dashes, DemoLoader.title_in)

Dostępne procesory wbudowane

Poniżej przedstawiono niektóre z powszechnie używanych wbudowanych procesorów -

class scrapy.loader.processors.Identity

Zwraca oryginalną wartość bez jej zmiany. Na przykład -

>>> from scrapy.loader.processors import Identity
>>> proc = Identity()
>>> proc(['a', 'b', 'c'])
['a', 'b', 'c']

class scrapy.loader.processors.TakeFirst

Zwraca pierwszą wartość niezerową / niepustą z listy otrzymanych wartości. Na przykład -

>>> from scrapy.loader.processors import TakeFirst
>>> proc = TakeFirst()
>>> proc(['', 'a', 'b', 'c'])
'a'

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

Zwraca wartość dołączoną do separatora. Domyślnym separatorem jest u '' i jest odpowiednikiem funkcjiu' '.join. Na przykład -

>>> from scrapy.loader.processors import Join
>>> proc = Join()
>>> proc(['a', 'b', 'c'])
u'a b c'
>>> proc = Join('<br>')
>>> proc(['a', 'b', 'c'])
u'a<br>b<br>c'

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

Jest definiowany przez procesor, w którym każda wartość wejściowa jest przekazywana do pierwszej funkcji, a wynik tej funkcji jest przekazywany do drugiej funkcji i tak dalej, aż funkcja ast zwróci wartość końcową jako wyjście.

Na przykład -

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

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

Jest to procesor, w którym wartość wejściowa jest iterowana, a pierwsza funkcja jest stosowana do każdego elementu. Następnie wynik tych wywołań funkcji jest konkatenowany w celu zbudowania nowej iterowalnej, która jest następnie stosowana do drugiej funkcji i tak dalej, aż do ostatniej funkcji.

Na przykład -

>>> def filter_scrapy(x): 
   return None if x == 'scrapy' else x  

>>> from scrapy.loader.processors import MapCompose 
>>> proc = MapCompose(filter_scrapy, unicode.upper) 
>>> proc([u'hi', u'everyone', u'im', u'pythonscrapy']) 
[u'HI, u'IM', u'PYTHONSCRAPY']

class scrapy.loader.processors.SelectJmes (json_path)

Ta klasa odpytuje wartość przy użyciu podanej ścieżki json i zwraca dane wyjściowe.

Na przykład -

>>> from scrapy.loader.processors import SelectJmes, Compose, MapCompose
>>> proc = SelectJmes("hello")
>>> proc({'hello': 'scrapy'})
'scrapy'
>>> proc({'hello': {'scrapy': 'world'}})
{'scrapy': 'world'}

Poniżej znajduje się kod, który wysyła zapytanie o wartość, importując json -

>>> import json
>>> proc_single_json_str = Compose(json.loads, SelectJmes("hello"))
>>> proc_single_json_str('{"hello": "scrapy"}')
u'scrapy'
>>> proc_json_list = Compose(json.loads, MapCompose(SelectJmes('hello')))
>>> proc_json_list('[{"hello":"scrapy"}, {"world":"env"}]')
[u'scrapy']

Opis

Powłoka Scrapy może być używana do usuwania danych z kodem wolnym od błędów, bez użycia pająka. Głównym celem powłoki Scrapy jest testowanie wyodrębnionego kodu, wyrażeń XPath lub CSS. Pomaga także określić strony internetowe, z których pobierasz dane.

Konfigurowanie powłoki

Powłokę można skonfigurować, instalując konsolę IPython (używaną do obliczeń interaktywnych), która jest potężną powłoką interaktywną, która zapewnia automatyczne uzupełnianie, kolorowanie danych wyjściowych itp.

Jeśli pracujesz na platformie Unix, lepiej zainstalować IPython. Możesz także użyć bpython , jeśli IPython jest niedostępny.

Możesz skonfigurować powłokę, ustawiając zmienną środowiskową o nazwie SCRAPY_PYTHON_SHELL lub definiując plik scrapy.cfg w następujący sposób -

[settings]
shell = bpython

Uruchomienie powłoki

Shell Scrapy można uruchomić za pomocą następującego polecenia -

scrapy shell <url>

W URL Określa adres URL, dla którego potrzebuje danych do zgarniania.

Korzystanie z powłoki

Powłoka zapewnia dodatkowe skróty i obiekty Scrapy, jak opisano w poniższej tabeli -

Dostępne skróty

Shell zapewnia następujące dostępne skróty w projekcie -

Sr.No Skrót i opis
1

shelp()

Udostępnia dostępne obiekty i skróty z opcją pomocy.

2

fetch(request_or_url)

Zbiera odpowiedź z żądania lub adresu URL, a powiązane obiekty zostaną poprawnie zaktualizowane.

3

view(response)

Możesz wyświetlić odpowiedź na dane żądanie w lokalnej przeglądarce w celu obserwacji i aby poprawnie wyświetlić link zewnętrzny, dołącza znacznik podstawowy do treści odpowiedzi.

Dostępne obiekty złomowania

Shell zapewnia następujące dostępne obiekty Scrapy w projekcie -

Sr.No Obiekt i opis
1

crawler

Określa bieżący obiekt przeszukiwacza.

2

spider

Jeśli nie ma pająka dla obecnego adresu URL, obsłuży adres URL lub obiekt pająka, definiując nowy pająk.

3

request

Określa obiekt żądania dla ostatnio zebranej strony.

4

response

Określa obiekt odpowiedzi dla ostatnio zebranej strony.

5

settings

Zawiera aktualne ustawienia Scrapy.

Przykład sesji powłoki

Spróbujmy zeskrobać stronę scrapy.org, a następnie zacznijmy zgarniać dane z reddit.com zgodnie z opisem.

Zanim przejdziemy dalej, najpierw uruchomimy powłokę, jak pokazano w następującym poleceniu -

scrapy shell 'http://scrapy.org' --nolog

Scrapy wyświetli dostępne obiekty podczas korzystania z powyższego adresu URL -

[s] Available Scrapy objects:
[s]   crawler    <scrapy.crawler.Crawler object at 0x1e16b50>
[s]   item       {}
[s]   request    <GET http://scrapy.org >
[s]   response   <200 http://scrapy.org >
[s]   settings   <scrapy.settings.Settings object at 0x2bfd650>
[s]   spider     <Spider 'default' at 0x20c6f50>
[s] Useful shortcuts:
[s]   shelp()           Provides available objects and shortcuts with help option
[s]   fetch(req_or_url) Collects the response from the request or URL and associated 
objects will get update
[s]   view(response)    View the response for the given request

Następnie zacznij od pracy z obiektami, pokazanymi w następujący sposób -

>> response.xpath('//title/text()').extract_first() 
u'Scrapy | A Fast and Powerful Scraping and Web Crawling Framework'  
>> fetch("http://reddit.com") 
[s] Available Scrapy objects: 
[s]   crawler     
[s]   item       {} 
[s]   request     
[s]   response   <200 https://www.reddit.com/> 
[s]   settings    
[s]   spider      
[s] Useful shortcuts: 
[s]   shelp()           Shell help (print this help) 
[s]   fetch(req_or_url) Fetch request (or URL) and update local objects 
[s]   view(response)    View response in a browser  
>> response.xpath('//title/text()').extract() 
[u'reddit: the front page of the internet']  
>> request = request.replace(method="POST")  
>> fetch(request) 
[s] Available Scrapy objects: 
[s]   crawler     
...

Wywołanie powłoki od pająków w celu sprawdzenia odpowiedzi

Możesz sprawdzić odpowiedzi, które są przetwarzane przez pająka, tylko jeśli spodziewasz się tej odpowiedzi.

Na przykład -

import scrapy 

class SpiderDemo(scrapy.Spider): 
   name = "spiderdemo" 
   start_urls = [ 
      "http://mysite.com", 
      "http://mysite1.org", 
      "http://mysite2.net", 
   ]  
   
   def parse(self, response): 
      # You can inspect one specific response 
      if ".net" in response.url: 
         from scrapy.shell import inspect_response 
         inspect_response(response, self)

Jak pokazano w powyższym kodzie, możesz wywołać powłokę z pająków, aby sprawdzić odpowiedzi, używając następującej funkcji -

scrapy.shell.inspect_response

Teraz uruchom pająka, a pojawi się następujący ekran -

2016-02-08 18:15:20-0400 [scrapy] DEBUG: Crawled (200)  (referer: None) 
2016-02-08 18:15:20-0400 [scrapy] DEBUG: Crawled (200)  (referer: None) 
2016-02-08 18:15:20-0400 [scrapy] DEBUG: Crawled (200)  (referer: None) 
[s] Available Scrapy objects: 
[s]   crawler     
...  
>> response.url 
'http://mysite2.org'

Możesz sprawdzić, czy wyodrębniony kod działa, używając następującego kodu -

>> response.xpath('//div[@class = "val"]')

Wyświetla dane wyjściowe jako

[]

Powyższa linia wyświetla tylko puste wyjście. Teraz możesz wywołać powłokę, aby sprawdzić odpowiedź w następujący sposób -

>> view(response)

Wyświetla odpowiedź jako

True

Opis

Item Pipelineto metoda, w której przetwarzane są złomowane elementy. Gdy przedmiot jest wysyłany do rurociągu przedmiotów, jest zeskrobywany przez pająka i przetwarzany przy użyciu kilku komponentów, które są wykonywane sekwencyjnie.

Za każdym razem, gdy otrzyma przedmiot, podejmuje decyzję o jednej z następujących czynności -

  • Kontynuuj przetwarzanie pozycji.
  • Zrzuć to z rurociągu.
  • Zatrzymaj przetwarzanie pozycji.

Potoki pozycji są zwykle używane do następujących celów -

  • Przechowywanie pobranych elementów w bazie danych.
  • Jeśli otrzymany element zostanie powtórzony, porzuci powtarzający się element.
  • Sprawdza, czy element zawiera pola docelowe.
  • Czyszczenie danych HTML.

Składnia

Możesz napisać plan pozycji za pomocą następującej metody -

process_item(self, item, spider)

Powyższa metoda zawiera następujące parametry -

  • Pozycja (obiekt lub słownik) - określa pobierany element.
  • pająk (obiekt pająka) - Pająk, który zeskrobał przedmiot.

Możesz użyć dodatkowych metod podanych w poniższej tabeli -

Sr.No Metoda i opis Parametry
1

open_spider(self, spider)

Jest wybierany, gdy pająk jest otwarty.

pająk (obiekt pająka) - odnosi się do pająka, który został otwarty.

2

close_spider(self, spider)

Jest wybierany, gdy pająk jest zamknięty.

pająk (obiekt pająka) - Odnosi się do pająka, który został zamknięty.

3

from_crawler(cls, crawler)

Z pomocą robota, potok może uzyskać dostęp do podstawowych komponentów, takich jak sygnały i ustawienia Scrapy.

robot indeksujący (obiekt robota) - odnosi się do robota używającego tego potoku.

Przykład

Poniżej przedstawiono przykłady potoku pozycji używanego w różnych koncepcjach.

Upuszczanie przedmiotów bez tagu

W poniższym kodzie potok równoważy atrybut (cena) dla tych produktów, które nie zawierają podatku VAT (atrybut excludes_vat) i ignoruje te produkty, które nie mają metki z ceną -

from Scrapy.exceptions import DropItem  
class PricePipeline(object): 
   vat = 2.25 

   def process_item(self, item, spider): 
      if item['price']: 
         if item['excludes_vat']: 
            item['price'] = item['price'] * self.vat 
            return item 
         else: 
            raise DropItem("Missing price in %s" % item)

Zapisywanie elementów do pliku JSON

Poniższy kod przechowuje wszystkie zeskrobane elementy wszystkich pająków w jednym items.jlplik, który zawiera jeden element w każdym wierszu w postaci serializowanej w formacie JSON. PlikJsonWriterPipeline klasa jest używana w kodzie, aby pokazać, jak pisać potok elementów -

import json  

class JsonWriterPipeline(object): 
   def __init__(self): 
      self.file = open('items.jl', 'wb') 

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

Pisanie elementów do MongoDB

Możesz określić adres MongoDB i nazwę bazy danych w ustawieniach Scrapy, a kolekcja MongoDB może zostać nazwana po klasie elementu. Poniższy kod opisuje, jak używaćfrom_crawler() sposób prawidłowego gromadzenia zasobów -

import pymongo  

class MongoPipeline(object):  
   collection_name = 'Scrapy_list' 

   def __init__(self, mongo_uri, mongo_db): 
      self.mongo_uri = mongo_uri 
      self.mongo_db = mongo_db 

   @classmethod 
   def from_crawler(cls, crawler): 
      return cls( 
         mongo_uri = crawler.settings.get('MONGO_URI'), 
         mongo_db = crawler.settings.get('MONGO_DB', 'lists') 
      ) 
  
   def open_spider(self, spider): 
      self.client = pymongo.MongoClient(self.mongo_uri) 
      self.db = self.client[self.mongo_db] 

   def close_spider(self, spider): 
      self.client.close() 

   def process_item(self, item, spider): 
      self.db[self.collection_name].insert(dict(item)) 
      return item

Powielanie filtrów

Filtr sprawdzi powtarzające się pozycje i usunie już przetworzone pozycje. W poniższym kodzie użyliśmy unikalnego identyfikatora dla naszych produktów, ale pająk zwraca wiele elementów z tym samym identyfikatorem -

from scrapy.exceptions import DropItem  

class DuplicatesPipeline(object):  
   def __init__(self): 
      self.ids_seen = set() 

   def process_item(self, item, spider): 
      if item['id'] in self.ids_seen: 
         raise DropItem("Repeated items found: %s" % item) 
      else: 
         self.ids_seen.add(item['id']) 
         return item

Aktywacja potoku pozycji

Można aktywować składnik potoku pozycji, dodając jego klasę do ustawienia ITEM_PIPELINES , jak pokazano w poniższym kodzie. Możesz przypisać wartości całkowite do klas w kolejności, w jakiej działają (kolejność może mieć niższą wartość do klas o wyższej wartości), a wartości będą w zakresie 0-1000.

ITEM_PIPELINES = {
   'myproject.pipelines.PricePipeline': 100,
   'myproject.pipelines.JsonWriterPipeline': 600,
}

Opis

Eksportowanie plików danych to metoda przechowywania danych pobranych z witryn, czyli generowanie pliku "export file".

Formaty serializacji

Korzystając z wielu formatów serializacji i zaplecza pamięci masowej, funkcja eksportu kanałów korzysta z eksporterów elementów i generuje kanał ze skrobanymi elementami.

Poniższa tabela przedstawia obsługiwane formaty -

Sr.No Format i opis
1

JSON

FEED_FORMAT to json

Użyty eksporter to klasa scrapy.exporters.JsonItemExporter

2

JSON lines

FEED_FROMAT to jsonlines

Użyty eksporter to klasa scrapy.exporters.JsonLinesItemExporter

3

CSV

FEED_FORMAT to CSV

Użyty eksporter to class scrapy.exporters.CsvItemExporter

4

XML

FEED_FORMAT to XML

Użyty eksporter to klasa scrapy.exporters.XmlItemExporter

Za pomocą FEED_EXPORTERS ustawienia, obsługiwane formaty można również rozszerzyć -

Sr.No Format i opis
1

Pickle

FEED_FORMAT to pikiel

Użyty eksporter to klasa scrapy.exporters.PickleItemExporter

2

Marshal

FEED_FORMAT jest marszałkiem

Użyty eksporter to klasa scrapy.exporters.MarshalItemExporter

Backendy pamięci masowej

Zaplecze pamięci masowej definiuje miejsce przechowywania źródła przy użyciu identyfikatora URI.

Poniższa tabela przedstawia obsługiwane backendy pamięci masowej -

Sr.No Pamięć masowa i opis
1

Local filesystem

Schemat URI jest plikiem i służy do przechowywania kanałów.

2

FTP

Schemat URI to ftp i jest używany do przechowywania kanałów.

3

S3

Schemat URI to S3, a źródła danych są przechowywane w Amazon S3. Wymagane są biblioteki zewnętrzne botocore lub boto .

4

Standard output

Schemat URI to standardowe wyjście, a źródła danych są przechowywane na standardowym wyjściu.

Parametry identyfikatora URI magazynu

Poniżej znajdują się parametry adresu URL przechowywania, który jest zastępowany podczas tworzenia kanału -

  • % (czas) s: ten parametr jest zastępowany znacznikiem czasu.
  • % (name) s: Ten parametr jest zastępowany nazwą pająka.

Ustawienia

Poniższa tabela przedstawia ustawienia, za pomocą których można skonfigurować eksport plików danych -

Sr.No Ustawienie i opis
1

FEED_URI

Jest to identyfikator URI źródła eksportu używanego do umożliwienia eksportu paszy.

2

FEED_FORMAT

Jest to format serializacji używany w źródle treści.

3

FEED_EXPORT_FIELDS

Służy do definiowania pól, które mają zostać wyeksportowane.

4

FEED_STORE_EMPTY

Określa, czy eksportować pliki danych bez elementów.

5

FEED_STORAGES

Jest to słownik z dodatkowymi backendami do przechowywania plików.

6

FEED_STORAGES_BASE

Jest to słownik z wbudowanymi backendami do przechowywania danych.

7

FEED_EXPORTERS

Jest to słownik z dodatkowymi eksporterami pasz.

8

FEED_EXPORTERS_BASE

Jest to słownik z wbudowanymi eksporterami kanałów.

Opis

Scrapy może indeksować witryny internetowe przy użyciu rozszerzenia Request i Responseobiekty. Obiekty żądania przechodzą przez system, używają pająków do wykonania żądania i wracają do żądania, gdy zwraca obiekt odpowiedzi.

Zażądaj obiektów

Obiekt żądania jest żądaniem HTTP, które generuje odpowiedź. Ma następującą klasę -

class scrapy.http.Request(url[, callback, method = 'GET', headers, body, cookies, meta,
   encoding = 'utf-8', priority = 0, dont_filter = False, errback])

Poniższa tabela przedstawia parametry obiektów Request -

Sr.No Parametr i opis
1

url

Jest to ciąg określający żądanie adresu URL.

2

callback

Jest to funkcja wywoływalna, która używa odpowiedzi żądania jako pierwszego parametru.

3

method

Jest to ciąg określający żądanie metody HTTP.

4

headers

Jest to słownik z nagłówkami żądań.

5

body

Jest to ciąg znaków lub Unicode, który ma treść żądania.

6

cookies

Jest to lista zawierająca pliki cookie żądań.

7

meta

Jest to słownik zawierający wartości dla metadanych żądania.

8

encoding

Jest to ciąg znaków zawierający kodowanie utf-8 używane do kodowania adresu URL.

9

priority

Jest to liczba całkowita, w przypadku której program planujący używa priorytetu do definiowania kolejności przetwarzania żądań.

10

dont_filter

Jest to wartość logiczna określająca, że ​​program planujący nie powinien filtrować żądania.

11

errback

Jest to funkcja wywoływalna, która jest wywoływana, gdy zostanie zgłoszony wyjątek podczas przetwarzania żądania.

Przekazywanie dodatkowych danych do funkcji wywołania zwrotnego

Funkcja wywołania zwrotnego żądania jest wywoływana, gdy odpowiedź jest pobierana jako jej pierwszy parametr.

Na przykład -

def parse_page1(self, response): 
   return scrapy.Request("http://www.something.com/some_page.html", 
      callback = self.parse_page2)  

def parse_page2(self, response): 
   self.logger.info("%s page visited", response.url)

Możesz użyć Request.meta atrybut, jeśli chcesz przekazać argumenty do funkcji wywoływalnych i odebrać te argumenty w drugim wywołaniu zwrotnym, jak pokazano w poniższym przykładzie -

def parse_page1(self, response): 
   item = DemoItem() 
   item['foremost_link'] = response.url 
   request = scrapy.Request("http://www.something.com/some_page.html", 
      callback = self.parse_page2) 
   request.meta['item'] = item 
   return request  

def parse_page2(self, response): 
   item = response.meta['item'] 
   item['other_link'] = response.url 
   return item

Używanie błędów zwrotnych do wychwytywania wyjątków w przetwarzaniu żądań

Errback to wywoływalna funkcja, która jest wywoływana, gdy zostanie zgłoszony wyjątek podczas przetwarzania żądania.

Poniższy przykład demonstruje to -

import scrapy  

from scrapy.spidermiddlewares.httperror import HttpError 
from twisted.internet.error import DNSLookupError 
from twisted.internet.error import TimeoutError, TCPTimedOutError  

class DemoSpider(scrapy.Spider): 
   name = "demo" 
   start_urls = [ 
      "http://www.httpbin.org/",              # HTTP 200 expected 
      "http://www.httpbin.org/status/404",    # Webpage not found  
      "http://www.httpbin.org/status/500",    # Internal server error 
      "http://www.httpbin.org:12345/",        # timeout expected 
      "http://www.httphttpbinbin.org/",       # DNS error expected 
   ]  
   
   def start_requests(self): 
      for u in self.start_urls: 
         yield scrapy.Request(u, callback = self.parse_httpbin, 
         errback = self.errback_httpbin, 
         dont_filter=True)  
   
   def parse_httpbin(self, response): 
      self.logger.info('Recieved response from {}'.format(response.url)) 
      # ...  
   
   def errback_httpbin(self, failure): 
      # logs failures 
      self.logger.error(repr(failure))  
      
      if failure.check(HttpError): 
         response = failure.value.response 
         self.logger.error("HttpError occurred on %s", response.url)  
      
      elif failure.check(DNSLookupError): 
         request = failure.request 
         self.logger.error("DNSLookupError occurred on %s", request.url) 

      elif failure.check(TimeoutError, TCPTimedOutError): 
         request = failure.request 
         self.logger.error("TimeoutError occurred on %s", request.url)

Request.meta Special Keys

Klucze specjalne request.meta to lista specjalnych kluczy meta identyfikowanych przez Scrapy.

Poniższa tabela przedstawia niektóre z kluczy Request.meta -

Sr.No Klucz i opis
1

dont_redirect

Jest to klucz, gdy jest ustawiony na true, nie przekierowuje żądania na podstawie statusu odpowiedzi.

2

dont_retry

Po ustawieniu wartości true jest kluczem, nie ponawia żądań zakończonych niepowodzeniem i zostanie zignorowany przez oprogramowanie pośredniczące.

3

handle_httpstatus_list

Jest to klucz definiujący, które kody odpowiedzi na żądanie mogą być dozwolone.

4

handle_httpstatus_all

Jest to klucz używany do zezwalania na dowolny kod odpowiedzi na żądanie poprzez ustawienie wartości true .

5

dont_merge_cookies

Jest to klucz używany do uniknięcia łączenia się z istniejącymi plikami cookie poprzez ustawienie wartości true .

6

cookiejar

Jest to klucz używany do utrzymywania wielu sesji plików cookie na pająka.

7

dont_cache

Jest to klucz używany do unikania buforowania żądań HTTP i odpowiedzi w każdej polityce.

8

redirect_urls

Jest to klucz zawierający adresy URL, przez które przechodzą żądania.

9

bindaddress

Jest to adres IP wychodzącego adresu IP, którego można użyć do wykonania żądania.

10

dont_obey_robotstxt

Jest to klucz, gdy ma wartość true, nie filtruje żądań zabronionych przez standard wykluczania pliku robots.txt, nawet jeśli włączony jest ROBOTSTXT_OBEY.

11

download_timeout

Służy do ustawiania limitu czasu (w sekundach) na pająka, na który downloader będzie czekał, zanim upłynie limit czasu.

12

download_maxsize

Służy do ustawienia maksymalnego rozmiaru (w bajtach) na pająka, który pobierze downloader.

13

proxy

Proxy można ustawić dla obiektów Request, aby ustawić proxy HTTP do używania żądań.

Poproś o podklasy

Możesz zaimplementować własną niestandardową funkcjonalność, tworząc podklasę klasy żądania. Wbudowane podklasy żądań są następujące -

Obiekty FormRequest

Klasa FormRequest obsługuje formularze HTML poprzez rozszerzenie żądania podstawowego. Ma następującą klasę -

class scrapy.http.FormRequest(url[,formdata, callback, method = 'GET', headers, body, 
   cookies, meta, encoding = 'utf-8', priority = 0, dont_filter = False, errback])

Poniżej znajduje się parametr -

formdata - Jest to słownik zawierający dane formularza HTML, które są przypisane do treści żądania.

Note - Pozostałe parametry są takie same jak klasa żądania i zostały wyjaśnione w Request Objects Sekcja.

Następujące metody klas są obsługiwane przez FormRequest obiekty oprócz metod żądania -

classmethod from_response(response[, formname = None, formnumber = 0, formdata = None, 
   formxpath = None, formcss = None, clickdata = None, dont_click = False, ...])

Poniższa tabela przedstawia parametry powyższej klasy -

Sr.No Parametr i opis
1

response

Jest to obiekt używany do wstępnego wypełniania pól formularza przy użyciu formularza odpowiedzi HTML.

2

formname

Jest to ciąg znaków, w którym zostanie użyty formularz z atrybutem nazwy, jeśli został określony.

3

formnumber

Jest to liczba całkowita form, których należy używać, gdy odpowiedź zawiera wiele formularzy.

4

formdata

Jest to słownik pól w danych formularza służących do nadpisywania.

5

formxpath

Jest to ciąg znaków, jeśli jest określony, używana jest forma pasująca do ścieżki xpath.

6

formcss

Jest to ciąg znaków, jeśli jest określony, używana jest forma pasująca do selektora css.

7

clickdata

Jest to słownik atrybutów używany do obserwowania klikniętej kontrolki.

8

dont_click

Dane z formularza zostaną przesłane bez klikania żadnego elementu, jeśli ustawione na true.

Przykłady

Oto niektóre przykłady użycia żądań -

Using FormRequest to send data via HTTP POST

Poniższy kod ilustruje sposób zwracania FormRequest obiekt, gdy chcesz zduplikować formularz HTML POST w swoim pająku -

return [FormRequest(url = "http://www.something.com/post/action", 
   formdata = {'firstname': 'John', 'lastname': 'dave'}, 
   callback = self.after_post)]

Using FormRequest.from_response() to simulate a user login

Zwykle strony internetowe wykorzystują elementy, za pomocą których udostępniają wstępnie wypełnione pola formularzy.

Plik FormRequest.form_response() można użyć, jeśli chcesz, aby te pola były automatycznie wypełniane podczas skrobania.

Poniższy przykład ilustruje to.

import scrapy  
class DemoSpider(scrapy.Spider): 
   name = 'demo' 
   start_urls = ['http://www.something.com/users/login.php']  
   def parse(self, response): 
      return scrapy.FormRequest.from_response( 
         response, 
         formdata = {'username': 'admin', 'password': 'confidential'}, 
         callback = self.after_login 
      )  
   
   def after_login(self, response): 
      if "authentication failed" in response.body: 
         self.logger.error("Login failed") 
         return  
      # You can continue scraping here

Obiekty odpowiedzi

Jest to obiekt wskazujący odpowiedź HTTP, która jest przekazywana pająkom do przetworzenia. Ma następującą klasę -

class scrapy.http.Response(url[, status = 200, headers, body, flags])

W poniższej tabeli przedstawiono parametry obiektów Response -

Sr.No Parametr i opis
1

url

Jest to ciąg określający odpowiedź adresu URL.

2

status

Jest to liczba całkowita zawierająca odpowiedź stanu HTTP.

3

headers

Jest to słownik zawierający nagłówki odpowiedzi.

4

body

Jest to łańcuch z treścią odpowiedzi.

5

flags

Jest to lista zawierająca flagi odpowiedzi.

Podklasy odpowiedzi

Możesz zaimplementować własną niestandardową funkcjonalność, podklasując klasę odpowiedzi. Wbudowane podklasy odpowiedzi są następujące -

TextResponse objects

Obiekty TextResponse są używane dla danych binarnych, takich jak obrazy, dźwięki itp., Które mają możliwość kodowania podstawowej klasy Response. Ma następującą klasę -

class scrapy.http.TextResponse(url[, encoding[,status = 200, headers, body, flags]])

Poniżej znajduje się parametr -

encoding - Jest to ciąg z kodowaniem, który służy do kodowania odpowiedzi.

Note - Pozostałe parametry są takie same jak klasa odpowiedzi i wyjaśniono je w Response Objects Sekcja.

Poniższa tabela przedstawia atrybuty obsługiwane przez obiekt TextResponse oprócz metod odpowiedzi -

Sr.No Atrybut i opis
1

text

Jest to treść odpowiedzi, do której można uzyskać dostęp wielokrotnie.

2

encoding

Jest to ciąg zawierający kodowanie odpowiedzi.

3

selector

Jest to atrybut, którego instancja jest tworzona przy pierwszym dostępie i używa odpowiedzi jako celu.

W poniższej tabeli przedstawiono metody obsługiwane przez obiekty TextResponse oprócz metod odpowiedzi -

Sr.No Metoda i opis
1

xpath (query)

Jest to skrót do TextResponse.selector.xpath (zapytanie).

2

css (query)

Jest to skrót do TextResponse.selector.css (zapytania).

3

body_as_unicode()

Jest to treść odpowiedzi dostępna jako metoda, do której można uzyskać dostęp wielokrotnie.

Obiekty HtmlResponse

Jest to obiekt, który obsługuje kodowanie i automatyczne wykrywanie poprzez sprawdzenie atrybutu meta httpequiv w HTML. Jego parametry są takie same jak w klasie odpowiedzi i zostały wyjaśnione w sekcji Obiekty odpowiedzi. Ma następującą klasę -

class scrapy.http.HtmlResponse(url[,status = 200, headers, body, flags])

Obiekty XmlResponse

Jest to obiekt, który obsługuje kodowanie i automatyczne wykrywanie, patrząc na wiersz XML. Jego parametry są takie same jak w klasie odpowiedzi i zostały wyjaśnione w sekcji Obiekty odpowiedzi. Ma następującą klasę -

class scrapy.http.XmlResponse(url[, status = 200, headers, body, flags])

Opis

Jak sama nazwa wskazuje, Link Extractors to obiekty używane do wyodrębniania linków ze stron internetowych za pomocą scrapy.http.Responseobiekty. W Scrapy są wbudowane ekstraktory, takie jakscrapy.linkextractors import LinkExtractor. Możesz dostosować swój własny ekstraktor linków do swoich potrzeb, implementując prosty interfejs.

Każdy ekstraktor linków ma publiczną metodę o nazwie extract_linksktóry zawiera obiekt Response i zwraca listę obiektów scrapy.link.Link. Możesz utworzyć instancję ekstraktorów linków tylko raz i wywołać metodę extract_links kilka razy, aby wyodrębnić linki z różnymi odpowiedziami. CrawlSpiderclass używa ekstraktorów linków z zestawem reguł, których głównym celem jest wyodrębnianie linków.

Wbudowane odniesienie do ekstrakcji linków

Zwykle narzędzia do ekstrakcji linków są zgrupowane w Scrapy i są dostarczane w module scrapy.linkextractors. Domyślnie ekstraktorem linków będzie LinkExtractor, który ma taką samą funkcjonalność jak LxmlLinkExtractor -

from scrapy.linkextractors import LinkExtractor

LxmlLinkExtractor

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

LxmlLinkExtractor jest wysoce zalecane łącza wyciąg, ponieważ ma przydatnych opcji filtrowania i jest używany z lxml za solidną HTMLParser.

Sr.No Parametr i opis
1

allow (wyrażenie regularne (lub lista))

Pozwala na pojedyncze wyrażenie lub grupę wyrażeń, które powinny pasować do adresu URL, który ma zostać wyodrębniony. Jeśli nie zostanie wymieniony, będzie pasować do wszystkich linków.

2

deny (wyrażenie regularne (lub lista))

Blokuje lub wyklucza pojedyncze wyrażenie lub grupę wyrażeń, które powinny pasować do adresu URL, który nie ma zostać wyodrębniony. Jeśli nie zostanie wymieniony lub pozostawiony pusty, nie usunie niepożądanych linków.

3

allow_domains (str lub lista)

Pozwala na pojedynczy ciąg lub listę ciągów, które powinny pasować do domen, z których mają być wyodrębnione linki.

4

deny_domains (str lub lista)

Blokuje lub wyklucza pojedynczy ciąg lub listę ciągów, które powinny pasować do domen, z których nie mają być wyciągane linki.

5

deny_extensions (lista)

Blokuje listę ciągów z rozszerzeniami podczas wyodrębniania linków. Jeśli nie jest ustawiona, to domyślnie zostanie ustawiona na IGNORED_EXTENSIONS, która zawiera predefiniowaną listę w pakiecie scrapy.linkextractors .

6

restrict_xpaths (str lub lista)

Jest to region listy XPath, z którego mają zostać wyodrębnione łącza z odpowiedzi. Jeśli podane, linki zostaną wyodrębnione tylko z tekstu, który jest wybrany przez XPath.

7

restrict_css (str lub lista)

Zachowuje się podobnie do parametru ogranicz_xpaths, który wyodrębnia linki z wybranych regionów CSS w odpowiedzi.

8

tags (str lub lista)

Pojedynczy tag lub lista tagów, które należy wziąć pod uwagę podczas wyodrębniania linków. Domyślnie będzie to ('a', 'area').

9

attrs (lista)

Podczas wyodrębniania linków należy wziąć pod uwagę pojedynczy atrybut lub listę atrybutów. Domyślnie będzie to ('href',).

10

canonicalize (logiczna)

Wyodrębniony adres URL jest przenoszony do standardowej postaci za pomocą scrapy.utils.url.canonicalize_url . Domyślnie będzie to prawda.

11

unique (logiczna)

Będzie używany, jeśli wyodrębnione linki zostaną powtórzone.

12

process_value (wywoływane)

Jest to funkcja, która otrzymuje wartość z zeskanowanych tagów i atrybutów. Otrzymana wartość może zostać zmieniona i zwrócona, w przeciwnym razie nic nie zostanie zwrócone, aby odrzucić link. Jeśli nie jest używany, domyślnie będzie to lambda x: x.

Przykład

Poniższy kod służy do wyodrębnienia linków -

<a href = "javascript:goToPage('../other/page.html'); return false">Link text</a>

Następująca funkcja kodu może być używana w wartość_procesu -

def process_value(val): 
   m = re.search("javascript:goToPage\('(.*?)'", val) 
   if m: 
      return m.group(1)

Opis

Zachowanie komponentów Scrapy można modyfikować za pomocą ustawień Scrapy. Ustawienia mogą również wybrać projekt Scrapy, który jest obecnie aktywny, w przypadku gdy masz wiele projektów Scrapy.

Wyznaczanie ustawień

Musisz powiadomić Scrapy, którego ustawienia używasz, kiedy usuwasz witrynę. W tym celu zmienna środowiskowaSCRAPY_SETTINGS_MODULE powinno być używane, a jego wartość powinna być zgodna ze składnią ścieżki w języku Python.

Wypełnianie ustawień

W poniższej tabeli przedstawiono niektóre mechanizmy, za pomocą których można wypełnić ustawienia -

Sr.No Mechanizm i opis
1

Command line options

W tym przypadku argumenty, które są przekazywane, mają najwyższy priorytet, zastępując inne opcje. -S służy do zastępowania jednego lub więcej ustawień.

scrapy crawl myspider -s LOG_FILE = scrapy.log
2

Settings per-spider

Pająki mogą mieć własne ustawienia, które zastępują ustawienia projektu przy użyciu atrybutu custom_settings.

class DemoSpider(scrapy.Spider): 
   name = 'demo'  
   custom_settings = { 
      'SOME_SETTING': 'some value', 
   }
3

Project settings module

Tutaj możesz wypełnić swoje ustawienia niestandardowe, takie jak dodawanie lub modyfikowanie ustawień w pliku settings.py.

4

Default settings per-command

Każde polecenie narzędzia Scrapy definiuje własne ustawienia w atrybucie default_settings, aby zastąpić globalne ustawienia domyślne.

5

Default global settings

Te ustawienia można znaleźć w module scrapy.settings.default_settings.

Ustawienia dostępu

Są dostępne poprzez ustawienia self i ustawiane w pająku podstawowym po jego zainicjowaniu.

Poniższy przykład ilustruje to.

class DemoSpider(scrapy.Spider): 
   name = 'demo' 
   start_urls = ['http://example.com']  
   def parse(self, response): 
      print("Existing settings: %s" % self.settings.attributes.keys())

Aby użyć ustawień przed inicjalizacją pająka, musisz nadpisać metodę from_crawler w metodzie _init_ () twojego pająka. Dostęp do ustawień można uzyskać za pośrednictwem atrybutu scrapy.crawler.Crawler.settings przekazanego do metody from_crawler .

Poniższy przykład ilustruje to.

class MyExtension(object): 
   def __init__(self, log_is_enabled = False): 
      if log_is_enabled: 
         print("Enabled log") 
         @classmethod 
   def from_crawler(cls, crawler): 
      settings = crawler.settings 
      return cls(settings.getbool('LOG_ENABLED'))

Uzasadnienie nadawania nazw

Nazwy ustawień są dodawane jako przedrostek do konfigurowanego przez nie komponentu. Na przykład w przypadku rozszerzenia robots.txt nazwy ustawień mogą mieć postać ROBOTSTXT_ENABLED, ROBOTSTXT_OBEY, ROBOTSTXT_CACHEDIR itp.

Odniesienie do wbudowanych ustawień

Poniższa tabela przedstawia wbudowane ustawienia Scrapy -

Sr.No Ustawienie i opis
1

AWS_ACCESS_KEY_ID

Służy do uzyskiwania dostępu do Amazon Web Services.

Wartość domyślna: brak

2

AWS_SECRET_ACCESS_KEY

Służy do uzyskiwania dostępu do Amazon Web Services.

Wartość domyślna: brak

3

BOT_NAME

Jest to nazwa bota, którego można użyć do zbudowania User-Agent.

Wartość domyślna: „scrapybot”

4

CONCURRENT_ITEMS

Maksymalna liczba istniejących pozycji w procesorze elementów używanych do przetwarzania równoległego.

Wartość domyślna: 100

5

CONCURRENT_REQUESTS

Maksymalna liczba istniejących żądań, które wykonuje downloader Scrapy.

Wartość domyślna: 16

6

CONCURRENT_REQUESTS_PER_DOMAIN

Maksymalna liczba istniejących żądań, które są wykonywane jednocześnie dla dowolnej domeny.

Wartość domyślna: 8

7

CONCURRENT_REQUESTS_PER_IP

Maksymalna liczba istniejących żądań wykonywanych jednocześnie dla dowolnego pojedynczego adresu IP.

Wartość domyślna: 0

8

DEFAULT_ITEM_CLASS

Jest to klasa używana do reprezentowania przedmiotów.

Wartość domyślna: „scrapy.item.Item”

9

DEFAULT_REQUEST_HEADERS

Jest to domyślny nagłówek używany dla żądań HTTP Scrapy.

Wartość domyślna -

{  
   'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,
	*/*;q=0.8', 'Accept-Language': 'en',  
}
10

DEPTH_LIMIT

Maksymalna głębokość indeksowania dowolnej witryny przez pająka.

Wartość domyślna: 0

11

DEPTH_PRIORITY

Jest to liczba całkowita używana do zmiany priorytetu żądania w zależności od głębokości.

Wartość domyślna: 0

12

DEPTH_STATS

Określa, czy zbierać statystyki głębokości, czy nie.

Wartość domyślna: True

13

DEPTH_STATS_VERBOSE

Po włączeniu tego ustawienia liczba żądań jest gromadzona w statystykach dla każdej szczegółowej głębokości.

Wartość domyślna: False

14

DNSCACHE_ENABLED

Służy do włączania DNS w pamięci podręcznej.

Wartość domyślna: True

15

DNSCACHE_SIZE

Definiuje rozmiar DNS w pamięci podręcznej.

Wartość domyślna: 10000

16

DNS_TIMEOUT

Służy do ustawiania limitu czasu dla DNS do przetwarzania zapytań.

Wartość domyślna: 60

17

DOWNLOADER

Jest to downloader używany do procesu indeksowania.

Wartość domyślna: „scrapy.core.downloader.Downloader”

18

DOWNLOADER_MIDDLEWARES

Jest to słownik zawierający oprogramowanie pośredniczące do pobierania i ich zamówienia.

Domyślna wartość: {}

19

DOWNLOADER_MIDDLEWARES_BASE

Jest to słownik zawierający oprogramowanie pośredniczące pobierania, które jest domyślnie włączone.

Wartość domyślna -

{ 'scrapy.downloadermiddlewares.robotstxt.RobotsTxtMiddleware': 100, }
20

DOWNLOADER_STATS

To ustawienie służy do włączania statystyk pobierania.

Wartość domyślna: True

21

DOWNLOAD_DELAY

Określa całkowity czas pobierania, zanim pobierze strony z witryny.

Wartość domyślna: 0

22

DOWNLOAD_HANDLERS

Jest to słownik z programami do pobierania.

Domyślna wartość: {}

23

DOWNLOAD_HANDLERS_BASE

Jest to słownik z programami obsługi pobierania, który jest domyślnie włączony.

Wartość domyślna -

{ 'file': 'scrapy.core.downloader.handlers.file.FileDownloadHandler', }
24

DOWNLOAD_TIMEOUT

Jest to łączny czas, przez jaki downloader musi czekać, zanim upłynie limit czasu.

Wartość domyślna: 180

25

DOWNLOAD_MAXSIZE

Jest to maksymalny rozmiar odpowiedzi, jaki może pobrać program do pobierania.

Wartość domyślna: 1073741824 (1024 MB)

26

DOWNLOAD_WARNSIZE

Definiuje rozmiar odpowiedzi, którą downloader ma ostrzec.

Wartość domyślna: 33554432 (32 MB)

27

DUPEFILTER_CLASS

Jest to klasa używana do wykrywania i filtrowania żądań, które są zduplikowane.

Wartość domyślna: „scrapy.dupefilters.RFPDupeFilter”

28

DUPEFILTER_DEBUG

To ustawienie rejestruje wszystkie zduplikowane filtry, gdy ma wartość true.

Wartość domyślna: False

29

EDITOR

Służy do edycji pająków za pomocą polecenia edit.

Wartość domyślna: zależy od środowiska

30

EXTENSIONS

Jest to słownik z rozszerzeniami, które są włączone w projekcie.

Domyślna wartość: {}

31

EXTENSIONS_BASE

Jest to słownik mający wbudowane rozszerzenia.

Wartość domyślna: {'scrapy.extensions.corestats.CoreStats': 0,}

32

FEED_TEMPDIR

Jest to katalog używany do ustawiania folderu niestandardowego, w którym mogą być przechowywane pliki tymczasowe przeszukiwacza.

33

ITEM_PIPELINES

Jest to słownik zawierający potoki.

Domyślna wartość: {}

34

LOG_ENABLED

Określa, czy logowanie ma być włączone.

Wartość domyślna: True

35

LOG_ENCODING

Określa typ kodowania, który ma być używany do logowania.

Wartość domyślna: „utf-8”

36

LOG_FILE

Jest to nazwa pliku, który ma być używany do zapisywania w dzienniku.

Wartość domyślna: brak

37

LOG_FORMAT

Jest to ciąg znaków, za pomocą którego można sformatować komunikaty dziennika.

Wartość domyślna: '% (asctime) s [% (name) s]% (levelname) s:% (message) s'

38

LOG_DATEFORMAT

Jest to ciąg znaków, za pomocą którego można sformatować datę / godzinę.

Wartość domyślna: '% Y-% m-% d% H:% M:% S'

39

LOG_LEVEL

Określa minimalny poziom dziennika.

Wartość domyślna: „DEBUG”

40

LOG_STDOUT

Jeśli to ustawienie ma wartość true, wszystkie dane wyjściowe procesu pojawią się w dzienniku.

Wartość domyślna: False

41

MEMDEBUG_ENABLED

Określa, czy debugowanie pamięci ma być włączone.

Wartość domyślna: False

42

MEMDEBUG_NOTIFY

Definiuje raport pamięci, który jest wysyłany na określony adres, gdy włączone jest debugowanie pamięci.

Domyślna wartość: []

43

MEMUSAGE_ENABLED

Określa, czy użycie pamięci ma być włączone, gdy proces Scrapy przekroczy limit pamięci.

Wartość domyślna: False

44

MEMUSAGE_LIMIT_MB

Określa maksymalny dozwolony limit pamięci (w megabajtach).

Wartość domyślna: 0

45

MEMUSAGE_CHECK_INTERVAL_SECONDS

Służy do sprawdzania aktualnego wykorzystania pamięci poprzez ustawienie długości interwałów.

Wartość domyślna: 60,0

46

MEMUSAGE_NOTIFY_MAIL

Służy do powiadamiania listą e-maili, gdy pamięć osiągnie limit.

Wartość domyślna: False

47

MEMUSAGE_REPORT

Określa, czy raport użycia pamięci ma być wysyłany po zamknięciu każdego pająka.

Wartość domyślna: False

48

MEMUSAGE_WARNING_MB

Definiuje całkowitą pamięć, która ma być dozwolona przed wysłaniem ostrzeżenia.

Wartość domyślna: 0

49

NEWSPIDER_MODULE

Jest to moduł, w którym za pomocą polecenia genspider tworzony jest nowy pająk.

Domyślna wartość: ''

50

RANDOMIZE_DOWNLOAD_DELAY

Definiuje losowy czas oczekiwania Scrapy na pobieranie żądań ze strony.

Wartość domyślna: True

51

REACTOR_THREADPOOL_MAXSIZE

Określa maksymalny rozmiar puli wątków reaktora.

Wartość domyślna: 10

52

REDIRECT_MAX_TIMES

Określa, ile razy można przekierować żądanie.

Wartość domyślna: 20

53

REDIRECT_PRIORITY_ADJUST

To ustawienie, gdy jest ustawione, dostosowuje priorytet przekierowania żądania.

Wartość domyślna: +2

54

RETRY_PRIORITY_ADJUST

To ustawienie, gdy jest ustawione, dostosowuje priorytet ponownych prób żądania.

Wartość domyślna: -1

55

ROBOTSTXT_OBEY

Scrapy przestrzega zasad pliku robots.txt, gdy ma wartość true .

Wartość domyślna: False

56

SCHEDULER

Definiuje harmonogram, który ma być używany do celów indeksowania.

Wartość domyślna: „scrapy.core.scheduler.Scheduler”

57

SPIDER_CONTRACTS

Jest to słownik w projekcie zawierający kontrakty pająków do testowania pająków.

Domyślna wartość: {}

58

SPIDER_CONTRACTS_BASE

Jest to słownik zawierający kontrakty Scrapy, który jest domyślnie włączony w Scrapy.

Wartość domyślna -

{ 
   'scrapy.contracts.default.UrlContract' : 1, 
   'scrapy.contracts.default.ReturnsContract': 2, 
}
59

SPIDER_LOADER_CLASS

Definiuje klasę, która implementuje API SpiderLoadera do ładowania pająków.

Wartość domyślna: „scrapy.spiderloader.SpiderLoader”

60

SPIDER_MIDDLEWARES

Jest to słownik zawierający oprogramowanie pośrednie pająka.

Domyślna wartość: {}

61

SPIDER_MIDDLEWARES_BASE

Jest to słownik przechowujący oprogramowanie pośrednie pająka, które jest domyślnie włączone w Scrapy.

Wartość domyślna -

{ 
   'scrapy.spidermiddlewares.httperror.HttpErrorMiddleware': 50, 
}
62

SPIDER_MODULES

Jest to lista modułów zawierających pająki, których będzie szukał Scrapy.

Domyślna wartość: []

63

STATS_CLASS

Jest to klasa, która implementuje API Stats Collector do zbierania statystyk.

Wartość domyślna: „scrapy.statscollectors.MemoryStatsCollector”

64

STATS_DUMP

To ustawienie, gdy ma wartość true, zrzuca statystyki do dziennika.

Wartość domyślna: True

65

STATSMAILER_RCPTS

Gdy pająki zakończą skrobanie, Scrapy używa tego ustawienia do wysyłania statystyk.

Domyślna wartość: []

66

TELNETCONSOLE_ENABLED

Określa, czy włączyć konsolę telnet.

Wartość domyślna: True

67

TELNETCONSOLE_PORT

Definiuje port dla konsoli telnet.

Wartość domyślna: [6023, 6073]

68

TEMPLATES_DIR

Jest to katalog zawierający szablony, które można wykorzystać podczas tworzenia nowych projektów.

Wartość domyślna: katalog szablonów w module scrapy

69

URLLENGTH_LIMIT

Określa maksymalny limit długości adresu URL, jaki może być dozwolony w przypadku indeksowanych adresów URL.

Wartość domyślna: 2083

70

USER_AGENT

Definiuje klienta użytkownika, który ma być używany podczas indeksowania serwisu.

Wartość domyślna: „Scrapy / VERSION (+ http: //scrapy.org)”

Aby zobaczyć inne ustawienia Scrapy, przejdź do tego łącza .

Opis

Nieregularne zdarzenia określane są jako wyjątki. W Scrapy wyjątki są zgłaszane z powodu takich powodów, jak brak konfiguracji, usunięcie elementu z potoku pozycji itp. Poniżej znajduje się lista wyjątków wymienionych w Scrapy i ich zastosowanie.

DropItem

Potok pozycji wykorzystuje ten wyjątek, aby zatrzymać przetwarzanie elementu na dowolnym etapie. Można go zapisać jako -

exception (scrapy.exceptions.DropItem)

ZamknijSpider

Ten wyjątek służy do zatrzymywania pająka przy użyciu żądania wywołania zwrotnego. Można go zapisać jako -

exception (scrapy.exceptions.CloseSpider)(reason = 'cancelled')

Zawiera parametr o nazwie przyczyna (str), który określa powód zamknięcia.

Na przykład poniższy kod przedstawia użycie tego wyjątku -

def parse_page(self, response): 
   if 'Bandwidth exceeded' in response.body: 
      raise CloseSpider('bandwidth_exceeded')

IgnoreRequest

Ten wyjątek jest używany przez program planujący lub oprogramowanie pośredniczące do pobierania w celu zignorowania żądania. Można go zapisać jako -

exception (scrapy.exceptions.IgnoreRequest)

Nie skonfigurowane

Wskazuje brakującą sytuację konfiguracyjną i powinien zostać podniesiony w konstruktorze składników.

exception (scrapy.exceptions.NotConfigured)

Ten wyjątek można zgłosić, jeśli którykolwiek z poniższych składników jest wyłączony.

  • Extensions
  • Potoki pozycji
  • Oprogramowanie pośredniczące do pobierania
  • Oprogramowanie pośrednie pająka

Niewspierany

Ten wyjątek jest zgłaszany, gdy żadna funkcja lub metoda nie jest obsługiwana. Można go zapisać jako -

exception (scrapy.exceptions.NotSupported)

Opis

Aby zeskrobać dane ze stron internetowych, najpierw musisz utworzyć projekt Scrapy, w którym będziesz przechowywać kod. Aby utworzyć nowy katalog, uruchom następujące polecenie -

scrapy startproject first_scrapy

Powyższy kod utworzy katalog o nazwie first_scrapy i będzie zawierał następującą strukturę -

first_scrapy/
scrapy.cfg            # deploy configuration file
first_scrapy/         # project's Python module, you'll import your code from here
__init__.py
items.py              # project items file
pipelines.py          # project pipelines file
settings.py           # project settings file
spiders/              # a directory where you'll later put your spiders
__init__.py

Opis

Elementy to kontenery używane do zbierania danych, które są usuwane z witryn internetowych. Musisz zacząć pająka od zdefiniowania przedmiotu. Aby zdefiniować elementy, edytujitems.py plik znaleziony w katalogu first_scrapy(katalog niestandardowy). Plik items.py wygląda następująco -

import scrapy  

class First_scrapyItem(scrapy.Item): 
   # define the fields for your item here like: 
      # name = scrapy.Field()

W MyItem klasa dziedziczy z poz zawierające szereg predefiniowanych obiektów, które Scrapy już zbudowany dla nas. Na przykład, jeśli chcesz wyodrębnić nazwę, adres URL i opis z witryn, musisz zdefiniować pola dla każdego z tych trzech atrybutów.

Dlatego dodajmy te przedmioty, które chcemy zebrać -

from scrapy.item import Item, Field  

class First_scrapyItem(scrapy.Item): 
   name = scrapy.Field() 
   url = scrapy.Field() 
   desc = scrapy.Field()

Opis

Spider to klasa, która definiuje początkowy adres URL, z którego należy wyodrębniać dane, sposób podążania za linkami do paginacji oraz wyodrębnianie i analizowanie pól zdefiniowanych items.py. Scrapy zapewnia różne rodzaje pająków, z których każdy ma określony cel.

Utwórz plik o nazwie "first_spider.py"w katalogu first_scrapy / spiders, gdzie możemy powiedzieć Scrapy, jak znaleźć dokładne dane, których szukamy. W tym celu musisz zdefiniować niektóre atrybuty -

  • name - Określa unikalną nazwę pająka.

  • allowed_domains - Zawiera podstawowe adresy URL do przeszukiwania przez pająka.

  • start-urls - Lista adresów URL, z których pająk zaczyna się indeksować.

  • parse() - Jest to metoda, która wyodrębnia i analizuje zeskrobane dane.

Poniższy kod pokazuje, jak wygląda kod pająka -

import scrapy  

class firstSpider(scrapy.Spider): 
   name = "first" 
   allowed_domains = ["dmoz.org"] 
   
   start_urls = [ 
      "http://www.dmoz.org/Computers/Programming/Languages/Python/Books/", 
      "http://www.dmoz.org/Computers/Programming/Languages/Python/Resources/" 
   ]  
   def parse(self, response): 
      filename = response.url.split("/")[-2] + '.html' 
      with open(filename, 'wb') as f: 
         f.write(response.body)

Opis

Aby wykonać pająka, uruchom następujące polecenie w swoim katalogu first_scrapy -

scrapy crawl first

Gdzie, first to nazwa pająka określona podczas tworzenia pająka.

Gdy pająk się czołgnie, możesz zobaczyć następujące dane wyjściowe -

2016-08-09 18:13:07-0400 [scrapy] INFO: Scrapy started (bot: tutorial)
2016-08-09 18:13:07-0400 [scrapy] INFO: Optional features available: ...
2016-08-09 18:13:07-0400 [scrapy] INFO: Overridden settings: {}
2016-08-09 18:13:07-0400 [scrapy] INFO: Enabled extensions: ...
2016-08-09 18:13:07-0400 [scrapy] INFO: Enabled downloader middlewares: ...
2016-08-09 18:13:07-0400 [scrapy] INFO: Enabled spider middlewares: ...
2016-08-09 18:13:07-0400 [scrapy] INFO: Enabled item pipelines: ...
2016-08-09 18:13:07-0400 [scrapy] INFO: Spider opened
2016-08-09 18:13:08-0400 [scrapy] DEBUG: Crawled (200) 
<GET http://www.dmoz.org/Computers/Programming/Languages/Python/Resources/> (referer: None)
2016-08-09 18:13:09-0400 [scrapy] DEBUG: Crawled (200) 
<GET http://www.dmoz.org/Computers/Programming/Languages/Python/Books/> (referer: None)
2016-08-09 18:13:09-0400 [scrapy] INFO: Closing spider (finished)

Jak widać w wynikach, dla każdego adresu URL znajduje się wiersz dziennika, który (referer: None) stwierdza, że ​​adresy URL są początkowymi adresami URL i nie mają odsyłaczy. Następnie powinieneś zobaczyć dwa nowe pliki o nazwach Books.html i Resources.html, które zostały utworzone w Twoim katalogu first_scrapy .

Opis

Do wydobywania danych ze stron internetowych Scrapy wykorzystuje technikę zwaną selektorami opartą na wyrażeniach XPath i CSS . Oto kilka przykładów wyrażeń XPath -

  • /html/head/title - Spowoduje to zaznaczenie elementu <title> wewnątrz elementu <head> dokumentu HTML.

  • /html/head/title/text() - Spowoduje to zaznaczenie tekstu w tym samym elemencie <title>.

  • //td - Spowoduje to zaznaczenie wszystkich elementów z <td>.

  • //div[@class = "slice"]- Spowoduje to zaznaczenie wszystkich elementów z div, które zawierają atrybut class = "slice"

Selektory mają cztery podstawowe metody, jak pokazano w poniższej tabeli -

Sr.No Metoda i opis
1

extract()

Zwraca ciąg znaków Unicode wraz z wybranymi danymi.

2

re()

Zwraca listę ciągów znaków Unicode, wyodrębnionych, gdy jako argument podano wyrażenie regularne.

3

xpath()

Zwraca listę selektorów, która reprezentuje węzły wybrane przez wyrażenie xpath podane jako argument.

4

css()

Zwraca listę selektorów, która reprezentuje węzły wybrane przez wyrażenie CSS podane jako argument.

Używanie selektorów w powłoce

Aby zademonstrować selektory z wbudowaną powłoką Scrapy, musisz mieć zainstalowany w systemie IPython . Ważną rzeczą jest to, że adresy URL powinny być umieszczane w cudzysłowach podczas uruchamiania Scrapy; w przeciwnym razie adresy URL ze znakami „&” nie będą działać. Możesz uruchomić powłokę, używając następującego polecenia w katalogu najwyższego poziomu projektu -

scrapy shell "http://www.dmoz.org/Computers/Programming/Languages/Python/Books/"

Powłoka będzie wyglądać następująco -

[ ... Scrapy log here ... ]

2014-01-23 17:11:42-0400 [scrapy] DEBUG: Crawled (200) 
<GET http://www.dmoz.org/Computers/Programming/Languages/Python/Books/>(referer: None)
[s] Available Scrapy objects:
[s]   crawler    <scrapy.crawler.Crawler object at 0x3636b50>
[s]   item       {}
[s]   request    <GET http://www.dmoz.org/Computers/Programming/Languages/Python/Books/>
[s]   response   <200 http://www.dmoz.org/Computers/Programming/Languages/Python/Books/>
[s]   settings   <scrapy.settings.Settings object at 0x3fadc50>
[s]   spider     <Spider 'default' at 0x3cebf50>
[s] Useful shortcuts:
[s]   shelp()           Shell help (print this help)
[s]   fetch(req_or_url) Fetch request (or URL) and update local objects
[s]   view(response)    View response in a browser

In [1]:

Po załadowaniu powłoki możesz uzyskać dostęp do treści lub nagłówka, używając odpowiednio response.body i response.header . Podobnie można uruchamiać zapytania dotyczące odpowiedzi za pomocą funkcji response.selector.xpath () lub response.selector.css () .

Na przykład -

In [1]: response.xpath('//title')
Out[1]: [<Selector xpath = '//title' data = u'<title>My Book - Scrapy'>]

In [2]: response.xpath('//title').extract()
Out[2]: [u'<title>My Book - Scrapy: Index: Chapters</title>']

In [3]: response.xpath('//title/text()')
Out[3]: [<Selector xpath = '//title/text()' data = u'My Book - Scrapy: Index:'>]

In [4]: response.xpath('//title/text()').extract()
Out[4]: [u'My Book - Scrapy: Index: Chapters']

In [5]: response.xpath('//title/text()').re('(\w+):')
Out[5]: [u'Scrapy', u'Index', u'Chapters']

Wyodrębnianie danych

Aby wyodrębnić dane ze zwykłej witryny HTML, musimy sprawdzić kod źródłowy witryny, aby uzyskać XPath. Po sprawdzeniu możesz zobaczyć, że dane będą w formacieuletykietka. Wybierz elementy w obrębieli etykietka.

Poniższe wiersze kodu pokazują wyodrębnianie różnych typów danych -

Do wybierania danych w tagu li -

response.xpath('//ul/li')

Do wyboru opisów -

response.xpath('//ul/li/text()').extract()

Do wybierania tytułów witryn -

response.xpath('//ul/li/a/text()').extract()

Do wybierania linków do witryn -

response.xpath('//ul/li/a/@href').extract()

Poniższy kod demonstruje użycie powyższych ekstraktorów -

import scrapy

class MyprojectSpider(scrapy.Spider):
   name = "project"
   allowed_domains = ["dmoz.org"]
   
   start_urls = [
      "http://www.dmoz.org/Computers/Programming/Languages/Python/Books/",
      "http://www.dmoz.org/Computers/Programming/Languages/Python/Resources/"
   ]
   def parse(self, response):
      for sel in response.xpath('//ul/li'):
         title = sel.xpath('a/text()').extract()
         link = sel.xpath('a/@href').extract()
         desc = sel.xpath('text()').extract()
         print title, link, desc

Opis

Itemobiekty są zwykłymi nakazami języka Python. Możemy użyć następującej składni, aby uzyskać dostęp do atrybutów klasy -

>>> item = DmozItem()
>>> item['title'] = 'sample title'
>>> item['title']
'sample title'

Dodaj powyższy kod do następującego przykładu -

import scrapy

from tutorial.items import DmozItem

class MyprojectSpider(scrapy.Spider):
   name = "project"
   allowed_domains = ["dmoz.org"]
   
   start_urls = [
      "http://www.dmoz.org/Computers/Programming/Languages/Python/Books/",
      "http://www.dmoz.org/Computers/Programming/Languages/Python/Resources/"
   ]
   def parse(self, response):
      for sel in response.xpath('//ul/li'):
         item = DmozItem()
         item['title'] = sel.xpath('a/text()').extract()
         item['link'] = sel.xpath('a/@href').extract()
         item['desc'] = sel.xpath('text()').extract()
         yield item

Wyjście powyższego pająka będzie -

[scrapy] DEBUG: Scraped from <200 
http://www.dmoz.org/Computers/Programming/Languages/Python/Books/>
   {'desc': [u' - By David Mertz; Addison Wesley. Book in progress, full text, 
      ASCII format. Asks for feedback. [author website, Gnosis Software, Inc.\n],
   'link': [u'http://gnosis.cx/TPiP/'],
   'title': [u'Text Processing in Python']}
[scrapy] DEBUG: Scraped from <200 
http://www.dmoz.org/Computers/Programming/Languages/Python/Books/>
   {'desc': [u' - By Sean McGrath; Prentice Hall PTR, 2000, ISBN 0130211192, 
      has CD-ROM. Methods to build XML applications fast, Python tutorial, DOM and 
      SAX, new Pyxie open source XML processing library. [Prentice Hall PTR]\n'],
   'link': [u'http://www.informit.com/store/product.aspx?isbn=0130211192'],
   'title': [u'XML Processing with Python']}

Opis

W tym rozdziale dowiemy się, jak wyodrębnić linki do interesujących nas stron, śledzić je i wyodrębniać dane z tej strony. W tym celu musimy wprowadzić następujące zmiany w naszym poprzednim kodzie pokazanym w następujący sposób -

import scrapy
from tutorial.items import DmozItem

class MyprojectSpider(scrapy.Spider):
   name = "project"
   allowed_domains = ["dmoz.org"]
   
   start_urls = [
      "http://www.dmoz.org/Computers/Programming/Languages/Python/",
   ]
   def parse(self, response):
      for href in response.css("ul.directory.dir-col > li > a::attr('href')"):
         url = response.urljoin(href.extract())
            yield scrapy.Request(url, callback = self.parse_dir_contents)

   def parse_dir_contents(self, response):
      for sel in response.xpath('//ul/li'):
         item = DmozItem()
         item['title'] = sel.xpath('a/text()').extract()
         item['link'] = sel.xpath('a/@href').extract()
         item['desc'] = sel.xpath('text()').extract()
         yield item

Powyższy kod zawiera następujące metody -

  • parse() - Wyodrębni linki, które nas interesują.

  • response.urljoin - Metoda parse () użyje tej metody do zbudowania nowego adresu URL i zapewni nowe żądanie, które zostanie później wysłane do wywołania zwrotnego.

  • parse_dir_contents() - To jest wywołanie zwrotne, które faktycznie usunie interesujące Cię dane.

Tutaj Scrapy używa mechanizmu wywołania zwrotnego do podążania za linkami. Korzystając z tego mechanizmu, można zaprojektować większy robot indeksujący i może podążać za interesującymi nas linkami, aby pobierać żądane dane z różnych stron. Zwykłą metodą będzie metoda callback, która wyodrębni elementy, wyszuka łącza do następnej strony, a następnie wyśle ​​żądanie tego samego wywołania zwrotnego.

Poniższy przykład tworzy pętlę, która będzie następować po łączach do następnej strony.

def parse_articles_follow_next_page(self, response):
   for article in response.xpath("//article"):
      item = ArticleItem()
    
      ... extract article data here

      yield item

   next_page = response.css("ul.navigation > li.next-page > a::attr('href')")
   if next_page:
      url = response.urljoin(next_page[0].extract())
      yield scrapy.Request(url, self.parse_articles_follow_next_page)

Opis

Najlepszym sposobem przechowywania zeskrobanych danych jest użycie eksportów kanałów, które zapewniają prawidłowe przechowywanie danych przy użyciu wielu formatów serializacji. JSON, linie JSON, CSV, XML to formaty łatwo obsługiwane w formatach serializacji. Dane można zapisać za pomocą następującego polecenia -

scrapy crawl dmoz -o data.json

To polecenie utworzy plik data.jsonplik zawierający pobrane dane w formacie JSON. Ta technika sprawdza się w przypadku niewielkich ilości danych. Jeśli trzeba obsłużyć dużą ilość danych, możemy użyć Item Pipeline. Podobnie jak plik data.json, plik zastrzeżony jest konfigurowany podczas tworzenia projektu w programietutorial/pipelines.py.

Opis

Loggingoznacza śledzenie zdarzeń, które wykorzystuje wbudowany system logowania oraz definiuje funkcje i klasy do implementacji aplikacji i bibliotek. Rejestrowanie to gotowy do użycia materiał, który może działać z ustawieniami Scrapy wymienionymi w Ustawieniach rejestrowania.

Scrapy ustawi niektóre ustawienia domyślne i obsłuży te ustawienia przy pomocy scrapy.utils.log.configure_logging () podczas wykonywania poleceń.

Poziomy dziennika

W Pythonie istnieje pięć różnych poziomów ważności komunikatu dziennika. Poniższa lista przedstawia standardowe komunikaty dziennika w porządku rosnącym -

  • logging.DEBUG - do debugowania wiadomości (najniższy poziom ważności)

  • logging.INFO - dla wiadomości informacyjnych

  • logging.WARNING - dla komunikatów ostrzegawczych

  • logging.ERROR - za zwykłe błędy

  • logging.CRITICAL - dla błędów krytycznych (najwyższa waga)

Jak rejestrować wiadomości

Poniższy kod przedstawia rejestrowanie wiadomości przy użyciu logging.info poziom.

import logging 
logging.info("This is an information")

Powyższy komunikat logowania można przekazać jako argument za pomocą logging.log pokazano następująco -

import logging 
logging.log(logging.INFO, "This is an information")

Teraz możesz również użyć rejestratorów do dołączenia wiadomości za pomocą rejestrowania pomocników rejestrowania, aby uzyskać komunikat logowania wyraźnie pokazany w następujący sposób -

import logging
logger = logging.getLogger()
logger.info("This is an information")

Może istnieć wiele rejestratorów, a dostęp do nich można uzyskać, uzyskując ich nazwy za pomocą logging.getLogger funkcja pokazana w następujący sposób.

import logging
logger = logging.getLogger('mycustomlogger')
logger.info("This is an information")

Dostosowany rejestrator może być używany dla dowolnego modułu za pomocą zmiennej __name__ , która zawiera ścieżkę modułu pokazaną w następujący sposób -

import logging
logger = logging.getLogger(__name__)
logger.info("This is an information")

Logowanie z pająków

Każda instancja pająka ma plik logger w nim i może być używany w następujący sposób -

import scrapy 

class LogSpider(scrapy.Spider):  
   name = 'logspider' 
   start_urls = ['http://dmoz.com']  
   def parse(self, response): 
      self.logger.info('Parse function called on %s', response.url)

W powyższym kodzie logger jest tworzony przy użyciu nazwy Spider, ale możesz użyć dowolnego niestandardowego loggera dostarczonego przez Pythona, jak pokazano w poniższym kodzie -

import logging
import scrapy

logger = logging.getLogger('customizedlogger')
class LogSpider(scrapy.Spider):
   name = 'logspider'
   start_urls = ['http://dmoz.com']

   def parse(self, response):
      logger.info('Parse function called on %s', response.url)

Konfiguracja dziennika

Loggery nie są w stanie samodzielnie wyświetlać wysyłanych przez siebie wiadomości. Potrzebują więc „programów obsługi” do wyświetlania tych komunikatów, a programy obsługi będą przekierowywać te komunikaty do odpowiednich miejsc docelowych, takich jak pliki, e-maile i standardowe wyjście.

W zależności od poniższych ustawień Scrapy skonfiguruje program obsługi dla rejestratora.

Ustawienia rejestrowania

Następujące ustawienia służą do konfigurowania logowania -

  • Plik LOG_FILE i LOG_ENABLED zdecydować o miejscu docelowym komunikatów dziennika.

  • Po ustawieniu LOG_ENCODING na false, nie wyświetli komunikatów wyjściowych dziennika.

  • Plik LOG_LEVELokreśli stopień ważności wiadomości; te wiadomości o mniejszej wadze zostaną odfiltrowane.

  • Plik LOG_FORMAT i LOG_DATEFORMAT służą do określania układów wszystkich wiadomości.

  • Po ustawieniu LOG_STDOUT na true, wszystkie standardowe dane wyjściowe i komunikaty o błędach procesu będą przekierowywane do dziennika.

Opcje wiersza poleceń

Ustawienia Scrapy można zastąpić, przekazując argumenty wiersza polecenia, jak pokazano w poniższej tabeli -

Sr.No Polecenie i opis
1

--logfile FILE

Zastępuje LOG_FILE

2

--loglevel/-L LEVEL

Zastępuje LOG_LEVEL

3

--nolog

Ustawia LOG_ENABLED na False

moduł scrapy.utils.log

Ta funkcja może służyć do inicjowania domyślnych ustawień rejestrowania dla Scrapy.

scrapy.utils.log.configure_logging(settings = None, install_root_handler = True)

Sr.No Parametr i opis
1

settings (dict, None)

Tworzy i konfiguruje program obsługi dla głównego rejestratora. Domyślnie jest to Brak .

2

install_root_handler (bool)

Określa instalację programu obsługi logowania root. Domyślnie jest to prawda .

Powyższa funkcja -

  • Przekierowuje ostrzeżenia i pokręcone logi przez standardowe rejestrowanie w Pythonie.
  • Przypisuje DEBUG do Scrapy i ERROR do Twisted Loggers.
  • Przekierowuje standardowe wyjście do dziennika, jeśli ustawienie LOG_STDOUT jest prawdziwe.

Domyślne opcje można zastąpić przy użyciu settingsargument. Jeśli ustawienia nie są określone, używane są wartości domyślne. Program obsługi można utworzyć dla głównego programu rejestrującego, gdy parametr install_root_handler ma wartość true. Jeśli ma wartość false, nie będzie ustawionych żadnych danych wyjściowych dziennika. Podczas korzystania z poleceń Scrapy polecenie configure_logging zostanie wywołane automatycznie i może działać jawnie podczas uruchamiania skryptów niestandardowych.

Aby ręcznie skonfigurować dane wyjściowe rejestrowania, możesz użyć logging.basicConfig() pokazano następująco -

import logging 
from scrapy.utils.log import configure_logging  

configure_logging(install_root_handler = False) 
logging.basicConfig ( 
   filename = 'logging.txt', 
   format = '%(levelname)s: %(your_message)s', 
   level = logging.INFO 
)

Opis

Stats Collector jest narzędziem dostarczanym przez Scrapy do zbierania statystyk w postaci klucza / wartości i jest dostępne za pomocą Crawler API (Crawler zapewnia dostęp do wszystkich podstawowych komponentów Scrapy). Kolektor statystyk udostępnia jedną tabelę statystyk dla każdego pająka, w której kolektor statystyk otwiera się automatycznie, gdy pająk się otwiera i zamyka kolektor statystyk, gdy pająk jest zamknięty.

Typowe zastosowania kolektora statystyk

Poniższy kod uzyskuje dostęp do modułu zbierającego statystyki przy użyciu stats atrybut.

class ExtensionThatAccessStats(object): 
   def __init__(self, stats): 
      self.stats = stats  
   
   @classmethod 
   def from_crawler(cls, crawler): 
      return cls(crawler.stats)

Poniższa tabela przedstawia różne opcje, których można używać z kolektorem statystyk -

Sr.No Parametry Opis
1
stats.set_value('hostname', socket.gethostname())
Służy do ustawiania wartości statystyk.
2
stats.inc_value('customized_count')
Zwiększa wartość statystyki.
3
stats.max_value('max_items_scraped', value)
Możesz ustawić wartość statystyki, tylko jeśli jest większa niż poprzednia wartość.
4
stats.min_value('min_free_memory_percent', value)
Możesz ustawić wartość statystyki, tylko jeśli jest niższa od poprzedniej wartości.
5
stats.get_value('customized_count')
Pobiera wartość statystyki.
6
stats.get_stats() {'custom_count': 1, 'start_time': 
datetime.datetime(2009, 7, 14, 21, 47, 28, 977139)}
Pobiera wszystkie statystyki

Dostępne kolektory statystyk

Scrapy zapewnia różne typy kolektorów statystyk, do których można uzyskać dostęp za pomocą STATS_CLASS oprawa.

MemoryStatsCollector

Jest to domyślny moduł zbierający statystyki, który przechowuje statystyki każdego pająka, który był używany do skrobania, a dane zostaną zapisane w pamięci.

class scrapy.statscollectors.MemoryStatsCollector

DummyStatsCollector

Ten kolektor statystyk jest bardzo wydajny i nic nie robi. Można to ustawić za pomocą ustawienia STATS_CLASS i można go użyć do wyłączenia gromadzenia statystyk w celu poprawy wydajności.

class scrapy.statscollectors.DummyStatsCollector

Opis

Scrapy może wysyłać e-maile przy użyciu własnego narzędzia zwanego Twisted non-blocking IO, który zapobiega blokowaniu operacji we / wy robota. Możesz skonfigurować kilka ustawień wysyłania e-maili i zapewnić proste API do wysyłania załączników.

Istnieją dwa sposoby utworzenia wystąpienia MailSender, jak pokazano w poniższej tabeli -

Sr.No Parametry metoda
1 z scrapy.mail import MailSender mailer = MailSender () Używając standardowego konstruktora.
2 mailer = MailSender.from_settings (ustawienia) Używając obiektu ustawień Scrapy.

Poniższy wiersz wysyła wiadomość e-mail bez załączników -

mailer.send(to = ["[email protected]"], subject = "subject data", body = "body data", 
   cc = ["[email protected]"])

Odwołanie do klasy MailSender

Klasa MailSender używa Twisted nieblokujących operacji we / wy do wysyłania wiadomości e-mail z Scrapy.

class scrapy.mail.MailSender(smtphost = None, mailfrom = None, smtpuser = None, 
   smtppass = None, smtpport = None)

Poniższa tabela przedstawia parametry używane w klasie MailSender -

Sr.No Parametr i opis
1

smtphost (str)

Do wysyłania wiadomości e-mail używany jest host SMTP. Jeśli nie, zostanie użyte ustawienie MAIL_HOST .

2

mailfrom (str)

Adres odbiorcy jest używany do wysyłania e-maili. Jeśli nie, zostanie użyte ustawienie MAIL_FROM .

3

smtpuser

Określa użytkownika SMTP. Jeśli nie jest używane, zostanie użyte ustawienie MAIL_USER i nie będzie sprawdzania poprawności SMTP, jeśli nie zostanie wymienione.

4

smtppass (str)

Określa przepustkę SMTP do weryfikacji.

5

smtpport (int)

Określa port SMTP do połączenia.

6

smtptls (boolean)

Realizuje za pomocą SMTP STARTTLS.

7

smtpssl (boolean)

Administruje przy użyciu bezpiecznego połączenia SSL.

Następujące dwie metody znajdują się w odwołaniu do klasy MailSender, jak określono. Pierwsza metoda,

classmethod from_settings(settings)

Włącza się za pomocą obiektu ustawień Scrapy. Zawiera następujący parametr -

settings (scrapy.settings.Settings object) - Jest traktowany jako odbiorca wiadomości e-mail.

Inna metoda,

send(to, subject, body, cc = None, attachs = (), mimetype = 'text/plain', charset = None)

Poniższa tabela zawiera parametry powyższej metody -

Sr.No Parametr i opis
1

to (list)

Odnosi się do odbiorcy wiadomości e-mail.

2

subject (str)

Określa temat wiadomości e-mail.

3

cc (list)

Odnosi się do listy odbiorców.

4

body (str)

Odnosi się do danych treści wiadomości e-mail.

5

attachs (iterable)

Odnosi się do załącznika wiadomości e-mail, typu MIME załącznika i nazwy załącznika.

6

mimetype (str)

Reprezentuje typ MIME wiadomości e-mail.

7

charset (str)

Określa kodowanie znaków używane w treści wiadomości e-mail.

Ustawienia poczty

Poniższe ustawienia zapewniają, że bez pisania kodu możemy skonfigurować e-mail korzystając z klasy MailSender w projekcie.

Sr.No Ustawienia i opis Domyślna wartość
1

MAIL_FROM

Odnosi się do wiadomości e-mail nadawcy do wysyłania wiadomości e-mail.

„scrapy @ localhost”
2

MAIL_HOST

Odnosi się do hosta SMTP używanego do wysyłania wiadomości e-mail.

'Lokalny Gospodarz'
3

MAIL_PORT

Określa port SMTP, który ma być używany do wysyłania wiadomości e-mail.

25
4

MAIL_USER

Odnosi się do walidacji SMTP. Nie będzie weryfikacji, jeśli to ustawienie jest wyłączone.

Żaden
5

MAIL_PASS

Zawiera hasło używane do weryfikacji SMTP.

Żaden
6

MAIL_TLS

Zapewnia metodę uaktualnienia niezabezpieczonego połączenia do bezpiecznego połączenia przy użyciu protokołu SSL / TLS.

Fałszywy
7

MAIL_SSL

Realizuje połączenie za pomocą szyfrowanego połączenia SSL.

Fałszywy

Opis

Konsola Telnet to powłoka Pythona, która działa w procesie Scrapy i służy do inspekcji i kontrolowania uruchomionego procesu Scrapy.

Uzyskaj dostęp do konsoli Telnet

Dostęp do konsoli telnet można uzyskać za pomocą następującego polecenia -

telnet localhost 6023

Zasadniczo konsola telnet jest wymieniona w porcie TCP, który jest opisany w TELNETCONSOLE_PORT ustawienia.

Zmienne

Niektóre domyślne zmienne podane w poniższej tabeli są używane jako skróty -

Sr.No Skrót i opis
1

crawler

Odnosi się to do obiektu Scrapy Crawler (scrapy.crawler.Crawler).

2

engine

Dotyczy to atrybutu Crawler.engine.

3

spider

Odnosi się to do pająka, który jest aktywny.

4

slot

Odnosi się to do gniazda silnika.

5

extensions

Dotyczy to atrybutu Extension Manager (Crawler.extensions).

6

stats

Odnosi się to do atrybutu Stats Collector (Crawler.stats).

7

setting

Odnosi się to do atrybutu obiektu ustawień Scrapy (Crawler.settings).

8

est

Odnosi się to do drukowania raportu o stanie silnika.

9

prefs

Odnosi się to do pamięci do debugowania.

10

p

Odnosi się to do skrótu do funkcji pprint.pprint .

11

hpy

Odnosi się to do debugowania pamięci.

Przykłady

Poniżej przedstawiono kilka przykładów zilustrowanych za pomocą konsoli Telnet.

Wstrzymaj, wznów i zatrzymaj silnik Scrapy

Aby wstrzymać silnik Scrapy, użyj następującego polecenia -

telnet localhost 6023
>>> engine.pause()
>>>

Aby wznowić silnik Scrapy, użyj następującego polecenia -

telnet localhost 6023
>>> engine.unpause()
>>>

Aby zatrzymać silnik Scrapy, użyj następującego polecenia -

telnet localhost 6023
>>> engine.stop()
Connection closed by foreign host.

Wyświetl stan silnika

Konsola Telnet używa est() metoda sprawdzania statusu silnika Scrapy, jak pokazano w poniższym kodzie -

telnet localhost 6023
>>> est()
Execution engine status

time()-engine.start_time                        : 8.62972998619
engine.has_capacity()                           : False
len(engine.downloader.active)                   : 16
engine.scraper.is_idle()                        : False
engine.spider.name                              : followall
engine.spider_is_idle(engine.spider)            : False
engine.slot.closing                             : False
len(engine.slot.inprogress)                     : 16
len(engine.slot.scheduler.dqs or [])            : 0
len(engine.slot.scheduler.mqs)                  : 92
len(engine.scraper.slot.queue)                  : 0
len(engine.scraper.slot.active)                 : 0
engine.scraper.slot.active_size                 : 0
engine.scraper.slot.itemproc_size               : 0
engine.scraper.slot.needs_backout()             : False

Sygnały konsoli Telnet

Za pomocą sygnałów konsoli telnet można dodawać, aktualizować lub usuwać zmienne w lokalnej przestrzeni nazw telnet. Aby wykonać tę akcję, musisz dodać dykt telnet_vars do swojego handlera.

scrapy.extensions.telnet.update_telnet_vars(telnet_vars)

Parametry -

telnet_vars (dict)

Gdzie, dict jest słownikiem zawierającym zmienne telnet.

Ustawienia Telnet

W poniższej tabeli przedstawiono ustawienia kontrolujące zachowanie konsoli Telnet -

Sr.No Ustawienia i opis Domyślna wartość
1

TELNETCONSOLE_PORT

Dotyczy to zakresu portów konsoli telnet. Jeśli jest ustawiona na none, port zostanie przypisany dynamicznie.

[6023, 6073]
2

TELNETCONSOLE_HOST

Odnosi się to do interfejsu, na którym powinna nasłuchiwać konsola telnet.

„127.0.0.1”

Opis

Działającym robotem indeksującym Scrapy można sterować za pomocą JSON-RPC. Jest włączany przez ustawienie JSONRPC_ENABLED. Ta usługa zapewnia dostęp do głównego obiektu przeszukiwacza za pośrednictwem protokołu JSON-RPC 2.0 . Punkt końcowy dostępu do obiektu przeszukiwacza to -

http://localhost:6080/crawler

Poniższa tabela zawiera niektóre ustawienia, które pokazują zachowanie usługi internetowej -

Sr.No Ustawienie i opis Domyślna wartość
1

JSONRPC_ENABLED

Odnosi się to do wartości logicznej, która decyduje, czy usługa internetowa wraz z jej rozszerzeniem będzie włączona, czy nie.

Prawdziwe
2

JSONRPC_LOGFILE

Odnosi się to do pliku używanego do rejestrowania żądań HTTP kierowanych do usługi internetowej. Jeśli nie zostanie ustawiona, zostanie użyty standardowy dziennik Scrapy.

Żaden
3

JSONRPC_PORT

Odnosi się to do zakresu portów dla usługi internetowej. Jeśli jest ustawiona na none, port zostanie przypisany dynamicznie.

[6080, 7030]
4

JSONRPC_HOST

Dotyczy to interfejsu, na którym powinna nasłuchiwać usługa sieciowa.

„127.0.0.1”