Scrapy — Обзор

Scrapy — это быстрый веб-фреймворк с открытым исходным кодом, написанный на Python, который используется для извлечения данных с веб-страницы с помощью селекторов на основе XPath.

Scrapy был впервые выпущен 26 июня 2008 года по лицензии BSD, а в июне 2015 года был выпущен Milestone 1.0.

Зачем использовать Scrapy?

• Легче создавать и масштабировать большие проекты сканирования.

• Он имеет встроенный механизм, называемый селекторами, для извлечения данных с веб-сайтов.

• Он обрабатывает запросы асинхронно и быстро.

• Он автоматически регулирует скорость сканирования с помощью механизма автоматического дросселирования .

• Обеспечивает доступность для разработчиков.

Легче создавать и масштабировать большие проекты сканирования.

Он имеет встроенный механизм, называемый селекторами, для извлечения данных с веб-сайтов.

Он обрабатывает запросы асинхронно и быстро.

Он автоматически регулирует скорость сканирования с помощью механизма автоматического дросселирования .

Обеспечивает доступность для разработчиков.

Особенности Scrapy

• Scrapy — это открытый исходный код, который можно использовать для сканирования веб-страниц.

• Scrapy генерирует экспорт кормов в таких форматах, как JSON, CSV и XML.

• Scrapy имеет встроенную поддержку для выбора и извлечения данных из источников с помощью выражений XPath или CSS.

• Scrapy на основе сканера, позволяет автоматически извлекать данные с веб-страниц.

Scrapy — это открытый исходный код, который можно использовать для сканирования веб-страниц.

Scrapy генерирует экспорт кормов в таких форматах, как JSON, CSV и XML.

Scrapy имеет встроенную поддержку для выбора и извлечения данных из источников с помощью выражений XPath или CSS.

Scrapy на основе сканера, позволяет автоматически извлекать данные с веб-страниц.

преимущества

• Скрапия легко расширяемая, быстрая и мощная.

• Это кроссплатформенный каркас приложений (Windows, Linux, Mac OS и BSD).

• Запросы Scrapy запланированы и обработаны асинхронно.

• Scrapy поставляется со встроенным сервисом Scrapyd, который позволяет загружать проекты и управлять пауками с помощью веб-сервиса JSON.

• Можно удалить любой веб-сайт, хотя этот веб-сайт не имеет API для доступа к необработанным данным.

Скрапия легко расширяемая, быстрая и мощная.

Это кроссплатформенный каркас приложений (Windows, Linux, Mac OS и BSD).

Запросы Scrapy запланированы и обработаны асинхронно.

Scrapy поставляется со встроенным сервисом Scrapyd, который позволяет загружать проекты и управлять пауками с помощью веб-сервиса JSON.

Можно удалить любой веб-сайт, хотя этот веб-сайт не имеет API для доступа к необработанным данным.

Недостатки

• Scrapy только для Python 2.7. +

• Установка отличается для разных операционных систем.

Scrapy только для Python 2.7. +

Установка отличается для разных операционных систем.

Scrapy — Окружающая среда

В этой главе мы обсудим, как установить и настроить Scrapy. Scrapy должен быть установлен с Python.

Scrapy можно установить с помощью pip . Для установки выполните следующую команду —

pip install Scrapy

Windows

Примечание. Python 3 не поддерживается в ОС Windows.

Шаг 1 — Установите Python 2.7 из Python

Установите переменные среды, добавив следующие пути к PATH —

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

Вы можете проверить версию Python, используя следующую команду —

python --version

Шаг 2 — Установите OpenSSL .

Добавьте C: \ OpenSSL-Win32 \ bin в переменные окружения.

Примечание. OpenSSL предустановлен во всех операционных системах, кроме Windows.

Шаг 3 — Установите распространяемые файлы Visual C ++ 2008 .

Шаг 4 — Установите pywin32 .

Шаг 5 — Установите pip для версий Python старше 2.7.9.

Вы можете проверить версию пипса, используя следующую команду —

pip --version

Шаг 6 — Чтобы установить scrapy, выполните следующую команду —

pip install Scrapy

анаконда

Если на вашем компьютере установлена anaconda или miniconda , выполните следующую команду, чтобы установить Scrapy с помощью conda:

conda install -c scrapinghub scrapy 

Компания Scrapinghub поддерживает официальные пакеты conda для Linux, Windows и OS X.

Примечание. Рекомендуется установить Scrapy с помощью приведенной выше команды, если у вас есть проблемы с установкой через pip.

Ubuntu 9.10 или выше

Последняя версия Python предустановлена ​​на ОС Ubuntu. Используйте aptgettable для пакетов Ubuntu, предоставляемых Scrapinghub. Чтобы использовать пакеты —

Шаг 1. Вам необходимо импортировать ключ GPG, используемый для подписи пакетов Scrapy, в связку ключей APT.

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

Шаг 2 — Затем используйте следующую команду для создания файла /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

Шаг 3 — Обновление списка пакетов и установка scrapy —

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

Archlinux

Вы можете установить Scrapy из пакета AUR Scrapy с помощью следующей команды —

yaourt -S scrapy

Mac OS X

Используйте следующую команду для установки инструментов командной строки Xcode —

xcode-select --install 

Вместо использования системного Python установите новую обновленную версию, которая не конфликтует с остальной частью вашей системы.

Шаг 1 — Установите доморощенный .

Шаг 2 — Установите переменную среды PATH, чтобы указать, что пакеты homebrew должны использоваться до системных пакетов.

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

Шаг 3 — Чтобы убедиться, что изменения сделаны, перезагрузите .bashrc, используя следующую команду —

source ~/.bashrc 

Шаг 4 — Затем установите Python с помощью следующей команды —

brew install python

Шаг 5 — Установите Scrapy с помощью следующей команды —

pip install Scrapy

Scrapy — инструменты командной строки

Описание

Инструмент командной строки Scrapy используется для управления Scrapy, который часто называют «Scrapy tool» . Он включает в себя команды для различных объектов с группой аргументов и опций.

Настройки конфигурации

Scrapy найдет параметры конфигурации в файле scrapy.cfg . Ниже приведены несколько мест —

• C: \ scrapy (папка проекта) \ scrapy.cfg в системе

• ~ / .config / scrapy.cfg ($ XDG_CONFIG_HOME) и ~ / .scrapy.cfg ($ HOME) для глобальных настроек

• Вы можете найти scrapy.cfg в корне проекта.

C: \ scrapy (папка проекта) \ scrapy.cfg в системе

~ / .config / scrapy.cfg ($ XDG_CONFIG_HOME) и ~ / .scrapy.cfg ($ HOME) для глобальных настроек

Вы можете найти scrapy.cfg в корне проекта.

Scrapy также может быть настроен с использованием следующих переменных среды:

• SCRAPY_SETTINGS_MODULE
• SCRAPY_PROJECT
• SCRAPY_PYTHON_SHELL

По умолчанию структура Scrapy Project

Следующая структура показывает файловую структуру по умолчанию для проекта 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
      . . .

Файл scrapy.cfg является корневым каталогом проекта, который включает имя проекта с настройками проекта. Например —

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

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

Используя Scrapy Tool

Инструмент Scrapy предоставляет некоторые возможности использования и доступные команды следующим образом:

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

Создание проекта

Вы можете использовать следующую команду для создания проекта в Scrapy —

scrapy startproject project_name

Это создаст проект с именем каталог_проекта . Затем перейдите к вновь созданному проекту, используя следующую команду —

cd  project_name

Контроллинг проектов

Вы можете контролировать проект и управлять им, используя инструмент Scrapy, а также создать нового паука, используя следующую команду —

scrapy genspider mydomain mydomain.com

Такие команды, как сканирование и т. Д., Должны использоваться внутри проекта Scrapy. В следующем разделе вы узнаете, какие команды должны выполняться внутри проекта Scrapy.

Scrapy содержит несколько встроенных команд, которые можно использовать для вашего проекта. Чтобы увидеть список доступных команд, используйте следующую команду —

scrapy -h

Когда вы выполните следующую команду, Scrapy отобразит список доступных команд, как указано ниже:

• fetch — выбирает URL с помощью загрузчика Scrapy.

• runspider — используется для запуска автономного паука без создания проекта.

• параметры настройки — это определяет значение настройки проекта.

• shell — это интерактивный модуль очистки по заданному URL.

• startproject — создает новый проект Scrapy.

• версия — отображает версию Scrapy.

• view — получает URL с помощью загрузчика Scrapy и отображает содержимое в браузере.

fetch — выбирает URL с помощью загрузчика Scrapy.

runspider — используется для запуска автономного паука без создания проекта.

параметры настройки — это определяет значение настройки проекта.

shell — это интерактивный модуль очистки по заданному URL.

startproject — создает новый проект Scrapy.

версия — отображает версию Scrapy.

view — получает URL с помощью загрузчика Scrapy и отображает содержимое в браузере.

Вы можете иметь несколько связанных с проектом команд, как указано в списке —

• crawl — используется для сканирования данных с помощью паука.

• check — Проверяет элементы, возвращенные командой сканирования.

• list — отображает список доступных пауков, присутствующих в проекте.

• редактировать — вы можете редактировать пауков с помощью редактора.

• parse — анализирует данный URL с пауком

• bench — используется для запуска быстрого теста производительности (Benchmark сообщает, сколько страниц Scrawling может сканировать в минуту).

crawl — используется для сканирования данных с помощью паука.

check — Проверяет элементы, возвращенные командой сканирования.

list — отображает список доступных пауков, присутствующих в проекте.

редактировать — вы можете редактировать пауков с помощью редактора.

parse — анализирует данный URL с пауком

bench — используется для запуска быстрого теста производительности (Benchmark сообщает, сколько страниц Scrawling может сканировать в минуту).

Пользовательские команды проекта

Вы можете создать собственную команду проекта с параметром COMMANDS_MODULE в проекте Scrapy. Он включает в себя пустую строку по умолчанию в настройке. Вы можете добавить следующую пользовательскую команду —

COMMANDS_MODULE = 'mycmd.commands'

Команды Scrapy можно добавить с помощью раздела scrapy.commands в файле setup.py, который показан ниже:

from setuptools import setup, find_packages  

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

Приведенный выше код добавляет команду cmd_demo в файл setup.py .

Scrapy — Пауки

Описание

Spider — это класс, отвечающий за определение того, как переходить по ссылкам через веб-сайт и извлекать информацию со страниц.

Пауки Scrapy по умолчанию следующие:

scrapy.Spider

