¿Cómo convertir un elemento Scrapy a JSON?

Requisito previo: 

• raspado
• JSON

Scrapy es una herramienta de raspado web que se utiliza para recopilar datos web y también se puede usar para modificar y almacenar datos en cualquier forma que queramos. Cada vez que la araña de scrapy extrae datos, estamos convirtiendo esos datos sin procesar en elementos de scrapy, y luego pasaremos ese elemento para su posterior procesamiento a las canalizaciones. En las canalizaciones, estos elementos se convertirán en datos JSON, y podemos imprimirlos o guardarlos en otro archivo. Por lo tanto, podemos recuperar datos JSON a partir de datos extraídos de la web.

Inicialización del directorio y configuración del proyecto

Primero vamos a crear un proyecto scrapy. Para eso, asegúrese de que Python y PIP estén instalados en el sistema. Luego, ejecute los comandos que se indican a continuación uno por uno para crear un proyecto scrapy similar al que usaremos en este artículo.

• Primero creemos un entorno virtual en una carpeta llamada GFGScrapy y activemos ese entorno virtual allí.

# To create a folder named GFGScrapy
mkdir GFGScrapy
cd GFGScrapy

# making virtual env there
virtualenv
cd scripts  

# activating it
activate
cd..

Por lo tanto, después de ejecutar todos estos comandos obtendremos el resultado como se muestra:

• Ahora es el momento de crear un proyecto scrapy. Para eso, asegúrese de que scrapy esté instalado en el sistema o no. Si no está instalado, instálelo usando el siguiente comando.

Sintaxis:

pip install scrapy

Ahora, para crear un proyecto scrapy, use el comando a continuación y también cree una araña.

scrapy startproject scrapytutorial //el nombre del proyecto es scrapytutorial

cd scrapytutorial

scrapy genspider spider_to_crawl https://quotes.toscrape.com/

//El enlace de arriba menciona el sitio web donde vamos a rastrear la araña.

Una vez que haya creado un proyecto scrapy utilizando el instalador pip, la salida del directorio del proyecto se verá como la que se muestra en la imagen. (Consulte esto si desea saber más sobre un proyecto scrapy y familiarizarse con él).

La estructura del directorio consta de la siguiente ruta (muestra)

C://<project-name>/<project-name>

En la imagen de arriba, el nombre del proyecto es scrapytutorial y tiene muchos archivos dentro, como se muestra.

Los archivos que nos interesan son el archivo spider_to_crawl.py (donde solíamos describir los métodos para nuestras arañas) y el archivo pipelines.py donde describiremos los componentes que manejarán nuestro procesamiento de datos adicional que se realizará con los datos raspados. . En términos simples, este archivo se usa para describir los métodos que se usan para operaciones posteriores con los datos. El tercer archivo más importante es el archivo settings.py donde registraremos nuestros componentes (creados en pipelines, archivo .py) de manera ordenada. El siguiente archivo más importante es items.pyexpediente. Este archivo se utiliza para describir la estructura de formulario o diccionario en la que los datos fluirán desde spider_to_crawl hasta el archivo pipelines.py. Aquí estaremos dando algunas claves que estarán presentes en cada ítem.

Echemos un vistazo a nuestro archivo spider_to_crawl.py presente dentro de nuestra carpeta de arañas. Este es el archivo donde estamos escribiendo la URL donde nuestra araña tiene que rastrear y también un método llamado parse() que se usa para describir qué se debe hacer con los datos extraídos por la araña.

Este archivo se genera automáticamente mediante el comando » scrapy genspider » utilizado anteriormente. El archivo lleva el nombre del nombre de la araña. A continuación se muestra el archivo predeterminado generado.

Tenga en cuenta que hicimos algunos cambios en el archivo predeterminado anterior, es decir, comentamos la línea allow_domains y también hicimos algunos cambios en strat_urls (eliminado » http:// «).

Convertir scrapy a JSON

Las canalizaciones son métodos mediante los cuales podemos convertir, modificar o almacenar elementos de datos extraídos. Por lo tanto, primero hablemos de algunos de sus componentes.

A continuación se muestra un vistazo al archivo Pipelines.py predeterminado:

Para realizar diferentes operaciones en elementos, debemos declarar un componente separado (clases en el archivo) que consta de varios métodos, utilizados para realizar operaciones. El archivo de canalizaciones por defecto tiene una clase nombrada según el nombre del proyecto. También podemos crear nuestras propias clases para escribir qué operaciones tienen que realizar.

Cada componente del archivo pipelines.py consta de un método predeterminado llamado process_item().

Sintaxis:

process_item(auto, elemento, araña):

Este método admite tres variables, una es una referencia al objeto propio, otra es el elemento de datos extraídos enviados por la araña y la tercera es la propia araña. Este método se utiliza para modificar o almacenar los elementos de datos que raspa la araña. Tenemos que mencionar la forma en que los paquetes de elementos recibidos se modificarán solo con este método.

Este es el método predeterminado que siempre se llama dentro de la clase del archivo pipelines.py.

Además de estos, también podemos crear nuestros propios métodos que se pueden usar para modificar o realizar otros cambios en los elementos de datos. Por lo tanto, dado que tenemos que convertir nuestros datos extraídos al formato JSON, debemos tener un componente (clase) que haga nuestro trabajo respectivo. Pero antes de eso, tenemos que realizar dos cosas principales.

1) Primero, debemos registrar el nombre del componente de canalización en nuestro archivo settings.py . La sintaxis se da a continuación.

