¿Cómo utilizar los elementos de Scrapy?

En este artículo, rasparemos los datos de Cotizaciones usando elementos raspados, de la página web https://quotes.toscrape.com/tag/reading/ . El principal objetivo del scraping, es preparar datos estructurados, a partir de recursos no estructurados. Los elementos Scrapy son envoltorios, las estructuras de datos del diccionario. El código se puede escribir, de modo que los datos extraídos se devuelvan, como objetos Item, en el formato de pares «clave-valor». El uso de Scrapy Items es beneficioso cuando:

• A medida que aumenta el volumen de datos raspados, se vuelven irregulares de manejar.
• A medida que sus datos se vuelven complejos, son vulnerables a los errores tipográficos y, en ocasiones, pueden devolver datos defectuosos.
• El formateo de los datos extraídos es más fácil, ya que los objetos de elementos se pueden pasar a las canalizaciones de elementos.
• Limpiar los datos es fácil, si raspamos los datos, como elementos.
• La validación de datos, el manejo de datos faltantes, es más fácil con Scrapy Items.

A través de la biblioteca de adaptadores de elementos, Scrapy admite varios tipos de elementos. Uno puede elegir el tipo de elemento que desee. Los siguientes son los tipos de elementos admitidos:

• Diccionarios: los elementos se pueden escribir en forma de objetos de diccionario. Son convenientes de usar.
• Objetos de elementos: proporcionan un diccionario como API, en el que debemos declarar, campos para el elemento, necesarios. Consiste en un par clave-valor, de objetos de campo utilizados, mientras se declara la clase de elemento. En este tutorial, estamos usando objetos Item.
• Objetos de clase de datos: se utilizan, cuando necesita almacenar, los valores raspados, en archivos JSON o CSV. Aquí necesitamos definir, el tipo de datos de cada campo, necesario.
• attr.s: attr.s permite definir clases de elementos, con nombres de campo, para que los datos raspados se puedan importar a diferentes formatos de archivo. Funcionan de manera similar a los objetos Dataclass, solo que es necesario instalar el paquete attr.

Instalación de la biblioteca Scrapy

La biblioteca Scrapy requiere una versión de Python, de 3.6 y superior. Instale la biblioteca Scrapy, ejecutando el siguiente comando, en la terminal:

pip instalar Scrapy

Este comando instalará la biblioteca Scrapy, en el entorno del proyecto. Ahora, podemos crear un proyecto Scrapy, para escribir el código Spider.

Crear un Proyecto Scrapy

Scrapy tiene una herramienta de línea de comandos eficiente, también llamada ‘herramienta Scrapy’. Los comandos aceptan un conjunto diferente de argumentos y opciones según su propósito. Para escribir el código Spider, comenzamos creando un proyecto Scrapy, ejecutando el siguiente comando en la terminal:

scrapy startproject <nombre_del_proyecto>

Producción:

Comando Scrapy ‘startproject’ para crear un proyecto Spider

Esto debería crear una carpeta, en su directorio actual. Contiene un ‘scrapy.cfg’, que es un archivo de configuración del proyecto. La estructura de carpetas es como se muestra a continuación:

La estructura de carpetas de ‘gfg_spiderreadingitems’

El scrapy.cfg, es un archivo de configuración del proyecto. La carpeta que contiene este archivo es el directorio raíz. La estructura de carpetas, de carpeta, creada es la siguiente:

Archivo ‘items.py’ dentro de la carpeta ‘gfg_spiderreadingitems’

La carpeta contiene items.py, middlerwares.py y otros archivos de configuración, junto con la carpeta ‘spiders’. El código de rastreo se escribirá en un archivo spider python. Modificaremos el archivo ‘items.py’, por mencionar, nuestros elementos de datos, para ser extraídos. Mantenga el contenido de ‘items.py’, tal como está actualmente.

Código araña para extraer datos

El código para web scraping está escrito en el archivo de código spider. Para crear el archivo spider, haremos uso del comando ‘genspider’. Tenga en cuenta que este comando se ejecuta, en el mismo nivel, donde está presente el archivo scrapy.cfg. 

Estamos raspando, leyendo citas presentes, en https://quotes.toscrape.com/tag/reading/ página web. Por lo tanto, ejecutaremos el comando como –

scrapy genspider spider_name url_to_be_scraped

Use el comando ‘genspider’ para crear un archivo Spider

El comando anterior creará un archivo araña, “gfg_spiitemsread.py” en la carpeta ‘arañas’. El nombre de la araña también será ‘gfg_spiitemsread’. El código por defecto, para el mismo, es el siguiente:

# Import the required libraries
import scrapy
 
# Spider Class Created
 
 
class GfgSpiitemsreadSpider(scrapy.Spider):
    # Name of the spider
    name = 'gfg_spiitemsread'
    # The domain to be scraped
    allowed_domains = ['quotes.toscrape.com/tag/reading/']
    # The URLs from domain to scrape
    start_urls = ['http://quotes.toscrape.com/tag/reading//']
 
    # Spider default callback function
    def parse(self, response):
        pass

Extraeremos el título, el autor y las etiquetas de las citas de la página web https://quotes.toscrape.com/tag/reading/ . Scrapy nos proporciona, con Selectores, para “seleccionar” partes de la página web, deseadas. Los selectores son expresiones CSS o XPath, escritas para extraer datos de los documentos HTML. En este tutorial, haremos uso de expresiones XPath para seleccionar los detalles que necesitamos. Entendamos, los pasos para escribir la sintaxis del selector, en el código spider.  

• El método de devolución de llamada predeterminado, presente en la clase spider, responsable de procesar la respuesta recibida, es el método parse(). Escribiremos, selectores con expresiones XPath, responsables de la extracción de datos, aquí.
• Seleccione el elemento a extraer, en la página web, diga clic derecho y elija la opción Inspeccionar. Esto nos permitirá ver sus atributos CSS.
• Cuando hacemos clic con el botón derecho en la primera Cotización y elegimos Inspeccionar, podemos ver que tiene el atributo de ‘clase’ de CSS «cita». Del mismo modo, todas las citas en la página web tienen el atributo ‘clase’ de CSS como «cita». Puede ser como se ve a continuación:

Haga clic derecho en la primera cita y verifique su atributo de «clase» CSS

Basado en esto, la expresión XPath, por lo mismo, se puede escribir como – 