Это паук, от которого все остальные пауки должны наследовать. У него есть следующий класс —

class scrapy.spiders.Spider

В следующей таблице приведены поля scrapy.Spider class —

название

Это имя вашего паука.

allowed_domains

Это список доменов, по которым ползает паук.

start_urls

Это список URL-адресов, которые будут корнями для последующих сканирований, откуда начнет сканировать паук.

Пользовательские настройки

Эти настройки, при запуске паука, будут переопределены в конфигурации всего проекта.

гусеничный трактор

Это атрибут, который ссылается на объект Crawler, к которому привязан экземпляр паука.

настройки

Это настройки для запуска паука.

лесоруб

Это регистратор Python, используемый для отправки сообщений журнала.

from_crawler (гусеничный, * Args, ** kwargs)

Это метод класса, который создает вашего паука. Параметры —

сканер — сканер, к которому будет привязан экземпляр паука.

args (list) — эти аргументы передаются методу _init_ () .

kwargs (dict) — эти ключевые аргументы передаются методу _init_ () .

start_requests ()

Если конкретные URL-адреса не указаны, а паук открыт для списания, Scrapy вызывает метод start_requests () .

make_requests_from_url (URL)

Это метод, используемый для преобразования URL-адресов в запросы.

синтаксический анализ (ответ)

Этот метод обрабатывает ответ и возвращает отмененные данные по следующим URL-адресам.

журнал (сообщение [уровень, компонент])

Это метод, который отправляет сообщение журнала через регистратор пауков.

закрытая (причина)

Этот метод вызывается, когда паук закрывается.

Аргументы Паука

Аргументы Spider используются для указания начальных URL-адресов и передаются с помощью команды сканирования с параметром -a , который показан ниже:

scrapy crawl first_scrapy -a group = accessories

Следующий код демонстрирует, как паук получает аргументы —

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]

Универсальные пауки

Вы можете использовать общих пауков, чтобы подклассы ваших пауков от. Их цель состоит в том, чтобы следовать всем ссылкам на веб-сайте на основе определенных правил для извлечения данных со всех страниц.

Для примеров, используемых в следующих пауках, давайте предположим, что у нас есть проект со следующими полями:

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

CrawlSpider

CrawlSpider определяет набор правил для перехода по ссылкам и удаления более одной страницы. У него есть следующий класс —

class scrapy.spiders.CrawlSpider

Ниже приведены атрибуты класса CrawlSpider —

правила

Это список объектов правил, который определяет, как сканер следует по ссылке.

В следующей таблице приведены правила класса CrawlSpider —

LinkExtractor

Он определяет, как паук следует по ссылкам и извлекает данные.

Перезвоните

Это должно быть вызвано после того, как каждая страница очищена.

следовать

Указывает, следует ли продолжать следующие ссылки или нет.

parse_start_url (ответ)

Он возвращает либо элемент, либо объект запроса, позволяя проанализировать начальные ответы.

Примечание. Убедитесь, что вы переименовываете функцию разбора, отличную от разбора, при написании правил, потому что функция разбора используется CrawlSpider для реализации своей логики.

Давайте посмотрим на следующий пример, где spider начинает сканировать домашнюю страницу demoexample.com, собирая все страницы, ссылки и анализ с помощью метода 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

Это базовый класс для пауков, которые очищают от XML-каналов и перебирают узлы. У него есть следующий класс —

class scrapy.spiders.XMLFeedSpider

В следующей таблице показаны атрибуты класса, используемые для установки итератора и имени тега.

итератор

Он определяет используемый итератор. Это может быть iternodes, html или xml . По умолчанию это iternodes .

itertag

Это строка с именем узла для повторения.

Пространства имен

Он определяется списком (prefix, uri) кортежей, которые автоматически регистрируют пространства имен с помощью метода register_namespace () .

adapt_response (ответ)

Он получает ответ и изменяет тело ответа, как только он прибывает из промежуточного программного обеспечения паука, прежде чем паук начнет его анализировать.

parse_node (ответ, селектор)

Он получает ответ и селектор при вызове для каждого узла, соответствующего указанному имени тега.

Примечание. Ваш паук не будет работать, если вы не переопределите этот метод.

process_results (ответ, итоги)

Возвращает список результатов и ответ, возвращенный пауком.

CSVFeedSpider

Он перебирает каждую из своих строк, получает CSV-файл в качестве ответа и вызывает метод parse_row () . У него есть следующий класс —

class scrapy.spiders.CSVFeedSpider

В следующей таблице показаны параметры, которые можно установить для файла CSV.

ограничитель

Это строка, содержащая разделитель запятой (‘,’) для каждого поля.

QuoteChar

Это строка, содержащая кавычку (‘»‘) для каждого поля.

заголовки

Это список операторов, из которых можно извлечь поля.

parse_row (ответ, строка)

Он получает ответ и каждую строку вместе с ключом для заголовка.

Пример 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 с помощью файлов Sitemap сканирует веб-сайт, находя URL-адреса из файла robots.txt. У него есть следующий класс —

class scrapy.spiders.SitemapSpider

В следующей таблице показаны поля SitemapSpider —

sitemap_urls

Список URL-адресов, которые вы хотите сканировать, указывая на карты сайта.

sitemap_rules

Это список кортежей (регулярное выражение, обратный вызов), где регулярное выражение является регулярным выражением, а обратный вызов используется для обработки URL-адресов, соответствующих регулярному выражению.

sitemap_follow

Это список регулярных выражений карты сайта.

sitemap_alternate_links

Определяет альтернативные ссылки, по которым нужно перейти для одного URL.

Пример SitemapSpider

Следующий SitemapSpider обрабатывает все 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

Следующий SitemapSpider обрабатывает некоторые URL с обратным вызовом —

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 

В следующем коде показаны файлы Sitemap в файле robots.txt, URL которого содержит / 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 

Вы даже можете комбинировать SitemapSpider с другими URL-адресами, как показано в следующей команде.

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... 

Scrapy — Селекторы

Описание

Когда вы просматриваете веб-страницы, вам нужно извлечь определенную часть исходного кода HTML с помощью механизма селекторов , который достигается с помощью выражений XPath или CSS. Селекторы построены на библиотеке lxml , которая обрабатывает XML и HTML на языке Python.

Используйте следующий фрагмент кода, чтобы определить различные концепции селекторов —

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

Построение селекторов

Вы можете создать экземпляры класса селектора, передав текст или объект TextResponse . На основе предоставленного типа ввода селектор выбирает следующие правила:

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

Используя приведенный выше код, вы можете построить из текста как —

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

Он будет отображать результат как —

[u'Hello world!!!'] 

Вы можете построить из ответа как —

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

Он будет отображать результат как —

[u'Hello world!!!']

Использование селекторов

Используя приведенный выше простой фрагмент кода, вы можете создать XPath для выделения текста, который определен в теге title, как показано ниже:

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

Теперь вы можете извлечь текстовые данные, используя метод .extract (), показанный ниже:

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

Это даст результат как —

[u'My Website']

Вы можете отобразить имя всех элементов, показанных ниже:

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

Это будет отображать элементы как —

Link 1
Link 2
Link 3

Если вы хотите извлечь первый элемент, используйте метод .extract_first () , показанный ниже:

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

Он будет отображать элемент как —

Link 1

Вложенные селекторы

Используя приведенный выше код, вы можете вкладывать селекторы для отображения ссылки на страницу и источника изображения, используя метод .xpath () , показанный ниже:

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 

Он будет отображать результат как —

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

Селекторы, использующие регулярные выражения

Scrapy позволяет извлекать данные с помощью регулярных выражений, используя метод .re () . Из приведенного выше HTML-кода мы извлечем имена изображений, показанные ниже:

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

Выше строка отображает имена изображений в виде —

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

Использование относительных XPath

Когда вы работаете с XPath, который начинается с / , вложенные селекторы и XPath связаны с абсолютным путем документа, а не с относительным путем селектора.

Если вы хотите извлечь элементы <p> , то сначала получите все элементы div —

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

Затем вы можете извлечь все элементы ‘p’ внутри, добавив к XPath точку с точкой .//p, как показано ниже —

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

Использование расширений EXSLT

EXSLT — это сообщество, которое выпускает расширения для XSLT (преобразования языка расширяемой таблицы стилей), который преобразует XML-документы в XHTML-документы. Вы можете использовать расширения EXSLT с зарегистрированным пространством имен в выражениях XPath, как показано в следующей таблице:

ре

регулярные выражения

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

задавать

манипулирование множеством

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

Вы можете проверить простой формат кода для извлечения данных, используя регулярные выражения в предыдущем разделе.

Есть несколько советов по XPath, которые полезны при использовании XPath с селекторами Scrapy. Для получения дополнительной информации, нажмите на эту ссылку .

Scrapy — Предметы

Описание

Процесс Scrapy можно использовать для извлечения данных из таких источников, как веб-страницы, используя пауков. Scrapy использует класс Item для создания выходных данных, чьи объекты используются для сбора очищенных данных.

Объявление предметов

Вы можете объявить элементы, используя синтаксис определения класса вместе с объектами поля, показанными следующим образом:

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

Поля предметов

Поля элемента используются для отображения метаданных для каждого поля. Поскольку нет ограничений на значения для объектов поля, доступные ключи метаданных не содержат никакого списка ссылок метаданных. Объекты поля используются для указания всех метаданных поля, и вы можете указать любой другой ключ поля согласно вашему требованию в проекте. К объектам поля можно получить доступ с помощью атрибута Item.fields.

Работа с предметами

Есть несколько общих функций, которые можно определить при работе с элементами. Для получения дополнительной информации, нажмите на эту ссылку .

Расширение предметов

Элементы могут быть расширены путем указания подкласса исходного элемента. Например —

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

Вы можете использовать существующие метаданные поля для расширения метаданных поля, добавив дополнительные значения или изменив существующие значения, как показано в следующем коде:

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

Предмет Объекты

Объекты элемента могут быть определены с использованием следующего класса, который предоставляет новый инициализированный элемент из данного аргумента —

class scrapy.item.Item([arg])

Item предоставляет копию конструктора и предоставляет дополнительный атрибут, который задается элементами в полях.

Полевые объекты

Объекты поля могут быть указаны с использованием следующего класса, в котором класс Field не выдает дополнительный процесс или атрибуты:

class scrapy.item.Field([arg])

Scrapy — Загрузчики предметов

Описание

Загрузчики элементов предоставляют удобный способ заполнять элементы, которые соскребаются с веб-сайтов.

Объявление загрузчиков предметов