Sintaxis:

ITEM_PIPELINES = {

myproject.pipelines.component : <número de prioridad>

#muchos otros componentes

}

Aquí, el número de prioridad es el orden en que el scrapy llamará a los componentes.

Por lo tanto, para el proyecto anterior, se aplicará el formato dado a continuación.

ITEM_PIPELINES = {

   ‘scrapytutorial.pipelines.ScrapytutorialPipeline’: 300,

}

2) Otra cosa que tenemos que realizar es declarar el formato del elemento que tenemos que usar para pasar nuestros datos a la canalización. Entonces, para eso, usaremos nuestro archivo items.py .

El código que aparece a continuación crea un artículo con una variable clave denominada » Cotización» en nuestro archivo items.py . Luego tenemos que importar este archivo en nuestro archivo spider_to_crawl.py (que se muestra en el ejemplo).

# Define here the models for your scraped items
#
# See documentation in:
# https://docs.scrapy.org/en/latest/topics/items.html
 
import scrapy
 
 
class ScrapytutorialItem(scrapy.Item):
    # define the fields for your item here like:
    # name = scrapy.Field()
    Quote = scrapy.Field()  # only one field that it of Quote.

El código anterior crea elementos con una sola clave, podemos crear elementos con muchas claves.

Ahora que hemos visto cómo implementar componentes en el archivo pipelines.py y cómo se realizan las configuraciones y se declaran los elementos. Ahora estamos listos para tener un ejemplo en el que convertiremos nuestros elementos de datos raspados al formato JSON. Para convertir los datos en formato JSON, utilizaremos la biblioteca JSON de python junto con su propiedad dumps . La idea es que obtendremos los datos raspados en el archivo pipelines.py, y luego abriremos un archivo y escribiremos todos los datos JSON en él. Entonces los métodos llamados:

• Se llamará a open_spider() para abrir el archivo ( result.json ) cuando spider comience a rastrearse.
• Se llamará a close_spider() para cerrar el archivo cuando se cierre spider y finalice el raspado.
• siempre se llamará a process_item() (ya que es el valor predeterminado) y será el principal responsable de convertir los datos al formato JSON e imprimir los datos en el archivo. Usaremos el concepto de marcos web de python, es decir, cómo convierten los datos recuperados de back-end a JSON y otros formatos.

Por lo tanto, el código en nuestro pipelines.py se ve así:

from itemadapter import ItemAdapter
import json  # Json package of python module.
 
 
class ScrapytutorialPipeline:
    def process_item(self, item, spider):  # default method
        # calling dumps to create json data.
        line = json.dumps(dict(item)) + "\n"
        # converting item to dict above, since dumps only intakes dict.
        self.file.write(line)                    # writing content in output file.
        return item
 
    def open_spider(self, spider):
        self.file = open('result.json', 'w')
 
    def close_spider(self, spider):
        self.file.close()

Nuestro spider_to_crawl.py parece

import scrapy
from ..items import ScrapytutorialItem   
 
class SpiderToCrawlSpider(scrapy.Spider):
    name = 'spider_to_crawl'
 
    start_urls = ['https://quotes.toscrape.com/']
 
    def parse(self, response):
         
        # creating items dictionary
        items = ScrapytutorialItem()   
        Quotes_all = response.xpath('//div/div/div/span[1]')
 
        # These paths are based on the selectors
         
        for quote in Quotes_all: #extracting data
            items['Quote'] = quote.css('::text').extract()
            yield items

Nuestro archivo settings.py se ve así:

Nuestro archivo items.py se parece a

Después de usar el comando » scrapy crawl spider_to_crawl «, se llevarán a cabo los siguientes pasos.

• La araña se rastrea debido a que se crea el archivo result.json. Ahora la araña raspa la página web y recopila los datos en Quotes_all Variable. Luego, cada dato se extrae de la variable y se pasa al elemento declarado en el archivo como el valor de la clave, es decir , Cotización. El último en el rendimiento que llamamos archivo pipelines.py para su posterior procesamiento.
• Recibimos una variable de elemento de spider en el archivo pipelines.py que luego se convierte a JSON usando el método de volcados y luego la salida se escribe en el archivo abierto.
• El archivo está cerrado y podemos ver la salida.

• Archivo JSON creado

Producción: