Recopilación de datos con Scrapy

requisitos previos: 

• raspado 
• SQLite3

Scrapy es una biblioteca de raspado web que se utiliza para raspar, analizar y recopilar datos web. Ahora, una vez que nuestra araña ha raspado los datos, decide si:

• Conserva los datos.
• Suelte los datos o elementos.
• detener y almacenar los elementos de datos procesados.

Por lo tanto, 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 del archivo pipelines.py, cómo se utiliza para recopilar los datos extraídos por scrapy utilizando el lenguaje de base de datos SQLite3.

Inicialización del directorio y configuración del proyecto

En primer lugar, creemos 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..

Producción:

Creando entorno virtual

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

# project name is scrapytutorial
scrapy startproject scrapytutorial  
cd scrapytutorial

# link is of the website we are looking to crawl
scrapy genspider spider_to_crawl https://quotes.toscrape.com

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. 

Estructura de directorios

Scrapy estructura de directorios

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 el archivo items.py . Este archivo se usa 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.

Recopilación de datos con Scrapy

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.

Estructura predeterminada del archivo spider_to_crawl

Nota:

• 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 start_urls (se eliminó «http://» ).
• No requerimos instalar SQLite3 en nuestro sistema ya que viene preinstalado junto con python. Por lo tanto, podemos importarlo y comenzar a usarlo.

Dado que ahora estamos listos con nuestro proyecto, ahora podemos continuar para ver cómo se implementa el archivo pipelines.py para almacenar datos extraídos por la araña. 

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.
• Conversión de archivos de un formato a otro. por ejemplo, a JSON.

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. 

Las operaciones se realizan secuencialmente, por lo que estamos utilizando 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.

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

Sintaxis:

process_item(yo, elemento, araña)

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.

Además de estos, también podemos definir nuestros propios métodos (como init(), etc.) para realizar otras tareas, como crear una base de datos para almacenar datos o escribir código que convierta datos a otras formas.

Funcionamiento de oleoductos.py

Ahora veamos cómo funciona pipelines.py:

• Al principio, nuestra araña raspará los datos web y, utilizando su método de análisis, creará elementos (descritos en el archivo items.py) a partir de ellos. Luego, estos elementos se pasan al archivo pipelines.py.
• Después de recibir los elementos, el archivo de canalizaciones llama a todos los componentes descritos en sí mismo en un orden secuencial mencionado en el archivo settings.py. Estos componentes utilizan su función predeterminada para procesar el elemento de datos.
• Por lo tanto, una vez que se completa el procesamiento, el siguiente elemento de datos se transfiere desde la araña y el mismo fenómeno continúa hasta que se completa el web scraping.

Registro de los componentes

Es importante registrar todo el componente que creamos en el archivo de tuberías de elementos en el archivo settings.py en la estructura de directorios bajo el título ITEM_PIPELINES.

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.

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()
      
    # only one field that it of Quote.
    Quote = scrapy.Field()

Necesitaremos que este archivo se importe a nuestro archivo spider_to_crawl.py. Por lo tanto, de esta manera, podemos crear elementos para pasar a la canalización. Ahora tenemos clara la idea de canalización y cómo funcionan.

Implementando SQLite3

Ahora es el momento de aprender a implementar SQLite3 para crear bases de datos y tablas en python.

• Primero, crearemos el método init() ya que se llama primero en cualquier clase de python. Por lo tanto, en esta función, mencionaremos la llamada a otros métodos denominados: create_conn() y create_table() para crear la conexión y la tabla de la base de datos, respectivamente.
• Ahora en create_conn() usaremos el método connect() de la clase SQLite para conectar (o crear si no existe) a la base de datos mencionada.
• En create_table() habíamos escrito un comando SQL y le indicamos a la referencia del cursor de la conexión que ejecute ese comando para crear la tabla.
• Por último , se llamará al método process_item() (predeterminado) que llama a otro método que a su vez coloca los datos de los elementos raspados en esa tabla creada en init() .

Por lo tanto, de esta manera, podemos almacenar datos en la base de datos. Para visualizar los datos recopilados, debemos usar SQLite en línea, ya que, de forma predeterminada, nuestro sistema no tiene ningún método para abrir este tipo de archivo. Si tiene algún software de ayuda instalado, entonces no lo necesita.

Ahora estamos listos para pasar al ejemplo. En este ejemplo, utilizaremos todas las técnicas anteriores que hemos aprendido y crearemos una base de datos de nuestros datos extraídos. Usaremos el sitio mencionado anteriormente para extraer datos de cotizaciones y almacenarlos en nuestra base de datos usando SQLite3 en el archivo pipelines.py. 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. Entonces, comencemos a escribir el código en el archivo spider_to_crawl.py . Aquí estamos declarando nuestra araña y dando la URL requerida como entrada para que la araña pueda rastrearla.

 spider_to_crawl.py:

import scrapy
  
# importing the items structure described 
# in items.py file
from ..items import ScrapytutorialItem
  
  
class SpiderToCrawlSpider(scrapy.Spider):
    name = 'spider_to_crawl'
    #allowed_domains = ['https://quotes.toscrape.com/']
    start_urls = ['https://quotes.toscrape.com/']
  
    def parse(self, response):
        
        # creating items dictionary
        items = ScrapytutorialItem()
          
        # this is selected by pressing ctrl+f in console 
        # and selecting the appropriate rule of Xpath
        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
            # calling pipelines components for further 
            # processing.

Ahora estamos agregando los métodos de tubería a continuación que se escribirán 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):
        
        # Creating connection to database
        self.create_conn()
          
        # calling method to create table
        self.create_table()
  
    # create connection method to create database
    # or use database to store scraped data
    def create_conn(self):
        
        # connecting to database.
        self.conn = sqlite3.connect("mydata.db")
          
        # collecting reference to cursor of connection
        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):
        
        # extracting item and adding to table using SQL commands.
        self.curr.execute("""insert into firsttable values (?)""", (
            item['Quote'][0],
        ))
        self.conn.commit()  # closing the connection.

Los archivos Items.py y settings.py deberían verse así:

Elementos.py y configuración.py

Después de esto, use el comando dado para raspar y recopilar los datos.

Sintaxis:

nombre de archivo de rastreo de chatarra

Después de usar el comando «scrapy crawl spider_to_crawl» , el procesamiento se llevará a cabo de la manera indicada:

• 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 registraremos 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 llama como 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 , el método process_item() se usa para llamar a un método llamado putitemintable() que almacena los datos en la base de datos. Luego, después de ejecutar este método, la referencia se devuelve a la araña para pasar otros elementos a operar.

Veamos la salida de los datos almacenados después de raspar las comillas.

Producción:

El gateo de nuestra araña

Los datos se almacenan en la tabla.

Por lo tanto, de esta manera podemos recopilar los datos web de manera eficiente en una base de datos.