Объявление Загрузчиков Предметов подобно Предметам.

Например —

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

В приведенном выше коде вы можете видеть, что входные процессоры объявлены с использованием суффикса _in, а выходные процессоры объявлены с использованием суффикса _out .

Атрибуты ItemLoader.default_input_processor и ItemLoader.default_output_processor используются для объявления процессоров ввода / вывода по умолчанию.

Использование загрузчиков элементов для заполнения элементов

Чтобы использовать Item Loader, сначала создайте экземпляр с помощью dict-like объекта или без него, где элемент использует класс Item, указанный в атрибуте ItemLoader.default_item_class .

• Вы можете использовать селекторы для сбора значений в Загрузчик элементов.

• Вы можете добавить больше значений в том же поле элемента, где загрузчик элементов будет использовать соответствующий обработчик для добавления этих значений.

Вы можете использовать селекторы для сбора значений в Загрузчик элементов.

Вы можете добавить больше значений в том же поле элемента, где загрузчик элементов будет использовать соответствующий обработчик для добавления этих значений.

Следующий код демонстрирует, как элементы заполняются с помощью загрузчиков элементов.

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

Как показано выше, есть два разных XPath, из которых поле заголовка извлекается с помощью метода add_xpath () —

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

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

После этого аналогичный запрос используется для поля desc . Данные о размере извлекаются с использованием метода add_css (), а last_updated заполняется значением «вчера» с использованием метода add_value () .

Как только все данные собраны, вызовите метод ItemLoader.load_item (), который возвращает элементы, заполненные данными, извлеченными с использованием методов add_xpath () , add_css () и add_value () .

Процессоры ввода и вывода

Каждое поле загрузчика элементов содержит один входной процессор и один выходной процессор.

• Когда данные извлекаются, процессор ввода обрабатывает их и их результат сохраняется в ItemLoader.

• Затем, после сбора данных, вызовите метод ItemLoader.load_item (), чтобы получить заполненный объект Item.

• Наконец, вы можете присвоить результат обработчику вывода элементу.

Когда данные извлекаются, процессор ввода обрабатывает их и их результат сохраняется в ItemLoader.

Затем, после сбора данных, вызовите метод ItemLoader.load_item (), чтобы получить заполненный объект Item.

Наконец, вы можете присвоить результат обработчику вывода элементу.

Следующий код демонстрирует, как вызывать процессоры ввода и вывода для определенного поля:

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]

Строка 1 — данные заголовка извлекаются из xpath1 и передаются через процессор ввода, а их результат собирается и сохраняется в ItemLoader.

Строка 2 — аналогично, заголовок извлекается из xpath2 и проходит через тот же процессор ввода, а его результат добавляется к данным, собранным для [1].

Строка 3 — заголовок извлекается из селектора css и передается через тот же процессор ввода, а результат добавляется к данным, собранным для [1] и [2].

Строка 4 — Далее значение «demo» назначается и передается через процессоры ввода.

Строка 5 — Наконец, данные собираются внутри всех полей и передаются в выходной процессор, и окончательное значение присваивается Элементу.

Объявление процессоров ввода и вывода

Процессоры ввода и вывода объявлены в определении ItemLoader. Кроме того, они также могут быть указаны в метаданных поля элемента .

Например —

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

Он отображает вывод как —

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

Контекст загрузчика элементов

Контекст загрузчика элементов — это набор произвольных значений ключей, общих для процессоров ввода и вывода.

Например, предположим, что у вас есть функция 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

Получая аргументы loader_context, он сообщает загрузчику элементов, что он может получить контекст загрузчика элементов. Есть несколько способов изменить значение контекста Item Loader —

• Изменить текущий активный контекст загрузчика элементов —

Изменить текущий активный контекст загрузчика элементов —

loader = ItemLoader (product)
loader.context ["unit"] = "mm"

• На экземпляре Item Loader —

На экземпляре Item Loader —

loader = ItemLoader(product, unit = "mm")

• В объявлении Item Loader для процессоров ввода / вывода, которые создаются с контекстом Item Loader —

В объявлении Item Loader для процессоров ввода / вывода, которые создаются с контекстом Item Loader —

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

ItemLoader Objects

Это объект, который возвращает загрузчик нового элемента, чтобы заполнить данный элемент. У него есть следующий класс —

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

В следующей таблице приведены параметры объектов ItemLoader —

вещь

Это элемент для заполнения с помощью вызова add_xpath (), add_css () или add_value ().

селектор

Он используется для извлечения данных с веб-сайтов.

ответ

Он используется для создания селектора с использованием default_selector_class.

В следующей таблице показаны методы объектов ItemLoader —

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

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

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

# 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 (.*)")

# 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 (.*)')

# 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 (.*)')

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

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

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

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

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

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

get_value (значение, * процессоры, ** kwargs)

При заданном аргументе процессора и ключевого слова значение обрабатывается методом get_value ().

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

Он обрабатывает значение и добавляет его в поле, где оно сначала передается через get_value, передавая процессоры и аргументы ключевых слов перед передачей через поле ввода процессора.

replace_value (имя_поля, значение, * процессоры, ** kwargs)

Он заменяет собранные данные новым значением.

get_xpath (xpath, * процессоры, ** kwargs)

Он используется для извлечения строк Юникода, давая процессоры и аргументы ключевых слов, получая XPath .

add_xpath (имя_поля, xpath, * процессоры, ** kwargs)

Он получает XPath в поле, которое извлекает строки Unicode.

replace_xpath (field_name, xpath, * процессоры, ** kwargs)

Он заменяет собранные данные с помощью XPath с сайтов.

get_css (css, * процессоры, ** kwargs)

Он получает селектор CSS, используемый для извлечения Unicode-строк.

add_css (имя_поля, css, * процессоры, ** kwargs)

Он похож на метод add_value () с одним отличием в том, что он добавляет селектор CSS в поле.

replace_css (имя_поля, css, * процессоры, ** kwargs)

Он заменяет извлеченные данные с помощью селектора CSS.

load_item ()

Когда данные собраны, этот метод заполняет элемент собранными данными и возвращает их.

nested_xpath (XPath)

Он используется для создания вложенных загрузчиков с помощью селектора XPath.

nested_css (CSS)

Он используется для создания вложенных загрузчиков с помощью селектора CSS.

В следующей таблице показаны атрибуты объектов ItemLoader —

вещь

Это объект, на котором Item Loader выполняет разбор.

контекст

Это текущий контекст загрузчика элементов, который активен.

default_item_class

Он используется для представления элементов, если он не указан в конструкторе.

default_input_processor

Поля, в которых не указан процессор ввода, являются единственными, для которых используются default_input_processors.

default_output_processor

Поля, в которых не указан выходной процессор, являются единственными, для которых используются default_output_processors.

default_selector_class

Это класс, используемый для создания селектора, если он не задан в конструкторе.

селектор

Это объект, который можно использовать для извлечения данных с сайтов.

Вложенные Погрузчики

Он используется для создания вложенных загрузчиков при разборе значений из подраздела документа. Если вы не создаете вложенные загрузчики, вам нужно указать полный XPath или CSS для каждого значения, которое вы хотите извлечь.

Например, предположим, что данные извлекаются из страницы заголовка —

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

Затем вы можете создать вложенный загрузчик с селектором заголовка, добавив связанные значения в заголовок —

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

Повторное использование и расширение загрузчиков предметов

Загрузчики предметов предназначены для облегчения обслуживания, которое становится фундаментальной проблемой, когда ваш проект приобретает больше пауков.

Например, предположим, что на сайте название продукта заключено в три черты (например, —DVD —). Вы можете удалить эти черточки, повторно используя загрузчик элементов товара по умолчанию, если вы не хотите, чтобы он был в окончательных названиях продуктов, как показано в следующем коде —

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)

Доступные встроенные процессоры

Ниже приведены некоторые из наиболее часто используемых встроенных процессоров:

класс scrapy.loader.processors.Identity

Возвращает исходное значение без изменения. Например —

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

класс scrapy.loader.processors.TakeFirst

Возвращает первое значение, которое не является нулевым / непустым из списка полученных значений. Например —

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

класс scrapy.loader.processors.Join (разделитель = u »)

Возвращает значение, прикрепленное к разделителю. Разделителем по умолчанию является u », и он эквивалентен функции u » .join . Например —

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

класс scrapy.loader.processors.Compose (* функции, ** default_loader_context)

Он определяется процессором, в котором каждое его входное значение передается первой функции, а результат этой функции передается второй функции и т. Д., Пока функция ast не вернет конечное значение в качестве вывода.

Например —

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

класс scrapy.loader.processors.MapCompose (* функции, ** default_loader_context)

Это процессор, в котором входное значение повторяется, и первая функция применяется к каждому элементу. Затем результат этих вызовов функций объединяется для создания новой итерации, которая затем применяется ко второй функции и т. Д. До последней функции.

Например —

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

класс scrapy.loader.processors.SelectJmes (json_path)

Этот класс запрашивает значение, используя предоставленный путь json, и возвращает выходные данные.

Например —

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

Ниже приведен код, который запрашивает значение путем импорта 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']

Scrapy — Shell

Описание

Оболочку Scrapy можно использовать для очистки данных с помощью безошибочного кода, без использования паука. Основная цель оболочки Scrapy — проверить извлеченный код, XPath или CSS-выражения. Это также помогает указать веб-страницы, с которых вы копируете данные.

Настройка оболочки

Оболочку можно настроить, установив консоль IPython (используется для интерактивных вычислений), которая представляет собой мощную интерактивную оболочку, которая обеспечивает автоматическое завершение, цветной вывод и т. Д.

Если вы работаете на платформе Unix, то лучше установить IPython. Вы также можете использовать bpython , если IPython недоступен.

Вы можете настроить оболочку, установив переменную среды SCRAPY_PYTHON_SHELL или определив файл scrapy.cfg следующим образом:

[settings]
shell = bpython

Запуск оболочки

Оболочка Scrapy может быть запущена с помощью следующей команды —

scrapy shell <url>

URL-адрес указывает URL-адрес, для которого необходимо очистить данные.

Используя Shell

Оболочка предоставляет некоторые дополнительные ярлыки и объекты Scrapy, как описано в следующей таблице:

Доступные ярлыки

Shell предоставляет следующие доступные ярлыки в проекте —

shelp ()

Он предоставляет доступные объекты и ярлыки с помощью опции справки.

выборки (request_or_url)

Он собирает ответ от запроса или URL, и связанные объекты будут обновляться должным образом.

Вид (ответ)

