Scrapy – Canalización de artículos

Scrapy es una biblioteca de raspado web que se utiliza para raspar, analizar y recopilar datos web. Para todas estas funciones, tenemos un archivo pipelines.py que se usa para manejar datos raspados a través de varios componentes (conocidos como clase ) que se ejecutan secuencialmente.

En este artículo, aprenderemos a través de los métodos definidos para el archivo de esta tubería y mostraremos diferentes ejemplos de ello.

Configuración del proyecto

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

Paso 1: 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:

Creando entorno virtual

Paso 2: 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 comando dado a continuación.

pip install scrapy

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

# projEct name is scrapytutorial
scrapy startproject scrapytutorial
cd scrapytutorial
scrapy genspider spider_to_crawl https://quotes.toscrape.com

Luego, la salida del directorio del proyecto se parece a la que se muestra en la imagen. (Consulte esto si desea saber más sobre un proyecto scrapy y familiarizarse con él).

Estructura de directorios

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.

spider_to_crawl.py

La canalización de elementos es un método de canalización que está escrito dentro del archivo pipelines.py y se utiliza para realizar las operaciones que se indican a continuación en los datos extraídos de forma secuencial. Las distintas operaciones que podemos realizar sobre los elementos raspados se enumeran a continuación:

• Analizar los archivos o datos raspados.
• Almacene los datos raspados en bases de datos.
• Validar y comprobar los datos obtenidos.
• Conversión de archivos de un formato a otro. por ejemplo, a JSON.

Realizaremos algunas de estas operaciones en los ejemplos siguientes.

Las operaciones se realizan secuencialmente ya que estamos usando el archivo settings.py para describir el orden en que se deben realizar las operaciones. es decir, podemos mencionar qué operación se realizará primero y cuál se realizará a continuación. Esto suele hacerse cuando estamos realizando varias operaciones sobre los artículos.

Primero veamos la estructura interna de un archivo de canalización predeterminado. A continuación se muestra la clase predeterminada mencionada en ese archivo.

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. Si algún archivo de canalización consta de más de una clase, debemos mencionar explícitamente su orden de ejecución. La estructura de componentes se define a continuación:

Cada componente (clase) debe tener una función predeterminada denominada process_item(). Este es el método predeterminado que siempre se llama dentro de la clase o componente del archivo de canalizaciones.

Sintaxis: process_item( self, item, spider )

Parámetros:

• self : Esta es una referencia al objeto self que llama al método.
• item : Esta es la lista de elementos raspados por la araña
• araña: menciona la araña usada para raspar.

El tipo de devolución de este método es el objeto del elemento modificado o no modificado o se generará un error si se encuentra alguna falla en el elemento.

Este método también se usa para llamar a otro método en esta clase que se puede usar para modificar o almacenar datos.

Métodos adicionales: estos métodos se utilizan junto con el método de objeto propio mencionado anteriormente para obtener un control adicional sobre los elementos.

Además de todos estos métodos, también podemos crear nuestro propio método para realizar más operaciones, como si queremos almacenar algunos datos, entonces podemos tener el componente que inicializa la base de datos y crea tablas en ella. Puede haber otro componente que agregará el datos a la base de datos.  

Antes de continuar y referirnos a los ejemplos, un punto importante a tener en cuenta es que debemos registrar todos los componentes (clases) del archivo pipelines.py en la configuración.py de la estructura de carpetas. Esto se hace para mantener un orden de los componentes a ejecutar y, por lo tanto, producir resultados precisos.

Creación de elementos para pasar a través de archivos.

Una cosa más a tener en cuenta es que necesitaremos una descripción de lo que contendrá nuestro artículo en el archivo items.py . Por lo tanto, nuestro archivo items.py contiene el siguiente código:

# Define here the models for your scraped items
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.

Necesitaremos que este archivo se importe en nuestro archivo spider_to_crawl.py . Por lo tanto, de esta manera podemos crear elementos para pasar a la canalización. Usaremos principalmente la página web de citas de sabiduría donde podemos obtener varias citas basadas en sus autores y etiquetas respectivas y luego modificaremos y usaremos canalizaciones de elementos en los datos extraídos a lo largo del ejemplo.