• comillas = respuesta.xpath(‘//*[@class=”quote”]’). Esta sintaxis recuperará todos los elementos que tengan «comillas» como el atributo ‘clase’ de CSS.
• Obtendremos el título de la cita, el autor y las etiquetas de todas las citas. Por lo tanto, escribiremos expresiones XPath para extraerlas, en un bucle. Para Quote Title, el atributo ‘clase’ de CSS es «texto». Por lo tanto, la expresión XPath, por lo mismo, sería – quote.xpath(‘.//*[@class=”text”]/text()’).extract_first(). El método text() extraerá el texto del título de la cita. El método extract_first() dará el primer valor coincidente, con el atributo CSS «texto». El operador punto ‘.’ en el inicio, indica extraer datos, de una comilla simple.
• De manera similar, los atributos CSS, «clase» y «elemento prop», para el elemento autor, es «autor». Podemos usar, cualquiera de estos, en la expresión XPath. La sintaxis sería: quote.xpath(‘.//*[@itemprop=”author”]/text()’).extract(). Esto extraerá el nombre del autor, donde el atributo ‘itemprop’ de CSS es ‘autor’.
• Los atributos CSS, «clase» y «itemprop», para el elemento de etiquetas, son «palabras clave». Podemos usar, cualquiera de estos, en la expresión XPath. Dado que hay muchas etiquetas, para cualquier cita, recorrerlas será complejo. Por lo tanto, extraeremos el atributo CSS «contenido» de cada cita. La expresión XPath para el mismo es – quote.xpath(‘.//*[@itemprop=”keywords”]/@content’).extract(). Esto extraerá, todos los valores de las etiquetas, del atributo «contenido», para las comillas.
• Usamos la sintaxis de ‘rendimiento’ para obtener los datos. Podemos recopilar y transferir datos a CSV, JSON y otros formatos de archivo, con la sintaxis ‘rendimiento’.
• Si observamos el código hasta aquí, rastreará y extraerá datos para la página web.

El código es el siguiente:

# Import the required library
import scrapy
 
# The Spider class
class GfgSpiitemsreadSpider(scrapy.Spider):
    # Name of the spider
    name = 'gfg_spiitemsread'
     
    # The domain allowed to scrape
    allowed_domains = ['quotes.toscrape.com/tag/reading']
     
    # The URL to be scraped
    start_urls = ['http://quotes.toscrape.com/tag/reading/']
     
    # Default callback function
    def parse(self, response):
         
        # Fetch all quotes tags
        quotes = response.xpath('//*[@class="quote"]')
         
        # Loop through the Quote selector elements
        # to get details of each
        for quote in quotes:
             
            # XPath expression to fetch text of the Quote title
            title = quote.xpath('.//*[@class="text"]/text()').extract_first()
             
            # XPath expression to fetch author of the Quote
            authors = quote.xpath('.//*[@itemprop="author"]/text()').extract()
             
            # XPath expression to fetch Tags of the Quote
            tags = quote.xpath('.//*[@itemprop="keywords"]/@content').extract()
             
            # Yield all elements
            yield {"Quote Text ": title, "Authors ": authors, "Tags ": tags}

El comando de rastreo se utiliza para ejecutar la araña. Mencione el nombre de la araña, en el comando de rastreo. Si ejecutamos el código anterior, usando el comando de rastreo, la salida en la terminal sería:

nombre de archivo de rastreo scrapy

Producción:

Cotizaciones raspadas como se muestra en la declaración de ‘rendimiento’

Aquí, la declaración de rendimiento, devuelve los datos, en objetos de diccionario de Python. 

Comprender el diccionario de Python y el elemento Scrapy

Los datos proporcionados anteriormente son objetos de diccionario de Python. Las ventajas de usarlos son:

• Son convenientes y fáciles de manejar estructuras de pares clave-valor, cuando el tamaño de los datos es menor.
• Úselos cuando no se requiera más procesamiento o formateo en datos raspados.
• Use un diccionario, cuando los datos que desea raspar, son completos y simples.

Para usar objetos Item, haremos cambios en los siguientes archivos:

• El archivo items.py presente
• Clase de araña actual generada, archivo gfg_spiitemsread.py.

Utilice elementos raspados para recopilar datos

Ahora, aprenderemos, el proceso de escribir nuestro Scrapy Item, para Cotizaciones. Para hacerlo, seguiremos los pasos que se mencionan a continuación:

• Abra el archivo items.py. Está presente, al mismo nivel, que la carpeta ‘spiders’. Mencione los campos, necesitamos extraer, en el archivo, como se muestra a continuación:

# Define here the models for your scraped
# items
# Import the required library
import scrapy
 
# Define the fields for Scrapy item here
# in class
class GfgSpiderreadingitemsItem(scrapy.Item):
     
    # Item key for Title of Quote
    quotetitle = scrapy.Field()
     
    # Item key for Author of Quote
    author = scrapy.Field()
     
    # Item key for Tags of Quote
    tags = scrapy.Field()

Como se ve, en el archivo anterior, hemos definido un elemento scrapy llamado ‘GfgSpiderreadingitemsItem’. Esta clase, es nuestro modelo, para todos los elementos, rasparemos. Persistirá, tres campos, a saber, título de la cita, nombre del autor y etiquetas. Ahora podemos agregar, solo los campos que mencionamos en la clase.

La clase Field() es un alias de la clase de diccionario integrada. Permite una manera de definir todos los metadatos de campo, en una ubicación. No proporciona ningún atributo adicional.

Ahora modifique el archivo spider, para almacenar los valores, en el objeto de la clase del archivo del elemento, en lugar de generarlos directamente. Tenga en cuenta que debe importar el módulo de clase de artículo, como se ve en el código a continuación.

# Import the required library
import scrapy
 
# Import the Item class with fields
# mentioned in the items.py file
from ..items import GfgSpiderreadingitemsItem
 
 
class GfgSpiitemsreadSpider(scrapy.Spider):
    name = 'gfg_spiitemsread'
    allowed_domains = ['quotes.toscrape.com/tag/reading']
    start_urls = ['http://quotes.toscrape.com/tag/reading/']
 
    def parse(self, response):
       
        # Write XPath expression to loop through
        # all quotes
        quotes = response.xpath('//*[@class="quote"]')
         
        # Loop through all quotes
        for quote in quotes:
             
            # Create an object of Item class
            item = GfgSpiderreadingitemsItem()
             
            # XPath expression to fetch text of the
            # Quote title Store the title in the class
            # attribute in key-value pair
            item['quotetitle'] = quote.xpath(
                './/*[@class="text"]/text()').extract_first()
             
            # XPath expression to fetch author of the Quote
            # Store the author in the class attribute in
            # key-value pair
            item['author'] = quote.xpath(
                './/*[@itemprop="author"]/text()').extract()
             
            # XPath expression to fetch tags of the Quote title
            # Store the tags in the class attribute in key-value
            # pair
            item['tags'] = quote.xpath(
                './/*[@itemprop="keywords"]/@content').extract()
             
            # Yield the item object
            yield item

Como se vio anteriormente, las claves mencionadas, en la clase Item, ahora se pueden usar para recopilar los datos extraídos mediante expresiones XPath. Asegúrese de mencionar los nombres exactos de las claves en ambos lugares. Por ejemplo, use «item[‘author’]», cuando ‘author’ es la clave definida, en el archivo items.py.

Los artículos, entregados en la terminal, son los que se muestran a continuación:

Datos extraídos de la página web usando Scrapy Items