Вы можете просмотреть ответ на данный запрос в локальном браузере для наблюдения и, чтобы правильно отобразить внешнюю ссылку, он добавляет базовый тег к телу ответа.

Доступные объекты Scrapy

Shell предоставляет следующие доступные объекты Scrapy в проекте —

гусеничный трактор

Он указывает текущий объект сканера.

паук

Если для текущего URL нет паука, он будет обрабатывать объект URL или паука, определяя нового паука.

запрос

Указывает объект запроса для последней собранной страницы.

ответ

Он указывает объект ответа для последней собранной страницы.

настройки

Он предоставляет текущие настройки Scrapy.

Пример сессии Shell

Давайте попробуем очистить сайт scrapy.org, а затем начнем собирать данные с reddit.com, как описано.

Прежде чем двигаться вперед, сначала запустим оболочку, как показано в следующей команде —

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

Scrapy будет отображать доступные объекты при использовании вышеуказанного 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

Далее начнем с обработки объектов, показанных следующим образом —

>> 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     
... 

Вызов оболочки от пауков для проверки ответов

Вы можете проверить ответы, которые обрабатываются пауком, только если вы ожидаете получить этот ответ.

Например —

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)

Как показано в приведенном выше коде, вы можете вызывать оболочку от пауков для проверки ответов, используя следующую функцию —

scrapy.shell.inspect_response

Теперь запустите паука, и вы получите следующий экран —

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' 

Вы можете проверить, работает ли извлеченный код, используя следующий код —

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

Он отображает вывод как

[]

Выше строка показала только пустой вывод. Теперь вы можете вызвать оболочку для проверки ответа следующим образом:

>> view(response)

Он отображает ответ как

True

Scrapy — Item Pipeline

Описание

Конвейер элементов — это метод обработки отбракованных элементов. Когда элемент отправляется в конвейер элементов, он обрабатывается пауком и обрабатывается с использованием нескольких компонентов, которые выполняются последовательно.

Всякий раз, когда предмет получен, он решает одно из следующих действий:

• Продолжайте обрабатывать предмет.
• Брось это из трубопровода.
• Прекратить обработку элемента.

Товаропроводы обычно используются для следующих целей —

• Хранение очищенных элементов в базе данных.
• Если полученный предмет повторяется, он отбрасывает повторяющийся предмет.
• Он проверит, относится ли элемент к целевым полям.
• Очистка данных HTML.

Синтаксис

Вы можете написать Item Pipeline, используя следующий метод —

process_item(self, item, spider) 

Вышеуказанный метод содержит следующие параметры:

• Предмет (предметный предмет или словарь) — указывает очищаемый предмет.
• паук (объект паука) — паук, который очистил предмет.

Вы можете использовать дополнительные методы, приведенные в следующей таблице —

open_spider ( сам, паук )

Он выбирается при открытии паука.

паук (объект паука) — относится к открытому пауку.

close_spider ( сам, паук )

Выбирается, когда паук закрыт.

паук (объект паука) — относится к пауку, который был закрыт.

from_crawler ( cls, crawler )

С помощью сканера, конвейер может получить доступ к основным компонентам, таким как сигналы и настройки Scrapy.

crawler (объект Crawler) — относится к сканеру, который использует этот конвейер.

пример

Ниже приведены примеры конвейера элементов, используемых в различных концепциях.

Отбрасывание предметов без тега

В следующем коде конвейер балансирует атрибут (цена) для тех товаров, которые не включают НДС (атрибут exclude_vat), и игнорирует те товары, у которых нет ценника.

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) 

Запись элементов в файл JSON

Следующий код будет хранить все очищенные элементы от всех пауков в одном файле items.jl , который содержит один элемент на строку в сериализованной форме в формате JSON. Класс JsonWriterPipeline используется в коде, чтобы показать, как писать конвейер элементов —

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

Запись элементов в MongoDB

Вы можете указать адрес и имя базы данных MongoDB в настройках Scrapy, а коллекцию MongoDB можно назвать по имени класса элемента. Следующий код описывает, как использовать метод from_crawler () для правильного сбора ресурсов:

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

Дублирующие фильтры

Фильтр проверит повторяющиеся элементы и отбросит уже обработанные элементы. В следующем коде мы использовали уникальный идентификатор для наших элементов, но spider возвращает много элементов с одинаковым идентификатором —

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

Активация конвейера предметов

Вы можете активировать компонент Item Pipeline, добавив его класс в настройку ITEM_PIPELINES, как показано в следующем коде. Вы можете присваивать целочисленные значения классам в порядке их выполнения (порядок может быть ниже для классов с более высокими значениями), и значения будут находиться в диапазоне 0-1000.

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

Scrapy — Экспорт кормов

Описание

Экспорт фидов — это метод хранения данных, извлеченных с сайтов, который создает «файл экспорта» .

Форматы сериализации

Используя несколько форматов сериализации и хранилища данных, Feed Exports использует экспортеры элементов и генерирует ленту с очищенными элементами.

В следующей таблице приведены поддерживаемые форматы

JSON

FEED_FORMAT — это JSON

Используется экспортер класса scrapy.exporters.JsonItemExporter

Строки JSON

FEED_FROMAT — это jsonlines

Используется экспортер класса scrapy.exporters.JsonLinesItemExporter

CSV

FEED_FORMAT — это CSV

Используемым экспортером является класс scrapy.exporters.CsvItemExporter

XML

FEED_FORMAT — это xml

Используется экспортер класса scrapy.exporters.XmlItemExporter

Используя настройки FEED_EXPORTERS , поддерживаемые форматы также могут быть расширены —

Соленый огурец

FEED_FORMAT это пикель

Используется экспортер класса scrapy.exporters.PickleItemExporter

маршал

FEED_FORMAT является маршалом

Используется экспортер класса scrapy.exporters.MarshalItemExporter

Хранение Backends

Бэкэнд хранилища определяет, где хранить канал, используя URI.

В следующей таблице приведены поддерживаемые бэкэнды хранилища.

Локальная файловая система

Схема URI является файловой и используется для хранения каналов.

FTP

Схема URI — ftp, и она используется для хранения каналов.

S3

Схема URI — S3, а каналы хранятся в Amazon S3. Требуются внешние библиотеки botocore или boto .

Стандартный вывод

Схема URI — это стандартный вывод, и каналы сохраняются для стандартного вывода.

Параметры URI хранилища

Ниже приведены параметры URL-адреса хранилища, который заменяется при создании канала.

• % (время) с: этот параметр заменяется меткой времени.
• % (name) s: этот параметр заменяется именем паука.

настройки

В следующей таблице приведены параметры, с помощью которых можно настроить экспорт каналов.

FEED_URI

Это URI фида экспорта, используемый для включения экспорта фидов.

FEED_FORMAT

Это формат сериализации, используемый для канала.

FEED_EXPORT_FIELDS

Используется для определения полей, которые необходимо экспортировать.

FEED_STORE_EMPTY

Определяет, экспортировать ли каналы без элементов.

FEED_STORAGES

Это словарь с дополнительными хранилищами каналов.

FEED_STORAGES_BASE

Это словарь со встроенным хранилищем каналов.

FEED_EXPORTERS

Это словарь с дополнительными кормами для экспортеров.

FEED_EXPORTERS_BASE

Это словарь со встроенными фидами экспортеров.

Scrapy — Запросы и ответы

Описание

Scrapy может сканировать веб-сайты, используя объекты запросов и ответов . Объекты запроса проходят через систему, используют пауки для выполнения запроса и возвращаются к запросу, когда он возвращает объект ответа.

Объекты запроса

Объект запроса — это HTTP-запрос, который генерирует ответ. У него есть следующий класс —

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

В следующей таблице приведены параметры объектов запроса —

URL

Это строка, которая указывает URL-запрос.

Перезвоните

Это вызываемая функция, которая использует ответ на запрос в качестве первого параметра.

метод

Это строка, определяющая запрос метода HTTP.

заголовки

Это словарь с заголовками запросов.

тело

Это строка или Unicode, которая имеет тело запроса.

печенье

Это список, содержащий запрос куки.

мета

Это словарь, который содержит значения для метаданных запроса.

кодирование

Это строка, содержащая кодировку utf-8, используемую для кодирования URL.

приоритет

Это целое число, в котором планировщик использует приоритет для определения порядка обработки запросов.

dont_filter

Это логическое значение, указывающее, что планировщик не должен фильтровать запрос.

errback

Это вызываемая функция, которая вызывается при возникновении исключения во время обработки запроса.

Передача дополнительных данных в функции обратного вызова

Функция обратного вызова запроса вызывается, когда ответ загружается в качестве первого параметра.

Например —

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) 

Вы можете использовать атрибут Request.meta , если хотите передать аргументы вызываемым функциям и получить эти аргументы во втором обратном вызове , как показано в следующем примере —

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

Использование ошибок для отлова исключений в обработке запросов

Ошибка — это вызываемая функция, которая вызывается при возникновении исключения во время обработки запроса.

Следующий пример демонстрирует это —

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 Специальные ключи

Специальные ключи request.meta — это список специальных мета-ключей, идентифицированных Scrapy.

В следующей таблице приведены некоторые ключи Request.meta —

dont_redirect

Это ключ, если задано значение true, не перенаправляет запрос в зависимости от состояния ответа.

dont_retry

Этот ключ имеет значение true, не повторяет неудавшиеся запросы и будет игнорироваться промежуточным ПО.

handle_httpstatus_list

Это ключ, который определяет, какие коды ответов могут быть разрешены для каждого запроса.

handle_httpstatus_all

Это ключ, используемый для разрешения любого кода ответа на запрос путем установки его в значение true .

dont_merge_cookies

Это ключ, который используется для предотвращения слияния с существующими файлами cookie, установив для него значение true .

cookiejar

Это ключ, используемый для хранения нескольких сеансов cookie для каждого паука.

dont_cache

Это ключ, используемый для предотвращения кэширования HTTP-запросов и ответов на каждую политику.

redirect_urls

Это ключ, содержащий URL-адреса, по которым проходят запросы.

BindAddress

Это IP-адрес исходящего IP-адреса, который можно использовать для выполнения запроса.

dont_obey_robotstxt

Ключ имеет значение true и не фильтрует запросы, запрещенные стандартом исключения robots.txt, даже если включен ROBOTSTXT_OBEY.

download_timeout

Он используется для установки времени ожидания (в секундах) для каждого паука, которое загрузчик будет ожидать до истечения времени ожидания.

download_maxsize