Ejemplo 1: Conversión de datos raspados a formato JSON

Para convertir los datos en formato JSON, utilizaremos la biblioteca JSON de python junto con su método   dumps() .

La idea es que obtendremos los datos raspados en el archivo pipelines.py y luego abriremos un archivo llamado result.json (si aún no está presente, se creará automáticamente) y escribiremos todos los datos JSON en él.

• 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
 
class ScrapytutorialPipeline:
    def process_item(self, item, spider):       
       
          # calling dumps to create json data.
        line = json.dumps(dict(item)) + "\n"  
        self.file.write(line)               
        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:

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('p::text').extract()
            yield items

Producción:

Explicación:

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

• 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 enviaremos cada dato de esta variable uno por uno a nuestro archivo pipelines.py.
• Recibimos variables de elementos de spider en el archivo pipelines.py, que luego se convierte a JSON usando el método dumps(), y luego la salida se escribe en el archivo abierto.

Este es el archivo JSON que se creó:

Ejemplo 2: canalización para cargar datos en la base de datos en SQLite3

Ahora vamos a presentar una canalización de elementos que extraerá el contenido de la web y lo almacenará en la tabla de la base de datos definida por nosotros. Para simplificar, usaremos la base de datos SQLite3.

Entonces, usaremos la idea de cómo implementar SQLite3 en python para crear una canalización que recibirá datos del raspado de araña e insertará esos datos en la tabla en la base de datos creada.

 spider_to_crawl.py:

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
         
        # extracting data
        for quote in Quotes_all:   
            items['Quote'] = quote.css('::text').extract()
            yield items

Mencionamos los métodos de canalización a continuación que deben escribirse en el archivo pipelines.py para que se cree la base de datos:

archivo pipelines.py

from itemadapter import ItemAdapter
import sqlite3
 
class ScrapytutorialPipeline(object):
 
# init method to initialize the database
# and create connection and tables
    def __init__(self):
        self.create_conn()
        self.create_table()
     
    # create connection method to create
    # database or use database to store scraped data
    def create_conn(self):
        self.conn = sqlite3.connect("mydata.db")
        self.curr = self.conn.cursor()
 
    # Create table method
    # using SQL commands to create table
    def create_table(self):
        self.curr.execute("""DROP TABLE IF EXISTS firsttable""")
        self.curr.execute("""create table firsttable(
                        Quote text
                        )""")
         
# store items to databases.
    def process_item(self, item, spider):
        self.putitemsintable(item)
        return item
     
    def putitemsintable(self,item):
        self.curr.execute("""insert into firsttable values (?)""",(
            item['Quote'][0],  # extracting item.
        ))
        self.conn.commit()

Producción:

Explicación:

Después de usar el comando «scrapy crawl spider_to_crawl», se llevarán a cabo los pasos que se indican a continuación

• En spider.py mencionamos el código que nuestra araña debe ir a ese sitio y extraer todos los datos mencionados en el formato de URL y luego creará una lista de elementos y pasará esa lista al archivo pipelines.py para su posterior procesamiento.
• También estamos creando un objeto de elementos para que contenga los datos que se pasarán y los elementos en el archivo items.py en el directorio.
• Luego, cuando la araña rastrea, recopila datos en objetos de elementos y los transfiere a las canalizaciones y lo que sucede a continuación ya está claro en el código anterior con sugerencias en los comentarios. El archivo pipelines.py crea una base de datos y almacena todos los elementos entrantes.
• Aquí se llama al método init(), que se denomina método predeterminado siempre en cualquier archivo de Python. Luego llama a todos los demás métodos que se utilizan para crear una tabla e inicializar la base de datos.
• Luego se llama al método process_item() que se usa para llamar a un método llamado putitemintable() donde los datos se agregan a la base de datos. Luego, después de ejecutar este método, la referencia se devuelve a la araña para pasar otro elemento a operar.