En este tutorial, estara enfocado en uno de los mejores frameworks para el rastreo web llamado Scrapy. Aprenderás los conceptos básicos de Scrapy y cómo crear tu primer rastreador web o araña. Además, el tutorial ofrece una demostración de extracción y almacenamiento de los datos rastreados.
Scrapy, es un framework web escrito en Python que se utiliza para rastrear un sitio web y extraer datos de manera eficiente.
Puedes utilizar los datos extraídos para un procesamiento mas profundo, extracción de datos y su almacenamiento en hojas de cálculo o cualquier otra necesidad comercial.
Table of Contents
Arquitectura Scrapy
La arquitectura de Scrapy contiene cinco componentes principales:
- El motor de Scrapy
- Planificador
- Descargador
- Arañas
- Tuberías de elementos
El Motor de scrapy
El motor de Scrapy es su componente principal, cuyo objetivo es controlar el flujo de datos entre todos los demás componentes. El motor genera peticiones y gestiona eventos contra una acción.
Planificador
El planificador recibe las solicitudes enviadas por el motor y las pone en cola.
Descargador
El objetivo del descargador es buscar todas las páginas web y enviarlas al motor. El motor luego envía las páginas web a las arañas.
Arañas
Las arañas es el código que escribes para analizar sitios web y extraer datos.
Tubería de elementos
La tubería de elementos procesa los elementos lado a lado después de que las arañas los extraen.
Instalación de Scrapy
Puedes instalar Scrapy junto con sus dependencias usando el Administrador de paquetes de Python (pip).
Ejecute el siguiente comando para instalar Scrapy en Windows:
pip install scrapy
Sin embargo, la guía de instalación oficial
recomienda instalar Scrapy en un entorno virtual porque las dependencias de Scrapy pueden entrar en conflicto con otros paquetes del sistema Python que afectarán a otros scripts y herramientas.
Por lo tanto, crearemos un entorno virtual para proporcionar un entorno de desarrollo encapsulado.
Primero instalaremos un entorno virtual y luego continuaremos con la instalación de Scrapy.
- Ejecuta el siguiente comando en la carpeta de scripts de Python para instalar el entorno virtual:
pip install virtualenv
- Ahora instala virtualenvwrapper-win que nos permite crear entornos virtuales aislados de Python.
pip install virtualenvwrapper-win
- Establece la ruta dentro de la carpeta de scripts, para que pueda usar globalmente los comandos de Python:
set PATH=%PATH%;C:\Users\hp\appdata\local\programs\python\python37-32\scripts
- Crear un entorno virtual:
mkvirtualenv ScrapyTut
ScrapyTut sera el nombre de nuestro entorno:
- Crea tu carpeta de proyectos y conéctala con el entorno virtual:
- Vincular el entorno virtual con el directorio de trabajo actual:
setprojectdir .
- Si desea desactivar el modo de entorno virtual, simplemente utiliza deactivate como se indica a continuación:
deactivate
- Si desea volver a trabajar en el proyecto, usa el comando workon junto con el nombre del proyecto:
workon ScrapyTut
Ahora que tenemos nuestro entorno virtual, podemos continuar con la instalación de Scrapy.
- Para la instalación en Windows, debes descargar OpenSSL e instalarlo. Elige la versión regular que coincida con tu versión de Python. Además, instala los redistribuibles de Visual C ++ 2008, de lo contrario, ocurrira un error al instalar las dependencias.
- Agrega C: \ OpenSSL-Win32 \ bin al PATH del sistema.
- Para instalar Scrapy, hay que instalar los paquetes de los cuales depende. Estos paquetes incluyen pywin32, twisted, zope.interface, lxml y pyOpenSSL.
- En el directorio ScrapyTut, ejecuta el siguiente comando pip para instalar Scrapy:
pip install scrapy
Ten en cuenta que al instalar Twisted, puedes ocurrir un error como el siguiente:
Microsoft visual c++ 14.0 is required
Para corregir este error, deberás instalar lo siguiente desde las herramientas de compilación de Microsoft:
Después de esta instalación, si ocurre otro error como el siguiente:
error: command 'C:\\Program Files (x86)\\Microsoft Visual Studio 14.0\\VC\\BIN\\link.exe' failed with exit status 1158
Simplemente descargue el wheel para Twisted que coincida con tu versión de Python. Pega este wheel en tu directorio de trabajo actual:
Ahora ejecuta el siguiente comando:
pip install Twisted-18.9.0-cp37-cp37m-win32.whl
Todo está listo para crear nuestro primer rastreador, así que hagámoslo.
Crear un proyecto Scrapy
Antes de escribir un código Scrapy, tendrás que crear un proyecto Scrapy usando el comando startproject así:
scrapy startproject myFirstScrapy
Esto generará el directorio del proyecto con los siguientes contenidos:
La carpeta de arañas contiene las arañas.
Aquí el archivo scrapy.cfg es el archivo de configuración. Dentro de la carpeta myFirstScrapy tendremos los siguientes archivos:
Crear una araña
Después de crear el proyecto, navega hasta el directorio del proyecto y crea una araña junto con la URL del sitio web que desea rastrear ejecutando el siguiente comando:
scrapy genspider jobs www.python.org
El resultado será como lo siguiente:
Nuestra carpeta de araña de “trabajos” será así:
En la carpeta de arañas, podemos tener múltiples arañas dentro del mismo proyecto.
Ahora vamos a ver el contenido de nuestra araña recién creada. Abre el archivo jobs.py que contiene el siguiente código:
1 2 3 4 5 6 7 8 9 10 11 12 13 | import scrapy class JobsSpider(scrapy.Spider): name = 'jobs' allowed_domains = ['www.python.org'] start_urls = ['http://www.python.org/'] def parse(self, response): pass |
Aquí el AccessoriesSpider es la subclase de scrapy.Spider. La variable “name” es el nombre de nuestra araña que se asignó en el proceso de creación de la araña. El nombre se utiliza para ejecutar la araña. Los ‘allowed_domains’ es el dominio accesible por esta araña.
Start_urls es la URL desde donde se iniciará el rastreo web o puedes decir que es la URL inicial donde empieza el proceso. Luego tenemos el método de análisis que analiza el contenido de la página.
Para rastrear la página de accesorios de nuestra URL, necesitamos agregar un enlace más en la propiedad start_urls de la siguiente manera:
1 2 3 | start_urls = ['http://www.python.org/', 'https://www.python.org/jobs/'] |
Como queremos rastrear más de una página, se recomienda heredar la araña de la clase CrawlSpider en lugar de la clase scrapy.spider. Para ello, deberás importar el siguiente módulo:
from scrapy.spiders import CrawlSpider
Nuestra clase se verá como la siguiente:
class JobsSpider(CrawlSpider): …
El siguiente paso es inicializar la variable rules. La variable rules define las reglas de navegación que se seguirán al rastrear el sitio. Para usar un objeto rules, importa la siguiente clase:
from scrapy.spiders import Rule
La variable rules contiene además objetos de regla como:
- link_extractor que es un objeto de la clase Link Extractor. El objeto link_extractor especifica cómo extraer enlaces de la URL rastreada. Para esto, tendrás que importar la clase Link Extractor de la siguiente manera:
from scrapy.linkextractors import LinkExtractor
La variable rules se verá así:
1 2 3 4 5 6 7 | rules = ( Rule(LinkExtractor(allow=(), restrict_css=('.list-recent-jobs',)), callback="parse_item", follow=True),) |
- callback es una cadena que se llama cuando se extrae un enlace. Especifica los métodos que se utilizarán al acceder a los elementos de la página.
- follow es un Boolean que especifica si el enlace extraído debe seguirse o no después de esta regla.
allow se utiliza para especificar el enlace que se va a extraer. Pero en nuestro ejemplo, hemos restringido por clase CSS. Entonces solo las páginas con la clase especificada deben ser extraídas.
El parámetro callback especifica el método al que se llamará al analizar la página. El .list-recent-jobs es la clase para todos los trabajos enumerados en la página. Puedes verificar la clase de un elemento haciendo clic derecho en ese elemento y seleccionando inspeccionar en la página web.
En el ejemplo, llamamos el método parse_item de spider en lugar de parse.
El contenido del método parse_item es el siguiente:
1 2 3 | def parse_item(self, response): print('Extracting…' + response.url) |
Esto imprimirá Extraer … junto con la URL que se está extrayendo actualmente. Por ejemplo, se extrae un enlace https://www.python.org/jobs/3698/ Por lo tanto, en la pantalla de salida, se imprimirá la extracción, Extracting…https://www.python.org/jobs/3698/ .
Para ejecutar la araña, navega a la carpeta de tu proyecto y escribe el siguiente comando:
scrapy crawl jobs
La salida será la siguiente:
En este ejemplo, establecemos follow = true, lo que significa que el rastrearás las páginas hasta que la regla se vuelva false. Esto sucederá cuando la lista de trabajos termine.
Si desea obtener solo la sentencia print, puede usar el siguiente comando:
scrapy crawl –nolog jobs
La salida será como la siguiente:
¡Felicidades! Has construido tu primer rastreador web.
Fundamentos de Scrapy
Ahora podemos rastrear páginas web. Vamos a jugar un poco con el contenido rastreado.
Selectores
Puedes usar los selectores para seleccionar algunas partes de los datos del HTML rastreado. Los selectores seleccionan datos de HTML utilizando XPath y CSS a través de response.xpath () y response.css () respectivamente. Al igual que en el ejemplo anterior, usamos la clase css para seleccionar los datos.
Considera el siguiente ejemplo donde declaramos una cadena con etiquetas HTML. Utilizando la clase selector, extrajimos los datos en la etiqueta h1 usando el Selector.xpath:
1 2 3 4 5 6 7 | >>> from scrapy.selector import Selector >>> body = '<html><body><h1>Heading 1</h1></body></html>' >>> Selector(text = body).xpath('//h1/text()').get() 'Heading 1' |
Items
Scrapy usa diccionarios de Python para devolver los datos extraídos.
Para extraer datos, Scrapy proporciona la clase de items que proporciona objetos items. Podemos usar estos objetos tipo Items como contenedores para los datos rastreados.
Los elementos proporcionan una sintaxis simple para declarar campos. La sintaxis es la la siguiente:
1 2 3 4 5 | >>> import scrapy >>> class Job(scrapy.Item): company = scrapy.Field() |
El objeto Field especifica los Metadatos para cada campo.
Puedes notar que cuando se crea el proyecto Scrapy, también se crea un archivo items.py en nuestro directorio de proyectos. Podemos modificar este archivo para agregar nuestros items de la siguiente forma:
1 2 3 4 5 6 7 | import scrapy class MyfirstscrapyItem(scrapy.Item): # define the fields for your item here like: location = scrapy.Field() |
Aquí hemos añadido un Item. Puedes llamar a esta clase desde tu archivo spider para inicializar los elementos de la siguiente manera:
1 2 3 4 5 6 7 | def parse_item(self, response): item_links = response.css('.text > .listing-company > .listing-location > a::text'').extract() for x in item_links: yield scrapy.Request(x, callback=self.MyfirstscrapyItem) |
En el código anterior, hemos utilizado el método de respuesta css para extraer los datos.
En nuestra página web, tenemos un div con texto de clase, dentro de este div, tenemos un encabezado con la clase listing-company, dentro de este encabezado, tenemos una etiqueta span con la clase listing-location y, finalmente, tenemos una etiqueta a que algo de texto. Este texto se extrae utilizando el método extract ().
Finalmente, recorreremos todos los items extraídos y llamaremos a la clase items.
En lugar de hacer todo esto en el rastreador, también podemos probar nuestro rastreador usando solo una sentencia mientras trabajamos en el shell de Scrapy. Haremos una demostración del shell de Scrapy shell.
Item Loaders
Los datos o elementos desechados por el objeto Item se cargan o rellenan utilizando el cargador de elementos (Item Loader). Puedes utilizar el item loader para ampliar las reglas del análisis.
Después de extraer elementos, podemos popular los elementos en el item loader con la ayuda de los selectores.
La sintaxis para el item loader es la siguiente:
1 2 3 4 5 6 7 8 9 10 11 | from scrapy.loader import ItemLoader from jobs.items import Job def parse(self, response): l = ItemLoader(item=Job(), response=response) l.add_css(‘name’, ‘//li[@class = ‘listing-company’]’) l.load_item() |
Scrapy Shell
Scrapy shell es una herramienta de línea de comandos que permite a los desarrolladores probar el analizador sin necesidad de utilizar el rastreador. Con Scrapy shell, puedes depurar tu código fácilmente. El propósito principal de Scrapy shell es probar el código de extracción de datos.
Usamos el shell de Scrapy para probar los datos extraídos por CSS y XPath al realizar operaciones de rastreo en un sitio web.
Puedes activar el shell de Scrapy desde el proyecto actual usando el siguiente comando:
scrapy shell
Si deseas analizar una página web, usarás el comando junto con el enlace de la página:
scrapy shell https://www.python.org/jobs/3659/
Para extraer la ubicación del trabajo, simplemente ejecuta el siguiente comando:
response.css('.text > .listing-company > .listing-location > a::text').extract()
El resultado será:
Del mismo modo, puede extraer cualquier dato del sitio web.
Para obtener la URL del trabajo actual, puedes utilizar el siguiente comando:
response.url
Así es como se extraen todos los datos en Scrapy. En la siguiente sección, guardaremos estos datos en un archivo CSV.
Almacenando los datos
Vamos a usar el response.css en nuestro código real. Almacenaremos el valor devuelto por esta sentencia en una variable y después de eso, lo guardaremos en un archivo CSV. Utiliza el siguiente código:
1 2 3 4 5 6 7 8 9 10 11 | def parse_detail_page(self, response): location = response.css('.text > .listing-company > .listing-location > a::text').extract() item = MyfirstscrapyItem() item['location'] = location item['url'] = response.url yield item |
Aquí almacenaremos el resultado de response.css en una variable llamada location. Luego asignamos esta variable al objeto de ubicación del elemento en la clase MyfirstscrapyItem().
Ejecuta el siguiente comando para que tu rastreador almacene el resultado en un archivo CSV:
scrapy crawl jobs -o ScrappedData.csv
Este generará un archivo CSV en el directorio del proyecto:
Scrapy es un framework muy fácil para rastrear páginas web. Eso fue solo el comienzo. Si te gustó el tutorial y tienes hambre de más, escribelo en nuestros comentarios no son suficientes. ¿Cuál es el próximo tema de Scrapy sobre el que te gustaría leer?
Felicitaciones por la forma puntual de sus explicaciones y ejemplos.
Muchos Éxitos
¡Muchas gracias!
Una pregunta. ¿Cómo y de dónde me bajo las herramientas de compilación de Microsoft?.
Puedes descargar MS Build Tools desde aquí:
https://aka.ms/vs/16/release/vs_buildtools.exe
No se entiende bien. las variables start_urls, rules y el método parse_item son de la clase ‘JobsSpider’?. podrías mostrar como queda el código porque es bastante confuso cuando pasas de ejemplo a código y cuando escribis en otro archivo
Hola,
solo siga el ejemplo y si enfrenta algún error, puede informarnos al respecto y le ayudaremos lo más que podamos.
Saludos,
Hola estaba siguiendo tu tutorial pero me he perdido en la parte que agregar más abajo , podrias poner el codigo del archivo final de jobs.py para que podamos ver la estructura y si lo hicimos bien. MUCHAS GRACIAS!!!
“Como queremos rastrear más de una página, se recomienda heredar la araña de la clase CrawlSpider en lugar de la clase scrapy.spider. Para ello, deberás importar el siguiente módulo:
from scrapy.spiders import CrawlSpider
Nuestra clase se verá como la siguiente:
class JobsSpider(CrawlSpider): …
“
Muchas gracias por la adición.
En realidad, hay muchas arañas disponibles, como scrapy.spider, CrawlSpider, XMLFeedSpider, CSVFeedSpider y SitemapSpider.
Elegí scrapy.spider porque es el más simple de usar para principiantes.