Он используется для установки максимального размера (в байтах) для каждого паука, который загрузчик загрузит.

полномочие

Прокси может быть установлен для объектов запроса, чтобы установить HTTP прокси для использования запросов.

Запросить подклассы

Вы можете реализовать свои собственные пользовательские функции, создав подкласс класса запроса. Встроенные подклассы запроса следующие:

Объекты FormRequest

Класс FormRequest работает с HTML-формами, расширяя базовый запрос. У него есть следующий класс —

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

Следующий параметр —

formdata — это словарь, содержащий данные формы HTML, которые назначаются телу запроса.

Примечание. Остальные параметры соответствуют классу запроса и описаны в разделе « Объекты запроса ».

Следующие методы класса поддерживаются объектами FormRequest в дополнение к методам запроса:

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

В следующей таблице приведены параметры вышеуказанного класса —

ответ

Это объект, используемый для предварительного заполнения полей формы с использованием HTML-формы ответа.

FormName

Это строка, в которой будет использоваться форма с атрибутом name, если она указана.

formnumber

Это целое число форм, которые должны использоваться, когда в ответе есть несколько форм.

FormData

Это словарь полей в данных формы, используемых для переопределения.

formxpath

Это указанная строка, используется форма, соответствующая xpath.

formcss

Это указанная строка, используется форма, соответствующая селектору css.

clickdata

Это словарь атрибутов, используемый для наблюдения за нажатием на элемент управления.

dont_click

Данные из формы будут отправлены без щелчка по любому элементу, если установлено значение true.

Примеры

Ниже приведены некоторые примеры использования запросов:

Использование FormRequest для отправки данных через HTTP POST

Следующий код демонстрирует, как вернуть объект FormRequest, когда вы хотите скопировать HTML-форму POST в вашем пауке —

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

Использование FormRequest.from_response () для имитации входа пользователя

Обычно веб-сайты используют элементы, через которые он предоставляет предварительно заполненные поля формы.

Метод FormRequest.form_response () можно использовать, если вы хотите, чтобы эти поля автоматически заполнялись при очистке.

Следующий пример демонстрирует это.

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

Объекты ответа

Это объект, указывающий HTTP-ответ, который подается паукам для обработки. У него есть следующий класс —

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

В следующей таблице приведены параметры объектов Response —

URL

Это строка, которая определяет ответ URL.

статус

Это целое число, содержащее ответ о статусе HTTP.

заголовки

Это словарь, содержащий заголовки ответа.

тело

Это строка с телом ответа.

флаги

Это список, содержащий флаги ответа.

Ответные подклассы

Вы можете реализовать свои собственные пользовательские функции, создав подкласс класса ответа. Встроенные подклассы ответа следующие:

TextResponse объекты

Объекты TextResponse используются для двоичных данных, таких как изображения, звуки и т. Д., Которые могут кодировать базовый класс Response. У него есть следующий класс —

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

Следующий параметр —

кодировка — это строка с кодировкой, которая используется для кодирования ответа.

Примечание. Остальные параметры соответствуют классу ответа и описаны в разделе « Объекты ответа ».

В следующей таблице показаны атрибуты, поддерживаемые объектом TextResponse в дополнение к методам ответа.

текст

Это тело ответа, где response.text может быть доступен несколько раз.

кодирование

Это строка, содержащая кодировку для ответа.

селектор

Этот атрибут создается при первом доступе и использует ответ в качестве цели.

В следующей таблице показаны методы, поддерживаемые объектами TextResponse в дополнение к методам ответа.

xpath (запрос)

Это ярлык для TextResponse.selector.xpath (запрос).

css (запрос)

Это ярлык для TextResponse.selector.css (запрос).

body_as_unicode ()

Это тело ответа, доступное как метод, где response.text может быть доступен несколько раз.

HtmlResponse Objects

Это объект, который поддерживает кодирование и автообнаружение, просматривая атрибут HTML httpequiv в HTML. Его параметры совпадают с классом ответа и описаны в разделе «Объекты ответа». У него есть следующий класс —

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

XmlResponse Objects

Это объект, который поддерживает кодирование и автообнаружение, глядя на строку XML. Его параметры совпадают с классом ответа и описаны в разделе «Объекты ответа». У него есть следующий класс —

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

Scrapy — экстракторы ссылок

Описание

Как указывает само название, экстракторы ссылок — это объекты, которые используются для извлечения ссылок с веб-страниц с использованием объектов scrapy.http.Response . В Scrapy есть встроенные экстракторы, такие как scrapy.linkextractors import LinkExtractor . Вы можете настроить свой собственный экстрактор ссылок в соответствии с вашими потребностями, реализовав простой интерфейс.

Каждый экстрактор ссылок имеет открытый метод extract_links, который включает в себя объект Response и возвращает список объектов scrapy.link.Link. Вы можете создавать экземпляры экстракторов ссылок только один раз и вызывать метод extract_links несколько раз, чтобы извлечь ссылки с разными ответами. CrawlSpiderclass использует экстракторы ссылок с набором правил, основной целью которых является извлечение ссылок.

Справочник по встроенным ссылкам

Обычно экстракторы ссылок сгруппированы с Scrapy и представлены в модуле scrapy.linkextractors. По умолчанию экстрактором ссылки будет LinkExtractor, который по функциональности равен 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 — это настоятельно рекомендуемый экстрактор ссылок, поскольку он имеет удобные параметры фильтрации и используется с надежным HTMLParser от lxml.

разрешить (регулярное выражение (или список))

Это позволяет отдельное выражение или группу выражений, которые должны соответствовать URL, который должен быть извлечен. Если это не упомянуто, это будет соответствовать всем ссылкам.

отказать (регулярное выражение (или список))

Он блокирует или исключает одно выражение или группу выражений, которые должны соответствовать URL-адресу, который не должен быть извлечен. Если оно не упомянуто или оставлено пустым, оно не удалит нежелательные ссылки.

allow_domains (str или list)

Это позволяет одну строку или список строк, которые должны соответствовать доменам, из которых должны быть извлечены ссылки.

deny_domains (ул или список)

Он блокирует или исключает одну строку или список строк, которые должны соответствовать доменам, из которых не следует извлекать ссылки.

deny_extensions (список)

Он блокирует список строк с расширениями при извлечении ссылок. Если он не установлен, то по умолчанию будет установлено значение IGNORED_EXTENSIONS, которое содержит предопределенный список в пакете scrapy.linkextractors .

restrict_xpaths (str или list)

Это область списка XPath, из которой ссылки должны быть извлечены из ответа. Если дано, ссылки будут извлечены только из текста, выбранного XPath.

restrict_css (str или list)

Он ведет себя подобно параметру restrict_xpaths, который извлекает ссылки из выделенных областей CSS внутри ответа.

теги (ул или список)

Отдельный тег или список тегов, которые следует учитывать при извлечении ссылок. По умолчанию это будет (‘a’, ‘area’).

attrs (список)

Отдельный атрибут или список атрибутов должны учитываться при извлечении ссылок. По умолчанию это будет (‘href’,).

канонизировать (булево)

Извлеченный URL-адрес приводится в стандартную форму с помощью scrapy.utils.url.canonicalize_url . По умолчанию это будет True.

уникальный (логический)

Он будет использоваться, если извлеченные ссылки будут повторяться.

process_value (вызываемый)

Это функция, которая получает значение из отсканированных тегов и атрибутов. Полученное значение может быть изменено и возвращено, иначе ничего не будет возвращено, чтобы отклонить ссылку. Если не используется, по умолчанию это будет лямбда х: х.

пример

Следующий код используется для извлечения ссылок —

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

Следующая функция кода может использоваться в process_value —

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

Scrapy — Настройки

Описание

Поведение компонентов Scrapy можно изменить с помощью настроек Scrapy. В настройках также можно выбрать проект Scrapy, который в данный момент активен, если у вас есть несколько проектов Scrapy.

Назначение настроек

Вы должны уведомить Scrapy, какие настройки вы используете, когда вы удаляете сайт. Для этого следует использовать переменную окружения SCRAPY_SETTINGS_MODULE , а ее значение должно соответствовать синтаксису пути Python.

Заполнение настроек

В следующей таблице приведены некоторые механизмы, с помощью которых вы можете заполнить настройки —

scrapy crawl myspider -s LOG_FILE = scrapy.log

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

Параметры командной строки

Здесь переданные аргументы имеют наивысший приоритет, переопределяя другие параметры. -S используется для переопределения одного или нескольких параметров.

Настройки на паука

Пауки могут иметь свои собственные настройки, которые переопределяют настройки проекта, используя атрибут custom_settings.

Модуль настроек проекта

Здесь вы можете заполнить свои пользовательские настройки, такие как добавление или изменение настроек в файле settings.py.

Настройки по умолчанию для каждой команды

Каждая команда инструмента Scrapy определяет свои собственные настройки в атрибуте default_settings, чтобы переопределить глобальные настройки по умолчанию.

Глобальные настройки по умолчанию

Эти настройки находятся в модуле scrapy.settings.default_settings.

Настройки доступа

Они доступны через self.settings и устанавливаются в базовом пауке после его инициализации.

Следующий пример демонстрирует это.

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

Чтобы использовать настройки перед инициализацией паука, вы должны переопределить метод from_crawler в методе _init_ () вашего паука. Вы можете получить доступ к настройкам через атрибут scrapy.crawler.Crawler.settings, переданный методу from_crawler .

Следующий пример демонстрирует это.

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

Обоснование настройки имен

Имена параметров добавляются в качестве префикса к компоненту, который они настраивают. Например, для расширения robots.txt имена параметров могут быть ROBOTSTXT_ENABLED, ROBOTSTXT_OBEY, ROBOTSTXT_CACHEDIR и т. Д.

Справочник по встроенным настройкам

В следующей таблице приведены встроенные настройки Scrapy —

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

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

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

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

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

AWS_ACCESS_KEY_ID

Он используется для доступа к веб-сервисам Amazon.

Значение по умолчанию: Нет

AWS_SECRET_ACCESS_KEY

Он используется для доступа к веб-сервисам Amazon.

Значение по умолчанию: Нет

BOT_NAME

Это имя бота, которое можно использовать для создания User-Agent.

Значение по умолчанию: ‘scrapybot’

CONCURRENT_ITEMS

Максимальное количество существующих элементов в процессоре элементов, используемое для параллельной обработки.

Значение по умолчанию: 100

CONCURRENT_REQUESTS

Максимальное количество существующих запросов, которые выполняет загрузчик Scrapy.

Значение по умолчанию: 16

