Header Ads Widget

Ticker

6/recent/ticker-posts

Cree su primer rastreador web Python con Scrapy

 En este tutorial, la atención se centrará en uno de los mejores marcos para el rastreo web llamado Scrapy. Aprenderá los conceptos básicos de Scrapy y cómo crear su primer rastreador web o araña. Además, el tutorial ofrece una demostración de cómo extraer y almacenar los datos extraídos.

Scrapy, un marco web escrito en Python que se utiliza para rastrear un sitio web y extraer datos de manera eficiente.

Puede utilizar los datos extraídos para su posterior procesamiento, extracción de datos y almacenamiento de datos en hojas de cálculo o cualquier otra necesidad comercial.

Arquitectura Scrapy

La arquitectura de Scrapy contiene cinco componentes principales:

  1. Motor chatarra
  2. Programador
  3. Descargador
  4. Arañas
  5. Canalizaciones de artículos

Motor chatarra

El motor Scrapy es el componente principal de Scrapy, cuyo objetivo es controlar el flujo de datos entre todos los demás componentes. El motor genera solicitudes y gestiona eventos contra una acción.

Programador

El planificador recibe las solicitudes enviadas por el motor y las pone en cola.

Descargador

El objetivo del descargador es recuperar todas las páginas web y enviarlas al motor. Luego, el motor envía las páginas web a la araña.

Arañas

Las arañas son los códigos que escribe para analizar sitios web y extraer datos.

Canalización de artículos

La canalización de elementos procesa los elementos uno al lado del otro después de que las arañas los extraen.

Instalación de Scrapy

Simplemente puede instalar Scrapy junto con sus dependencias usando el Administrador de paquetes de Python (pip).

Ejecute el siguiente comando para instalar Scrapy en Windows:

pip instalar 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, lo que afectará a otros scripts y herramientas.

Por lo tanto, crearemos un entorno virtual para proporcionar un entorno de desarrollo encapsulado.

En este tutorial, primero instalaremos un entorno virtual y luego continuaremos con la instalación de Scrapy.

  1. Ejecute el siguiente comando en la carpeta Python Scripts para instalar el entorno virtual:

pip instalar virtualenv

Rastreador web de Python
  1. Ahora instale virtualenvwrapper-win que nos permite crear entornos virtuales Python aislados.

pip instalar virtualenvwrapper-win

Rastreador web de Python
  1. Establezca la ruta dentro de la carpeta de scripts, para que pueda usar globalmente los comandos de Python:

establecer RUTA =% RUTA%; C: \ Usuarios \ hp \ appdata \ local \ programas \ python \ python37-32 \ scripts

  1. Crea un entorno virtual:

mkvirtualenv ScrapyTut

Donde ScrapyTut es el nombre de nuestro entorno:

Rastreador web de Python
  • Crea tu carpeta de proyecto y conéctala con el entorno virtual

Rastreador web de Python
  • Vincular el entorno virtual con el directorio de trabajo actual:

setprojectdir.

Rastreador web de Python
  • Si desea desactivar el modo de entorno virtual, simplemente use desactivar como se muestra a continuación:

desactivar

Rastreador web de Python
  • Si desea volver a trabajar en el proyecto, use el comando workon junto con el nombre de su proyecto:

trabajar en ScrapyTut

Rastreador web de Python

Ahora que tenemos nuestro entorno virtual, podemos continuar con la instalación de Scrapy.

  1. Para la instalación en Windows, debe descargar OpenSSL e instalarlo. Elija la versión normal que coincida con su versión de Python. Además, instale los redistribuibles de Visual C ++ 2008; de lo contrario, obtendrá un error al instalar las dependencias.
  2. Agregue C: \ OpenSSL-Win32 \ bin a la RUTA del sistema.
  3. Al instalar Scrapy, hay una serie de paquetes de los que depende Scrapy y tienes que instalarlos. Estos paquetes incluyen pywin32, twisted, zope.interface, lxml y pyOpenSSL.
  4. En el directorio ScrapyTut, ejecute el siguiente comando pip para instalar Scrapy:

pip instalar scrapy

Tenga en cuenta que al instalar Twisted, puede encontrar un error como:

Se requiere Microsoft visual c ++ 14.0

Para corregir este error, deberá instalar lo siguiente desde las herramientas de compilación de Microsoft:

Rastreador web de Python

Después de esta instalación, si recibe otro error como el siguiente:

error: el comando 'C: \\ Archivos de programa (x86) \\ Microsoft Visual Studio 14.0 \\ VC \\ BIN \\ link.exe' falló con el estado de salida 1158

Simplemente descargue la rueda de Twisted que coincida con su versión de Python. Pegue esta rueda en su directorio de trabajo actual como:

Rastreador web de Python

Ahora ejecute el siguiente comando:

instalación de pip Twisted-18.9.0-cp37-cp37m-win32.whl

Rastreador web de Python

Ahora, todo está listo para crear nuestro primer rastreador, así que hagámoslo.

Crear un proyecto scrapy

Antes de escribir un código Scrapy, deberá crear un proyecto Scrapy usando el comando startproject como este:

proyecto de inicio scrapy myFirstScrapy

Rastreador web de Python

Eso generará el directorio del proyecto con el siguiente contenido:

Rastreador web de Python

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:

Rastreador web de Python

Crear una araña

Después de crear el proyecto, navegue hasta el directorio del proyecto y genere su araña junto con la URL del sitio web que desea rastrear ejecutando el siguiente comando:

trabajos de scrapy genspider www.python.org

El resultado será como el siguiente:

Rastreador web de Python

Nuestra carpeta de araña "trabajos" será así:

Rastreador web de Python

En la carpeta Arañas, podemos tener varias arañas dentro del mismo proyecto.

Ahora repasemos el contenido de nuestra araña recién creada. Abra el archivo jobs.py que contiene el siguiente código:

01
02
03
04
05
06
07
08
09
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í, AccessoriesSpider es la subclase de scrapy.Spider. La variable 'nombre' es el nombre de nuestra araña que se asignó en el proceso de creación de la araña. El nombre se usa para ejecutar la araña. Los 'dominios_permitidos' es el dominio al que puede acceder esta araña.

Start_urls es la URL desde donde se iniciará el rastreo web o puede decir que es la URL inicial donde comienza el rastreo web. Luego tenemos el método parse 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 como se muestra a continuación:

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 subclasificar la araña de la clase CrawlSpider en lugar de la clase scrapy.spider. Para ello, deberá importar el siguiente módulo:

de scrapy.spiders importar CrawlSpider

Nuestra clase se verá así:

clase JobsSpider (CrawlSpider):…

El siguiente paso es inicializar la variable de reglas . La variable de reglas define las reglas de navegación que se seguirán al rastrear el sitio. Para utilizar el objeto de reglas, importe la siguiente clase:

de scrapy.spiders import Rule

La variable de reglas contiene además objetos de reglas como:

  1. link_extractor que es un objeto de la clase Link Extractor. El objeto link_extractor especifica cómo extraer los enlaces de la URL rastreada. Para ello, tendrá que importar la clase Link Extractor así:

de scrapy.linkextractors importar LinkExtractor

La variable de regla tendrá el siguiente aspecto:

1
2
3
4
5
6
7
rules = (
 
        Rule(LinkExtractor(allow=(), restrict_css=('.list-recent-jobs',)),
 
             callback="parse_item",
 
             follow=True),)
  1. 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.
  2. follow es un booleano que especifica si el enlace extraído debe seguirse o no después de esta regla.

Aquí permite se utiliza para especificar el enlace que se va a extraer. Pero en nuestro ejemplo, lo hemos restringido por clase CSS. Por lo tanto, solo se deben extraer las páginas con la clase especificada.

El parámetro de devolución de llamada especifica el método al que se llamará al analizar la página. Los .list-reciente-jobs es la clase para todos los puestos de trabajo que figuran en la página. Puede verificar la clase de un artículo haciendo clic derecho sobre ese artículo y seleccionando inspeccionar en la página web.

Rastreador web de Python

En el ejemplo, llamamos al método parse_item de la araña 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á Extrayendo… junto con la URL que se está extrayendo actualmente. Por ejemplo, se extrae un enlace https://www.python.org/jobs/3698/. Entonces, en la pantalla de salida, se imprimirá Extrayendo… https: //www.python.org/jobs/3698/.

Para ejecutar la araña, navegue a la carpeta de su proyecto y escriba el siguiente comando:

trabajos de rastreo scrapy

La salida será como la siguiente:

Rastreador web de Python