CONCURRENT_REQUESTS_PER_DOMAIN

Максимальное количество существующих запросов, которые выполняются одновременно для любого отдельного домена.

Значение по умолчанию: 8

CONCURRENT_REQUESTS_PER_IP

Максимальное количество существующих запросов, выполняемых одновременно к любому отдельному IP.

Значение по умолчанию: 0

DEFAULT_ITEM_CLASS

Это класс, используемый для представления предметов.

Значение по умолчанию: ‘scrapy.item.Item’

DEFAULT_REQUEST_HEADERS

Это заголовок по умолчанию, используемый для HTTP-запросов Scrapy.

Значение по умолчанию —

DEPTH_LIMIT

Максимальная глубина для паука, чтобы сканировать любой сайт.

Значение по умолчанию: 0

DEPTH_PRIORITY

Это целое число, используемое для изменения приоритета запроса в соответствии с глубиной.

Значение по умолчанию: 0

DEPTH_STATS

Здесь указывается, собирать ли статистику глубины или нет.

Значение по умолчанию: True

DEPTH_STATS_VERBOSE

При включении этого параметра количество запросов собирается в статистике для каждой подробной глубины.

Значение по умолчанию: False

DNSCACHE_ENABLED

Используется для включения DNS в кеш-памяти.

Значение по умолчанию: True

DNSCACHE_SIZE

Он определяет размер DNS в кеше памяти.

Значение по умолчанию: 10000

DNS_TIMEOUT

Он используется для установки времени ожидания DNS для обработки запросов.

Значение по умолчанию: 60

DOWNLOADER

Это загрузчик, используемый для процесса сканирования.

Значение по умолчанию: ‘scrapy.core.downloader.Downloader’

DOWNLOADER_MIDDLEWARES

Это словарь, содержащий загрузчик промежуточного ПО и его заказы.

Значение по умолчанию: {}

DOWNLOADER_MIDDLEWARES_BASE

Это словарь, содержащий промежуточное ПО загрузчика, которое включено по умолчанию.

Значение по умолчанию —

DOWNLOADER_STATS

Этот параметр используется для включения статистики загрузчика.

Значение по умолчанию: True

DOWNLOAD_DELAY

Он определяет общее время загрузки до загрузки страниц с сайта.

Значение по умолчанию: 0

DOWNLOAD_HANDLERS

Это словарь с обработчиками загрузки.

Значение по умолчанию: {}

DOWNLOAD_HANDLERS_BASE

Это словарь с обработчиками загрузки, который включен по умолчанию.

Значение по умолчанию —

DOWNLOAD_TIMEOUT

Общее время ожидания загрузки до истечения времени ожидания.

Значение по умолчанию: 180

DOWNLOAD_MAXSIZE

Это максимальный размер ответа для загрузки загрузчиком.

Значение по умолчанию: 1073741824 (1024 МБ)

DOWNLOAD_WARNSIZE

Он определяет размер ответа, который загрузчик должен предупредить.

Значение по умолчанию: 33554432 (32 МБ)

DUPEFILTER_CLASS

Это класс, используемый для обнаружения и фильтрации повторяющихся запросов.

Значение по умолчанию: ‘scrapy.dupefilters.RFPDupeFilter’

DUPEFILTER_DEBUG

Этот параметр регистрирует все дубликаты фильтров, если установлено значение true.

Значение по умолчанию: False

РЕДАКТОР

Он используется для редактирования пауков с помощью команды редактирования.

Значение по умолчанию: зависит от среды

РАСШИРЕНИЯ

Это словарь с расширениями, которые включены в проект.

Значение по умолчанию: {}

EXTENSIONS_BASE

Это словарь, имеющий встроенные расширения.

Значение по умолчанию: {‘scrapy.extensions.corestats.CoreStats’: 0,}

FEED_TEMPDIR

Это каталог, используемый для установки пользовательской папки, в которой могут храниться временные файлы искателя.

ITEM_PIPELINES

Это словарь с конвейерами.

Значение по умолчанию: {}

LOG_ENABLED

Он определяет, должно ли быть включено ведение журнала.

Значение по умолчанию: True

LOG_ENCODING

Он определяет тип кодирования, который будет использоваться для регистрации.

Значение по умолчанию: ‘utf-8’

ЖУРНАЛЬНЫЙ ФАЙЛ

Это имя файла, который будет использоваться для вывода журнала.

Значение по умолчанию: Нет

LOG_FORMAT

Это строка, с помощью которой сообщения журнала могут быть отформатированы.

Значение по умолчанию: ‘% (asctime) s [% (имя) s]% (имя уровня) s:% (сообщение) s’

LOG_DATEFORMAT

Это строка, в которой можно отформатировать дату / время.

Значение по умолчанию: «% Y-% m-% d% H:% M:% S»

LOG_LEVEL

Он определяет минимальный уровень журнала.

Значение по умолчанию: «DEBUG»

LOG_STDOUT

Если для этого параметра установлено значение true, весь вывод процесса будет отображаться в журнале.

Значение по умолчанию: False

MEMDEBUG_ENABLED

Он определяет, должна ли быть включена отладка памяти.

Значение по умолчанию: False

MEMDEBUG_NOTIFY

Он определяет отчет памяти, который отправляется на определенный адрес, когда включена отладка памяти.

Значение по умолчанию: []

MEMUSAGE_ENABLED

Он определяет, должно ли использоваться использование памяти, когда процесс Scrapy превышает предел памяти.

Значение по умолчанию: False

MEMUSAGE_LIMIT_MB

Он определяет максимально допустимый предел памяти (в мегабайтах).

Значение по умолчанию: 0

MEMUSAGE_CHECK_INTERVAL_SECONDS

Он используется для проверки текущего использования памяти путем установки длины интервалов.

Значение по умолчанию: 60,0

MEMUSAGE_NOTIFY_MAIL

Он используется для уведомления со списком электронных писем, когда память достигает предела.

Значение по умолчанию: False

MEMUSAGE_REPORT

Он определяет, будет ли отправляться отчет об использовании памяти при закрытии каждого паука.

Значение по умолчанию: False

MEMUSAGE_WARNING_MB

Он определяет общий объем памяти, который должен быть разрешен до отправки предупреждения.

Значение по умолчанию: 0

NEWSPIDER_MODULE

Это модуль, в котором новый паук создается с помощью команды genspider.

Значение по умолчанию: »

RANDOMIZE_DOWNLOAD_DELAY

Он определяет случайное время ожидания Scrapy при загрузке запросов с сайта.

Значение по умолчанию: True

REACTOR_THREADPOOL_MAXSIZE

Он определяет максимальный размер пула резьбы реактора.

Значение по умолчанию: 10

REDIRECT_MAX_TIMES

Он определяет, сколько раз запрос может быть перенаправлен.

Значение по умолчанию: 20

REDIRECT_PRIORITY_ADJUST

Этот параметр, если установлен, регулирует приоритет перенаправления запроса.

Значение по умолчанию: +2

RETRY_PRIORITY_ADJUST

Этот параметр, если установлен, регулирует приоритет повторения запроса.

Значение по умолчанию: -1

ROBOTSTXT_OBEY

Scrapy соблюдает правила robots.txt, если установлено значение true .

Значение по умолчанию: False

SCHEDULER

Он определяет планировщик, который будет использоваться для целей сканирования.

Значение по умолчанию: ‘scrapy.core.scheduler.Scheduler’

SPIDER_CONTRACTS

Это словарь проекта, в котором есть контракты с пауками для тестирования пауков.

Значение по умолчанию: {}

SPIDER_CONTRACTS_BASE

Это словарь с контрактами Scrapy, который включен в Scrapy по умолчанию.

Значение по умолчанию —

SPIDER_LOADER_CLASS

Он определяет класс, который реализует API SpiderLoader для загрузки пауков.

Значение по умолчанию: «scrapy.spiderloader.SpiderLoader»

SPIDER_MIDDLEWARES

Это словарь, содержащий промежуточное программное обеспечение для пауков.

Значение по умолчанию: {}

SPIDER_MIDDLEWARES_BASE

Это словарь, содержащий промежуточное программное обеспечение для пауков, которое по умолчанию включено в Scrapy.

Значение по умолчанию —

SPIDER_MODULES

Это список модулей, содержащих пауков, которые Scrapy будет искать.

Значение по умолчанию: []

STATS_CLASS

Это класс, который реализует API Stats Collector для сбора статистики.

Значение по умолчанию: ‘scrapy.statscollectors.MemoryStatsCollector’

STATS_DUMP

Если для этого параметра установлено значение true, статистика выводится в журнал.

Значение по умолчанию: True

STATSMAILER_RCPTS

Как только пауки закончат соскоб, Scrapy использует этот параметр для отправки статистики.

Значение по умолчанию: []

TELNETCONSOLE_ENABLED

Он определяет, следует ли включать telnetconsole.

Значение по умолчанию: True

TELNETCONSOLE_PORT

Он определяет порт для консоли telnet.

Значение по умолчанию: [6023, 6073]

TEMPLATES_DIR

Это каталог, содержащий шаблоны, которые можно использовать при создании новых проектов.

Значение по умолчанию: каталог шаблонов внутри модуля scrapy

URLLENGTH_LIMIT

Он определяет максимальный предел длины для URL, который будет разрешен для просканированных URL.

Значение по умолчанию: 2083

USER_AGENT

Он определяет пользовательский агент, который будет использоваться при сканировании сайта.

Значение по умолчанию: «Scrapy / VERSION (+ http: //scrapy.org)»

Для других настроек Scrapy, перейдите по этой ссылке .

Scrapy — исключения

Описание

Нерегулярные события называются исключениями. В Scrapy исключения вызываются по таким причинам, как отсутствие конфигурации, удаление элемента из конвейера элементов и т. Д. Ниже приведен список исключений, упомянутых в Scrapy и их применении.

DropItem

Item Pipeline использует это исключение, чтобы остановить обработку элемента на любом этапе. Это можно записать как —

exception (scrapy.exceptions.DropItem)

CloseSpider

Это исключение используется для остановки паука с помощью запроса обратного вызова. Это можно записать как —

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

Он содержит параметр под названием причина (str), который указывает причину закрытия.

Например, следующий код показывает использование этого исключения —

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

IgnoreRequest

Это исключение используется промежуточным программным обеспечением планировщика или загрузчика для игнорирования запроса. Это можно записать как —

exception (scrapy.exceptions.IgnoreRequest)

Не настроено

Это указывает на ситуацию с отсутствующей конфигурацией и должно вызываться в конструкторе компонента.

exception (scrapy.exceptions.NotConfigured)

Это исключение можно вызвать, если какой-либо из следующих компонентов отключен.

• расширения
• Пункт трубопроводов
• Загрузчик промежуточного программного обеспечения
• Промежуточное программное обеспечение паука

Не поддерживается

Это исключение возникает, когда какая-либо функция или метод не поддерживаются. Это можно записать как —

exception (scrapy.exceptions.NotSupported)

Scrapy — Создать проект

Описание

Чтобы удалить данные с веб-страниц, сначала вам нужно создать проект Scrapy, в котором вы будете хранить код. Чтобы создать новый каталог, выполните следующую команду —

scrapy startproject first_scrapy

Приведенный выше код создаст каталог с именем first_scrapy и будет содержать следующую структуру:

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

Scrapy — определите предмет

Описание

Элементы — это контейнеры, используемые для сбора данных, которые удаляются с веб-сайтов. Вы должны начать свой паук с определения вашего предмета. Чтобы определить элементы, отредактируйте файл items.py, находящийся в каталоге first_scrapy (пользовательский каталог). Items.py выглядит следующим образом:

import scrapy  

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

Класс MyItem наследует от Item, содержащего несколько предопределенных объектов, которые Scrapy уже создал для нас. Например, если вы хотите извлечь имя, URL и описание из сайтов, вам необходимо определить поля для каждого из этих трех атрибутов.

Следовательно, давайте добавим те предметы, которые мы хотим собрать —

from scrapy.item import Item, Field  

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

Scrapy — Первый Паук

Описание

Spider — это класс, который определяет начальный URL для извлечения данных, как переходить по ссылкам на нумерацию страниц и как извлекать и анализировать поля, определенные в items.py . Scrapy предоставляет различные типы пауков, каждый из которых дает определенную цель.

Создайте файл под названием «first_spider.py» в каталоге first_scrapy / spiders, где мы можем указать Scrapy, как найти точные данные, которые мы ищем. Для этого вы должны определить некоторые атрибуты —

• name — определяет уникальное имя для паука

• allow_domains — содержит базовые URL для паука для сканирования.

• start-urls — список URL-адресов, с которых начинает сканировать паук.

• parse () — это метод, который извлекает и анализирует очищенные данные.

name — определяет уникальное имя для паука

allow_domains — содержит базовые URL для паука для сканирования.

start-urls — список URL-адресов, с которых начинает сканировать паук.

parse () — это метод, который извлекает и анализирует очищенные данные.

Следующий код демонстрирует, как выглядит код паука:

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)

Scrapy — Crawling

Описание

Чтобы запустить своего паука, выполните следующую команду в вашем каталоге first_scrapy —

scrapy crawl first

Где first имя паука, указанное при создании паука.

Как только паук ползет, вы можете увидеть следующий результат —

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)

Как видно из выходных данных, для каждого URL-адреса есть строка журнала, в которой (реферер: нет) указано, что URL-адреса являются начальными URL-адресами и не имеют ссылок. Затем вы должны увидеть два новых файла с именами Books.html и Resources.html, которые будут созданы в вашем каталоге first_scrapy .

Scrapy — Извлечение предметов

Описание

Для извлечения данных из веб-страниц Scrapy использует метод, называемый селекторами, основанный на выражениях XPath и CSS . Ниже приведены некоторые примеры выражений XPath:

• / html / head / title — это выберет элемент <title> внутри элемента <head> документа HTML.

• / html / head / title / text () — это выделит текст в том же элементе <title>.

• // td — это выберет все элементы из <td>.

• // div [@class = «slice»] — это выберет все элементы из div, которые содержат атрибут class = «slice»

/ html / head / title — это выберет элемент <title> внутри элемента <head> документа HTML.

/ html / head / title / text () — это выделит текст в том же элементе <title>.

// td — это выберет все элементы из <td>.

// div [@class = «slice»] — это выберет все элементы из div, которые содержат атрибут class = «slice»

Селекторы имеют четыре основных метода, как показано в следующей таблице:

экстракт ()

Возвращает строку в юникоде вместе с выбранными данными.

Re ()

Возвращает список строк Unicode, извлеченный, когда регулярное выражение было задано в качестве аргумента.

XPath ()

Он возвращает список селекторов, который представляет узлы, выбранные выражением xpath, заданным в качестве аргумента.

CSS ()

Он возвращает список селекторов, который представляет узлы, выбранные выражением CSS, заданным в качестве аргумента.

Использование селекторов в оболочке

Чтобы продемонстрировать селекторы с помощью встроенной оболочки Scrapy, в вашей системе должен быть установлен IPython . Здесь важно то, что URL должны быть включены в кавычки при запуске Scrapy; в противном случае URL с символами ‘&’ не будут работать. Вы можете запустить оболочку с помощью следующей команды в каталоге верхнего уровня проекта —

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

Оболочка будет выглядеть следующим образом —

[ ... 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]:

При загрузке оболочки вы можете получить доступ к телу или заголовку, используя соответственно response.body и response.header . Аналогично, вы можете выполнять запросы к ответу, используя response.selector.xpath () или response.selector.css () .

Например —

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

Извлечение данных

Чтобы извлечь данные с обычного HTML-сайта, мы должны проверить исходный код сайта, чтобы получить XPath. После проверки вы увидите, что данные будут в теге ul . Выберите элементы внутри тега li .

Следующие строки кода показывают извлечение различных типов данных —

Для выбора данных в теге li —

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

Для выбора описания —

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

Для выбора заголовков сайта —

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

Для выбора ссылок сайта —

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

Следующий код демонстрирует использование вышеуказанных экстракторов —

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

Scrapy — Использование предмета

Описание

Объекты предметов являются обычными диктатами Python. Мы можем использовать следующий синтаксис для доступа к атрибутам класса —

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

Добавьте приведенный выше код к следующему примеру —

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

Выход вышеупомянутого паука будет —

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

Scrapy — следующие ссылки

Описание

В этой главе мы изучим, как извлечь ссылки на интересующие нас страницы, следовать им и извлекать данные с этой страницы. Для этого нам нужно внести следующие изменения в наш предыдущий код, показанный ниже:

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

Приведенный выше код содержит следующие методы —

• parse () — он извлечет ссылки нашего интереса.

• response.urljoin — метод parse () будет использовать этот метод для создания нового URL-адреса и предоставления нового запроса, который позднее будет отправлен обратному вызову.

• parse_dir_contents () — это обратный вызов, который фактически очистит интересующие данные.

parse () — он извлечет ссылки нашего интереса.

response.urljoin — метод parse () будет использовать этот метод для создания нового URL-адреса и предоставления нового запроса, который позднее будет отправлен обратному вызову.

parse_dir_contents () — это обратный вызов, который фактически очистит интересующие данные.

Здесь Scrapy использует механизм обратного вызова для перехода по ссылкам. Используя этот механизм, можно спроектировать более крупный сканер, который может переходить по интересующим ссылкам для извлечения нужных данных с разных страниц. Обычным методом будет метод обратного вызова, который будет извлекать элементы, искать ссылки для перехода на следующую страницу и затем предоставлять запрос на тот же обратный вызов.

В следующем примере создается цикл, который будет следовать ссылкам на следующую страницу.

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)

Scrapy — Scraped Data

Описание

Лучший способ сохранить очищенные данные — использовать экспорт каналов, который обеспечивает правильное хранение данных с использованием нескольких форматов сериализации. JSON, JSON lines, CSV, XML — форматы, которые легко поддерживаются в форматах сериализации. Данные могут быть сохранены с помощью следующей команды —

scrapy crawl dmoz -o data.json

Эта команда создаст файл data.json, содержащий очищенные данные в JSON. Этот метод подходит для небольшого количества данных. Если необходимо обработать большой объем данных, мы можем использовать Item Pipeline. Как и файл data.json, зарезервированный файл создается при создании проекта в tutorial / pipelines.py .

Scrapy — Logging

Описание

Ведение журнала означает отслеживание событий, которое использует встроенную систему ведения журнала и определяет функции и классы для реализации приложений и библиотек. Logging — это готовый материал, который может работать с настройками Scrapy, перечисленными в настройках Logging.

Scrapy будет устанавливать некоторые настройки по умолчанию и обрабатывать эти настройки с помощью scrapy.utils.log.configure_logging () при запуске команд.

Уровни журнала

В Python существует пять разных уровней серьезности сообщения журнала. В следующем списке показаны стандартные сообщения журнала в порядке возрастания.

• logging.DEBUG — для отладки сообщений (самая низкая серьезность)

• logging.INFO — для информационных сообщений

• logging.WARNING — для предупреждающих сообщений

• logging.ERROR — для регулярных ошибок

• logging.CRITICAL — для критических ошибок (наибольшая серьезность)

logging.DEBUG — для отладки сообщений (самая низкая серьезность)

logging.INFO — для информационных сообщений

logging.WARNING — для предупреждающих сообщений

logging.ERROR — для регулярных ошибок

logging.CRITICAL — для критических ошибок (наибольшая серьезность)

Как регистрировать сообщения

Следующий код показывает запись сообщения с использованием уровня logging.info .

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

Приведенное выше сообщение регистрации может быть передано в качестве аргумента, используя logging.log, показанный ниже:

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

Теперь вы также можете использовать средства ведения журнала, чтобы заключить сообщение, используя средства ведения журнала ведения журнала, чтобы получить сообщение журнала, которое четко показано следующим образом:

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

Может быть несколько регистраторов, и к ним можно получить доступ, получив их имена с помощью функции logging.getLogger, показанной ниже.

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

Настроенный регистратор можно использовать для любого модуля, используя переменную __name__, которая содержит путь к модулю, показанный ниже:

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

Вход от Пауков

Каждый экземпляр паука имеет регистратор внутри и может использоваться следующим образом —

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)

В приведенном выше коде регистратор создается с использованием имени Паука, но вы можете использовать любой настраиваемый регистратор, предоставляемый Python, как показано в следующем коде:

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)

Конфигурация журнала

Регистраторы не могут отображать сообщения, отправленные ими самостоятельно. Поэтому им требуются «обработчики» для отображения этих сообщений, а обработчики будут перенаправлять эти сообщения в их соответствующие пункты назначения, такие как файлы, электронные письма и стандартный вывод.

В зависимости от следующих настроек, Scrapy настроит обработчик для регистратора.

Настройки ведения журнала

Для настройки ведения журнала используются следующие параметры:

• LOG_FILE и LOG_ENABLED определяют место назначения для сообщений журнала.