En este ejemplo, establecemos follow = true, lo que significa que el rastreador rastreará las páginas hasta que la regla se vuelva falsa. Eso significa cuando termina la lista de trabajos.

Si desea obtener solo la declaración de impresión, puede usar el siguiente comando:

trabajos scrapy crawl –nolog

La salida será como la siguiente:

Rastreador web de Python

¡Felicidades! Ha creado su primer rastreador web.

Conceptos básicos de Scrapy

Ahora podemos rastrear páginas web. Juguemos un poco con el contenido rastreado.

Selectores

Puede utilizar selectores para seleccionar algunas partes de los datos del HTML rastreado. Los selectores seleccionan datos de HTML usando 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.

Considere el siguiente ejemplo donde declaramos una cadena con etiquetas HTML. Usando la clase de selector, extrajimos los datos en la etiqueta h1 usando  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'

Artículos

Scrapy usa dictados de Python para devolver los datos extraídos.

Para extraer datos, Scrapy proporciona la  clase Item que proporciona objetos item. Podemos utilizar estos objetos de elementos como contenedores para los datos extraídos.

Los elementos proporcionan una sintaxis simple para declarar campos. La sintaxis es como 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.

Puede 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 elementos de la siguiente manera:

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 agregado un elemento. Puede llamar a esta clase desde su archivo de araña 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 class text , dentro de este div, tenemos un encabezado con class Listing-company , dentro de este encabezado, tenemos una etiqueta span con class Listing-location , y finalmente, tenemos una etiqueta a que contiene algo de texto. Este texto se extrae mediante el método extract ().

Finalmente, recorreremos todos los elementos extraídos y llamaremos a la clase de elementos.

En lugar de hacer todo esto en el rastreador, también podemos probar nuestro rastreador usando solo una declaración mientras trabajamos en el shell de Scrapy. Demostraremos Scrapy Shell en una sección posterior.

Cargadores de artículos

Los datos o elementos desechados por el objeto Elemento se cargan o se completan mediante el Cargador de elementos. Puede utilizar el cargador de elementos para ampliar las reglas de análisis.

Después de extraer elementos, podemos completar los elementos en el cargador de elementos con la ayuda de selectores.

La sintaxis del cargador de artículos es la siguiente:

01
02
03
04
05
06
07
08
09
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()

Caparazón Scrapy

Scrapy shell es una herramienta de línea de comandos que permite a los desarrolladores probar el analizador sin pasar por el rastreador en sí. Con Scrapy shell, puede depurar su código fácilmente. El objetivo principal de Scrapy shell es probar el código de extracción de datos.

Usamos el shell Scrapy para probar los datos extraídos por CSS y la expresión XPath cuando realizamos operaciones de rastreo en un sitio web.

Puede activar Scrapy shell desde el proyecto actual usando el comando shell:

cáscara chatarra

Rastreador web de Python

si desea analizar una página web, utilizará el comando de shell junto con el enlace de la página:

shell chatarra https://www.python.org/jobs/3659/

Para extraer la ubicación del trabajo, simplemente ejecute el siguiente comando en el shell:

response.css ('. text> .listing-company> .listing-location> a :: text'). extract ()

El resultado será así:

Rastreador web de Python

Del mismo modo, puede extraer cualquier dato del sitio web.

Para obtener la URL de trabajo actual, puede usar el siguiente comando:

response.url

Rastreador web de Python

Así es como extraes todos los datos en Scrapy. En la siguiente sección, guardaremos estos datos en un archivo CSV.

Almacenar los datos

Usemos response.css en nuestro código real. Almacenaremos el valor devuelto por esta declaración en una variable y luego lo almacenaremos en un archivo CSV. Utilice el siguiente código:

01
02
03
04
05
06
07
08
09
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í almacenamos 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 ().

Ejecute el siguiente comando para ejecutar su rastreador y almacenar el resultado en un archivo CSV:

trabajos de rastreo scrapy -o ScrappedData.csv

El generará un archivo CSV en el directorio del proyecto:

Rastreador web de Python

Scrapy es un marco muy sencillo para rastrear páginas web. Eso fue solo el comienzo. Si te gustó el tutorial y tienes ganas de más, cuéntanos en los comentarios, ¿cuál es el próximo tema de Scrapy sobre el que te gustaría leer?

Publicar un comentario

0 Comentarios