• Когда вы установите для LOG_ENCODING значение false, он не будет отображать сообщения вывода журнала.

• LOG_LEVEL определит порядок серьезности сообщения; те сообщения с меньшей серьезностью будут отфильтрованы.

• LOG_FORMAT и LOG_DATEFORMAT используются для указания макетов для всех сообщений.

• Когда вы установите для LOG_STDOUT значение true, все стандартные выходные данные и сообщения об ошибках вашего процесса будут перенаправлены в журнал.

LOG_FILE и LOG_ENABLED определяют место назначения для сообщений журнала.

Когда вы установите для LOG_ENCODING значение false, он не будет отображать сообщения вывода журнала.

LOG_LEVEL определит порядок серьезности сообщения; те сообщения с меньшей серьезностью будут отфильтрованы.

LOG_FORMAT и LOG_DATEFORMAT используются для указания макетов для всех сообщений.

Когда вы установите для LOG_STDOUT значение true, все стандартные выходные данные и сообщения об ошибках вашего процесса будут перенаправлены в журнал.

Параметры командной строки

Настройки Scrapy могут быть переопределены путем передачи аргументов командной строки, как показано в следующей таблице:

—logfile FILE

Переопределяет LOG_FILE

—loglevel / -L LEVEL

Переопределяет LOG_LEVEL

—nolog

Устанавливает LOG_ENABLED в False

модуль scrapy.utils.log

Эта функция может быть использована для инициализации параметров регистрации по умолчанию для Scrapy.

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

настройки (dict, None)

Он создает и настраивает обработчик для корневого регистратора. По умолчанию это None .

install_root_handler (bool)

Он указывает на установку обработчика корневых журналов. По умолчанию это True .

Вышеуказанная функция —

• Маршрутизация предупреждений и искаженных журналов через стандартную регистрацию Python.
• Назначает DEBUG для уровня Scrapy и уровень ERROR для витых регистраторов.
• Направляет стандартный вывод в журнал, если для параметра LOG_STDOUT установлено значение true.

Параметры по умолчанию могут быть переопределены с помощью аргумента настройки . Если настройки не указаны, используются значения по умолчанию. Обработчик может быть создан для корневого регистратора, когда для install_root_handler задано значение true. Если задано значение false, то не будет никакого выхода журнала. При использовании команд Scrapy файл configure_logging будет вызываться автоматически, и он может запускаться явно при выполнении пользовательских сценариев.

Чтобы настроить вывод журнала вручную, вы можете использовать logging.basicConfig (), показанный ниже:

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 
)

Scrapy — Stats Collection

Описание

Stats Collector — это средство, предоставляемое Scrapy для сбора статистики в виде ключей / значений, доступ к которой осуществляется с помощью API Crawler (Crawler обеспечивает доступ ко всем основным компонентам Scrapy). Сборщик статистики предоставляет одну таблицу статистики для каждого паука, в которой сборщик статистики открывается автоматически при открытии паука и закрывает сборщик статистики при закрытии паука.

Обычное использование сборщика статистики

Следующий код обращается к сборщику статистики, используя атрибут stats .

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

В следующей таблице показаны различные параметры, которые можно использовать со сборщиком статистики.

stats.set_value('hostname', socket.gethostname())

stats.inc_value('customized_count')

stats.max_value('max_items_scraped', value)

stats.min_value('min_free_memory_percent', value)

stats.get_value('customized_count')

stats.get_stats() {'custom_count': 1, 'start_time': datetime.datetime(2009, 7, 14, 21, 47, 28, 977139)} 

Доступные Статистика Коллекционеры

Scrapy предоставляет различные типы сборщика статистики, доступ к которому можно получить с помощью настройки STATS_CLASS .

MemoryStatsCollector

Это сборщик статистики по умолчанию, который поддерживает статистику каждого паука, который использовался для очистки, и данные будут храниться в памяти.

class scrapy.statscollectors.MemoryStatsCollector

DummyStatsCollector

Этот сборщик статистики очень эффективен и ничего не делает. Это может быть установлено с помощью параметра STATS_CLASS и может быть использовано для отключения сбора статистики для повышения производительности.

class scrapy.statscollectors.DummyStatsCollector

Scrapy — отправка электронной почты

Описание

Scrapy может отправлять электронные письма, используя свое собственное средство, называемое Twisted неблокирующее IO, которое защищает от неблокирующего IO сканера. Вы можете настроить несколько параметров отправки электронных писем и предоставить простой API для отправки вложений.

Существует два способа создания MailSender, как показано в следующей таблице:

Следующая строка отправляет электронное письмо без вложений —

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

Ссылка на класс MailSender

Класс MailSender использует неблокируемый ввод- вывод Twisted для отправки электронной почты из Scrapy.

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

В следующей таблице приведены параметры, используемые в классе MailSender.

smtphost (str)

Хост SMTP используется для отправки электронных писем. Если нет, то будет использоваться настройка MAIL_HOST .

mailfrom (str)

Адрес получателя используется для отправки электронных писем. Если нет, то будет использоваться настройка MAIL_FROM .

smtpuser

Указывает пользователя SMTP. Если он не используется, будет использоваться настройка MAIL_USER , и SMTP-проверка не будет выполняться, если она не указана.

smtppass (str)

Он указывает SMTP проход для проверки.

smtpport (int)

Указывает порт SMTP для подключения.

smtptls (логическое)

Он реализует использование SMTP STARTTLS.

smtpssl (логическое)

Он администрирует, используя безопасное соединение SSL.

Следующие два метода есть в ссылке на класс MailSender, как указано. Первый метод,

classmethod from_settings(settings)

Включает с помощью объекта настроек Scrapy. Он содержит следующий параметр —

параметры (объект scrapy.settings.Settings) — Он рассматривается как получатель электронной почты.

Другой метод,

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

Следующая таблица содержит параметры вышеуказанного метода —

к списку)

Это относится к получателю электронной почты.

предмет (ул)

Указывает тему письма.

Копия (список)

Это относится к списку получателей.

тело (ул)

Это относится к данным тела письма.

прикрепляет (повторяется)

Это относится к вложению электронной почты, mimetype вложения и имени вложения.

Mimetype (ул)

Он представляет MIME-тип электронной почты.

charset (str)

Он определяет кодировку символов, используемую для содержимого электронной почты.

Настройки почты

Следующие настройки гарантируют, что без написания какого-либо кода мы сможем настроить электронную почту, используя класс MailSender в проекте.

mail_from

Это относится к электронной почте отправителя для отправки электронных писем.

MAIL_HOST

Это относится к узлу SMTP, используемому для отправки электронных писем.

MAIL_PORT

Указывает порт SMTP, который будет использоваться для отправки электронных писем.

MAIL_USER

Это относится к проверке SMTP. Проверка не будет выполнена, если этот параметр отключен.

MAIL_PASS

Он предоставляет пароль, используемый для проверки SMTP.

MAIL_TLS

Он предоставляет метод обновления небезопасного соединения до безопасного соединения с использованием SSL / TLS.

MAIL_SSL

Он реализует соединение, используя зашифрованное соединение SSL.

Scrapy — консоль Telnet

Описание

Консоль Telnet — это оболочка Python, которая запускается внутри процесса Scrapy и используется для проверки и управления процессом Scrapy.

Доступ к консоли Telnet

Доступ к консоли telnet можно получить с помощью следующей команды:

telnet localhost 6023

В основном, консоль telnet указана в порте TCP, который описан в настройках TELNETCONSOLE_PORT .

переменные

Некоторые из переменных по умолчанию, приведенных в следующей таблице, используются в качестве ярлыков —

гусеничный трактор

Это относится к объекту Scrapy Crawler (scrapy.crawler.Crawler).

двигатель

Это относится к атрибуту Crawler.engine.

паук

Это относится к пауку, который активен.

слот

Это относится к слоту двигателя.

расширения

Это относится к атрибуту Extension Manager (Crawler.extensions).

статистика

Это относится к атрибуту Stats Collector (Crawler.stats).

установка

Это относится к атрибуту объекта настроек Scrapy (Crawler.settings).

стандартное восточное время

Это относится к распечатке отчета о состоянии двигателя.

привилегированные

Это относится к памяти для отладки.

п

Это относится к ярлыку функции pprint.pprint .

HPY

Это относится к отладке памяти.

Примеры

Ниже приведены некоторые примеры, иллюстрируемые с помощью консоли Telnet.

Приостановить, возобновить и остановить Scrapy Engine

Чтобы приостановить Scrapy Engine, используйте следующую команду —

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

Чтобы возобновить Scrapy Engine, используйте следующую команду —

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

Чтобы остановить двигатель Scrapy, используйте следующую команду —

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

Просмотр состояния двигателя

Консоль Telnet использует метод est () для проверки состояния движка Scrapy, как показано в следующем коде —

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

Сигналы консоли Telnet

Вы можете использовать сигналы консоли telnet для добавления, обновления или удаления переменных в локальном пространстве имен telnet. Чтобы выполнить это действие, вам нужно добавить dict telnet_vars в ваш обработчик.

scrapy.extensions.telnet.update_telnet_vars(telnet_vars)

Параметры —

telnet_vars (dict)

Где dict — это словарь, содержащий переменные telnet.

Настройки Telnet

В следующей таблице приведены параметры, управляющие поведением консоли Telnet.

TELNETCONSOLE_PORT

Это относится к диапазону портов для консоли telnet. Если для него установлено значение none, порт будет назначен динамически.

TELNETCONSOLE_HOST

Это относится к интерфейсу, который должна прослушивать консоль telnet.

Scrapy — веб-сервисы

Описание

Работающий веб-сканер Scrapy можно контролировать через JSON-RPC . Это включено настройкой JSONRPC_ENABLED. Этот сервис предоставляет доступ к основному объекту искателя по протоколу JSON-RPC 2.0 . Конечная точка для доступа к объекту искателя:

http://localhost:6080/crawler

В следующей таблице приведены некоторые параметры, которые показывают поведение веб-службы.

JSONRPC_ENABLED

Это относится к логическому значению, которое решает, будет ли включен веб-сервис вместе с его расширением или нет.

JSONRPC_LOGFILE

Это относится к файлу, который используется для регистрации HTTP-запросов к веб-сервису. Если он не установлен, будет использоваться стандартный журнал Scrapy.

JSONRPC_PORT

Это относится к диапазону портов для веб-службы. Если для него установлено значение none, порт будет назначен динамически.

JSONRPC_HOST

Это относится к интерфейсу, который должен прослушивать веб-сервис.