Web Scraping con Python: La Guía Definitiva para Construir tu Scraper

Raluca Penciuc el 30 mar 2021

Si en el siglo XX pensábamos que "el tiempo es oro", ahora todo gira en torno a los datos. Más datos significa más información, mejores decisiones y más dinero.

El web scraping y los web scrapers han aumentado enormemente su popularidad, sobre todo en la última década. Cada vez más empresas necesitan una estrategia de marketing precisa, lo que implica grandes cantidades de información en poco tiempo.

Ahora que la extracción de datos está en el punto de mira, las empresas empiezan a ver cómo pueden beneficiarse de ella. Para los desarrolladores, podría ser una buena manera de impulsar su negocio o simplemente un proyecto interesante para perfeccionar sus habilidades de codificación.

Incluso si tu trabajo no tiene nada que ver con el web scraping, pero sabes trabajar con Python, al final de este artículo, conocerás un nuevo nicho en el que puedes hacer un gran uso de tus habilidades. Veremos cómo podemos construir nuestro propio Web Scraping con Python.

Comprender el Web Scraping con Python

Pero primero, ¿qué significa web scraping? En el nivel más básico, un web scraper extrae los datos de un sitio web, siempre que no todos ellos ofrezcan sus datos bajo una API pública.

Este proceso es más útil de lo que parece si tenemos en cuenta que cuanta más información tengamos, mejores decisiones tomaremos en nuestra empresa.

Hoy en día, los sitios web están cada vez más cargados de contenido, por lo que realizar este proceso totalmente a mano está lejos de ser una buena idea. Ahí es donde entra en discusión la construcción de una herramienta automatizada para el scraping.

"¿Para qué necesito los datos?", se preguntará. Echemos un vistazo a algunos de los principales casos de uso en los que el web scraping es un salvavidas:

Inteligencia de precios: una empresa de comercio electrónico necesitará información sobre los precios de la competencia para tomar mejores decisiones de precios y marketing.
Investigación de mercado: el análisis de mercado implica información de gran calidad, volumen y perspicacia.
Inmobiliario: particulares o empresas necesitan agregar ofertas de múltiples fuentes.
Generación de clientes potenciales: encontrar clientes para su negocio en crecimiento.
Seguimiento de la marca: las empresas analizarán foros, plataformas de medios sociales y reseñas para saber cómo se percibe su marca.
El control de los precios mínimos anunciados (MAP) garantiza que los precios en línea de una marca se corresponden con su política de precios.
Aprendizaje automático: los desarrolladores necesitan proporcionar datos de entrenamiento para que sus soluciones basadas en IA funcionen correctamente.

Puede encontrar más casos de uso y una descripción más detallada de los mismos aquí.

"¡Genial, empecemos!", dirá usted. Pero no tan rápido.

Incluso si usted entiende cómo funciona el raspado web y cómo puede mejorar su negocio, no es tan fácil construir un raspador web. Para empezar, algunas personas no quieren un raspador en sus sitios web por diferentes razones.

Una de ellas sería que el scraping implica el envío de muchas peticiones en un segundo, lo que puede sobrecargar el servidor. Los propietarios de sitios web pueden considerar esto a veces como un ataque de hackers(denegación de servicio), por lo que los sitios web adoptan medidas para protegerse bloqueando los bots.

Algunas de estas medidas pueden ser:

Bloqueo de IP: se produce cuando un sitio web detecta un elevado número de solicitudes procedentes de la misma dirección IP; el sitio web puede prohibirle totalmente el acceso o ralentizarlo considerablemente).
CAPTCHAs (Completely Automated Public Turing tests to tell Computers and Humans Apart): son problemas lógicos bastante triviales de resolver para las personas pero un quebradero de cabeza para los scrappers.
Honeypot: enlaces integrados en invisibles para los humanos pero visibles para los bots; una vez que caen en la trampa, el sitio web bloquea su IP.
Inicio de sesión obligatorio: los sitios web pueden ocultar parte de la información necesaria tras una página de inicio de sesión; aunque se autentique en el sitio web, el raspador no tiene acceso a sus credenciales ni a las cookies de su navegador.

Puede que algunos sitios web no apliquen estas técnicas, pero el simple hecho de que quieran mejorar la experiencia del usuario utilizando Javascript complica la vida de un web scraper.

Cuando un sitio web utiliza Javascript o un marco de generación de HTML, parte del contenido sólo es accesible tras realizar algunas interacciones con el sitio web o tras ejecutar un script (generalmente escrito en Javascript) que genera el documento HTML.

Consideremos también la calidad de los datos extraídos. Por ejemplo, en un sitio web de comercio electrónico, es posible que veas precios diferentes según la región en la que vivas. Estos datos no son muy precisos, por lo que el bot debe encontrar la forma de extraerlos con la mayor exactitud posible.

Si consigue superar todos estos obstáculos, deberá tener en cuenta que la estructura del sitio web siempre puede sufrir cambios. Al fin y al cabo, un sitio web debe ser fácil de usar, no apto para bots, por lo que nuestra herramienta automatizada debe adaptarse a estos cambios.

En esta interminable guerra del scraping, los bots idean soluciones por su cuenta. El objetivo de todos ellos es recrear lo mejor posible el comportamiento humano en Internet.

Por ejemplo, puede evitar el bloqueo de IP utilizando servicios proxy de IP. Es mejor utilizar servicios de pago porque los gratuitos hacen públicas sus IP, de modo que un sitio web puede bloquearlas.

También puede integrar solucionadores CAPTCHA. Te ayudarán a conseguir una alimentación continua de datos, pero ralentizarán ligeramente el proceso de scraping.

Como solución a las trampas honeypot, puede utilizar XPath (o incluso expresiones regulares si es lo suficientemente audaz) para raspar elementos especificados en lugar de todo el documento HTML.

Considerar todos estos problemas y cómo superarlos puede convertirse en un proceso laborioso y lento. Por eso, en la última década, las API de web scraping han ganado cada vez más atención.

Aquí, en WebScrapingAPI, recogemos el contenido HTML de cualquier sitio web, gestionando cualquier posible reto (como los mencionados anteriormente). Además, utilizamos Amazon Web Services, por lo que la velocidad y la escalabilidad no son un problema. ¿Te animas a probarlo? Puedes empezar con una cuenta gratuita, que te ofrece 1000 llamadas a la API al mes. Estupendo, ¿verdad?

Entender la Web

Pero ahora, volvamos al propósito de este artículo. Queremos aprender a construir un raspador web usando Python.

El primer concepto que hay que conocer es el Protocolo de Transferencia de Hipertexto (HTTP), que explica la comunicación entre un servidor y un cliente. La idea que hay detrás es bastante sencilla. El cliente (aplicación) envía un mensaje (petición HTTP) al servidor, y éste le devuelve una respuesta.

El mensaje contiene información múltiple que describe al cliente y cómo procesará los datos: método, versión HTTP y cabeceras.

En el web scraping, el método más utilizado para una petición HTTP es GET. Esto significa que vas a recuperar los datos que solicitas. Si quieres saber más sobre ellos, puedes encontrar aquí una lista completa y detallada.

Las cabeceras incluyen información adicional sobre la petición o respuesta HTTP. Hablaremos de las más relevantes en web scraping, pero puedes consultar la lista completa.

User-Agent: se utiliza para identificar la aplicación, el sistema operativo, el software y su versión; un raspador web utiliza este encabezado para que las solicitudes parezcan más realistas.
Cookie: contiene información de estado sobre la solicitud (por ejemplo, el token de autenticación).
Host: especifica el nombre de dominio del servidor y, eventualmente, el número de puerto en el que escucha el servidor.
Referrer: contiene el sitio de origen del que procede el usuario; en función de ello, el contenido mostrado puede ser diferente, por lo que un raspador web también tiene que tenerlo en cuenta.
Accept: notifica al servidor qué tipo de contenido puede devolver como respuesta; a menudo se pasa por alto en el web scraping, aunque puede ofrecer una comunicación más orgánica entre cliente y servidor.

Comprender Python

Python es un lenguaje de programación de propósito general y alto nivel que consigue mantenerse en las preferencias de los desarrolladores por múltiples razones:

Código legible: su sencilla sintaxis lo convierte en una opción perfecta para principiantes.
Paradigmas de programación: programación orientada a objetos, estructurada, funcional y orientada a aspectos son sólo algunos ejemplos.
Robusta biblioteca estándar: amplia gama de módulos para cada necesidad
Comunidad activa: muchas bibliotecas y herramientas de código abierto

Bien, dicho esto, preparemos nuestro espacio de trabajo. En primer lugar, necesitamos Python3. Puedes descargarlo e instalarlo desde aquí.

Este tutorial es independiente del IDE, así que siéntete libre de elegir con el que te sientas cómodo. Nosotros preferimos Visual Studio Code porque es ligero y está disponible para varios idiomas.

También vamos a utilizar un montón de bibliotecas de Python:

requests: para realizar una petición HTTP
beautifulsoup: para analizar el documento HTML
selenium: para scrapear contenido dinámico
nltk (opcional): para procesar el lenguaje natural

No tienes que instalarlos todos de antemano porque hay más detalles e instrucciones de instalación en cada paso.

Ahora, ¡empecemos a raspar la Web!

Crea tu propio raspador web

Para facilitarte las cosas, el tutorial estará dividido en pasos. Además, verás algunos pasos extra marcados con .1 después del número. Son alternativas que pueden interesarte.

Paso 1: Inspeccione la página que desea raspar

Bueno, basta de cháchara, vamos al grano.

En primer lugar, tenemos que elegir un sitio web que queramos scrapear. Para ilustrar los principios, vamos a elegir un sitio web educativo sencillo: https://en.wikipedia.org/wiki/Beer.

En este paso, sólo queremos comprobar el documento HTML de la página para hacernos una breve idea de su estructura. No importa qué navegador o sistema operativo utilices en este paso; el proceso es el mismo. Haga clic con el botón derecho del ratón en cualquier lugar, sobre una imagen, un enlace o un simple bloque de texto, y elija la opción "Inspeccionar elemento".

La pestaña "Elementos" es lo único que tendremos en foco. Dependiendo del sitio web, puedes ver mucho código HTML. Es importante no dejarse abrumar por él, sino comprobar sólo los datos que le interesan.

Paso 2: Enviar una solicitud HTTP

Ahora podemos empezar a escribir el código para nuestro raspador web. Simplemente empezamos haciendo una petición HTTP a nuestro sitio web para que nos devuelva el código HTML completo que acabamos de ver en el navegador. ¿Cómo se vería eso en código? Bueno, ¡impresionante! Estamos hablando de Python, después de todo.

Vamos a instalar la librería requests para realizar la petición HTTP:

pip install solicitudes

Ahora vamos a escribir el código:

import requests
URL = 'https://en.wikipedia.org/wiki/Beer'
page = requests.get(URL)

Bastante sencillo, ¿verdad? Importamos la librería que instalamos anteriormente. Luego definimos la URL del sitio web que queremos scrapear, e hicimos una petición GET. Si quieres ver cuál es el resultado, entonces hazlo e imprímelo. Por ahora, sólo verás una cadena desordenada que debería representar el HTML que viste en tu navegador. No nos ayuda demasiado, así que tenemos que procesarlo.

Paso 3: Raspar el HTML de la página

Para extraer alguna información útil de nuestro resultado, instalaremos la biblioteca beautifulsoup:

pip install beautifulsoup4

Primero vamos a dar un formato bonito a nuestro resultado:

import requests
from bs4 import BeautifulSoup
 
URL = 'https://en.wikipedia.org/wiki/Beer'
page = requests.get(URL)
 
soup = BeautifulSoup(page.content, 'html.parser')
prettyHTML = soup.prettify()
print(prettyHTML)

Convertimos el resultado anterior en un objeto BeautifulSoup. Con el atributo .content, puedes acceder a los datos HTML. Aplicando el método .prettify(), puedes ver el mismo formato que viste antes en tu navegador.

Desgraciadamente, no todos los sitios web te darán su HTML completo así como así. Como ya hemos dicho, los raspadores web se enfrentan a algunos retos.

Paso 3.1: Contenido dinámico

Por ejemplo, algunas páginas sólo son visibles después de iniciar sesión. Aunque te autentiques desde el navegador, tu script python no podrá acceder a los datos.

Otra situación habitual es la de los sitios web dinámicos. Significa que la respuesta a la solicitud GET no es un documento HTML, sino un script Javascript. Aunque puedas ver el HTML en el navegador, es porque ejecuta el script. Pero en tu código, necesitas ejecutar el script localmente para obtener el HTML.

Pero veamos esta situación en la práctica. Elegiremos un ejemplo minimalista de sitio web construido rápidamente a partir de un ejercicio universitario más antiguo: https://dynamic-website.surge.sh.

Puede ver el HTML completo en su navegador. En este ejemplo, se trata de una tabla que contiene imágenes en sus celdas.

import requests
from bs4 import BeautifulSoup
 
URL = 'https://dynamic-website.surge.sh'
page = requests.get(URL)
soup = BeautifulSoup(page.content, 'html.parser')
 
file = open('page.txt', mode='w', encoding='utf-8')
file.write(soup.prettify())

Ahora vamos a extraer este HTML, y esto significa que vamos a ejecutar el mismo código que antes, con algunos cambios: actualizamos la URL y abrimos un archivo de texto para almacenar nuestro resultado. Ejecutamos el programa y comprobamos en el archivo page.txt la misma sección de la tabla.

What is that? Where is the table? Well, it is there, except that there was no one to generate it yet. You can look into the <head> tag of the HTML document to see if there are any scripts used:

Y sí, usamos un guión.

Para resolver este problema, necesitamos selenium, una librería utilizada para pruebas web y automatización de actividades del navegador. Lo usaremos en modo headless, lo que significa que se comportará como un navegador normal que ejecutará el código Javascript pero sin interfaz de usuario visible.

pip install selenium

En este tutorial, vamos a utilizar el ChromeDriver para configurar el controlador web para selenium. ¡Sólo recuerda copiar la ruta donde lo descargaste! Nosotros lo guardamos en el directorio C, pero cualquier ubicación funcionará.

from selenium import webdriver
from selenium.webdriver.chrome.options import Options
from bs4 import BeautifulSoup
 
CHROMEDRIVER_PATH = "your/path/here/chromedriver_win32/chromedriver"
URL = "https://dynamic-website.surge.sh"
 
options = Options()
options.headless = True
driver = webdriver.Chrome(CHROMEDRIVER_PATH, options=opciones)
 
driver.get(URL)
soup = BeautifulSoup(driver.page_source, 'html.parser')
 
file = open('page.txt', mode='w', encoding='utf-8')
file.write(soup.prettify())

El resto del proceso es prácticamente igual, salvo que ya no utilizamos la biblioteca requests para realizar la petición HTTP.

Volvemos a ejecutar el programa, y...

... ¡Voilà! Ya tenemos el HTML completo.

Paso 4: Extracción de secciones específicas

Muy bien, volvamos al tema.

Tener el HTML completo es un progreso excelente, pero el proceso no ha terminado. La mayoría de las veces, necesitamos información específica de un sitio web, así que veamos cómo podemos extraerla.

Let’s start with something small - the title of the website. You can find it in the <head> section of the HTML, under a <title> tag.

Sabemos que un sitio web sólo tiene un título, por lo que utilizaremos el método.find(). Toma el nombre de la etiqueta como entrada y devuelve el elemento HTML, así que si necesitas su contenido, simplemente accede a él a través del atributo .text. Además, añadiremos un poco de estructura a nuestro pequeño scraper.

def extract_title(soup):
    title = soup.find('title')
 
    #output: <title>Beer - Wikipedia</title>    
    print('Title element: ', title)
 
    #output: Beer - Wikipedia
    print('Title: ', title.text)
 
def main():
    URL = 'https://en.wikipedia.org/wiki/Beer'
    page = requests.get(URL)
    soup = BeautifulSoup(page.content, 'html.parser')
 
    extract_title(soup)
 
main()

No hay ciencia espacial aquí. BeautifulSoup es una potente librería y soporta varios patrones de extracción de datos específicos. Puedes obtener elementos HTML por su nombre, id y atributo de clase, o incluso puedes usar selectores CSS. ¡El cielo es el límite!

Vamos a por más, como extraer elementos que aparecen más de una vez. En este caso, utilizamos el método.find_all(). La única diferencia es que devuelve una lista de elementos en lugar de uno solo. Por eso, después iteramos a través de ella y mostramos los atributos de cada elemento. Como ejemplo, extrajimos todas las imágenes del artículo:

def extract_images(soup):
 images = soup.find_all('img')
 for image in images:
 imageAlt = image.get('alt')
 imageSrc = image.get('src')
 print("ALT: ", imageAlt, "SRC: ", imageSrc)
 
def main():
   URL = 'https://en.wikipedia.org/wiki/Beer'
 page = requests.get(URL)
 soup = BeautifulSoup(page.content, 'html.parser')
 
 extract_images(soup)
 
main()

Paso 5: Pasar funciones mientras se raspa

Una situación habitual en el web scraping es cuando la lista de resultados del análisis es muy larga y contiene información mixta.

Por ejemplo, habrá observado que nuestras imágenes anteriores pueden contener o no un atributo alt .

O imaginemos que extraemos todos los enlaces del artículo. Todos sabemos que un artículo de Wikipedia tiene MUCHOS enlaces, y puede que no queramos una lista completa de ellos. El resultado tendrá enlaces externos e internos, referencias y citas, por lo que necesitamos clasificarlos en varias categorías.

Para resolver este problema, vamos a utilizar una función función lambda. Básicamente, la lambda tomará como parámetro cada elemento de la lista de resultados y aplicará la condición que definamos, igual que si usáramos un filtro.

Para un ejemplo práctico, supongamos que necesitamos extraer todos los enlaces internos, acceder a su artículo y hacer un resumen de cada uno. Teniendo en cuenta que uno de los casos de uso de Python es la Inteligencia Artificial, este ejemplo podría ser una excelente aplicación para obtener datos de entrenamiento.

En primer lugar, necesitaremos instalar la biblioteca NLTK porque calcular un resumen implica procesar el lenguaje humano.

pip install -U nltk

Y, por supuesto, importarlo en nuestro código:

import re
import nltk
import heapq
# necesidad de descargar sólo para la primera ejecución
# advertencia: el tamaño del conjunto de datos es grande; por lo tanto, llevará tiempo
nltk.download()

Nota: si eres usuario de macOS, es posible que aparezca el error "SSL: certificate verify failed". La causa puede ser que Python3.6 utiliza una versión incrustada de OpenSSL. Todo lo que tienes que hacer es abrir la ubicación donde instalaste Python y ejecutar este archivo:

/Su/Ruta/Aquí/Python 3.6/Instalar Certificados.command

Como puedes ver, también hemos importado la librería re, utilizada para operaciones con expresiones regulares y heapq, una implementación de heap queue.

Bien, ya tenemos todo lo que necesitamos para empezar a escribir el código. Empecemos por extraer los enlaces internos. Si vuelves al navegador, te darás cuenta de algunas cosas sobre los elementos que nos interesan.

Esas cosas serían:

El atributo href tiene un valor;
El valor href empieza por "/wiki/";
The link’s parent is a <p> tag;

Estas características nos ayudarán a diferenciar los enlaces que necesitamos de todos los demás.

Ahora que sabemos cómo encontrar los enlaces, veamos cómo podemos extraerlos.

count = 0
 
def can_do_summary(tag):
 global count
 if count > 10: return False
 
 # Rechazar si el padre no es un párrafo
 if not tag.parent.name == 'p': return False
 
 href = tag.get('href')
 # Rechazar si href no está establecido
 if href is None: return False
 
 # Rechazar si el valor de href no empieza por /wiki/
 if not href.startswith('/wiki/'): return False
 
 compute_summary(href)
 return True
 
 
def extract_links(soup):
 soup.find_all(lambda tag: tag.name == 'a' and can_do_summary(tag))
 
def main():
   URL = 'https://en.wikipedia.org/wiki/Beer'
 page = requests.get(URL)
 soup = BeautifulSoup(page.content, 'html.parser')
 
 extract_links(soup)
 
main()

Muy bien, ¿qué ha pasado aquí? Mirando la función extract_links(), podemos ver que en lugar del nombre de una etiqueta, pasamos una función lambda como parámetro al método .find_all(). Esto significa que de todas las etiquetas del documento HTML elegimos sólo las que cumplen nuestra condición.

Como puede ver, la condición de una etiqueta es ser un enlace y ser aceptada por la función can_do_summary() definida anteriormente. Allí, rechazamos todo lo que no coincide con las características observadas anteriormente. Además, utilizamos una variable global para limitar a 10 el número de enlaces extraídos. Si los necesita todos, no dude en eliminar la variable count.

Al final, llamamos a la función compute_summary() para el enlace recién encontrado. Ahí es donde se resume el artículo.

def compute_summary(href):
    global count
    full_link = 'https://en.wikipedia.org' + href
    page = requests.get(full_link)
    soup = BeautifulSoup(page.content, 'html.parser')
 
    # Concatenate article paragraphs
    paragraphs = soup.find_all('p')
    article_text = ""
    for p in paragraphs:
        article_text += p.text
 
    # Removing Square Bracket, extra spaces, special characters and digits
    article_text = re.sub(r'\[[0-9]*\]', ' ', article_text)
    article_text = re.sub(r'\s+', ' ', article_text)
    formatted_article_text = re.sub('[^a-zA-Z]', ' ', article_text)
    formatted_article_text = re.sub(r'\s+', ' ', formatted_article_text)
 
    # Converting text to sentences
    sentence_list = nltk.sent_tokenize(article_text)
 
    # Find frequency of occurrence of each word
    stopwords = nltk.corpus.stopwords.words('english')
 
    word_frequencies = {}
    for word in nltk.word_tokenize(formatted_article_text):
        if word not in stopwords:
            if word not in word_frequencies.keys():
                word_frequencies[word] = 1
            else:
                word_frequencies[word] += 1
 
    maximum_frequency = max(word_frequencies.values())
 
    for word in word_frequencies.keys():
        word_frequencies[word] = (word_frequencies[word] / maximum_frequency)
 
    # Calculate the score of each sentence
    sentence_scores = {}
    for sent in sentence_list:
        for word in nltk.word_tokenize(sent.lower()):
            if word in word_frequencies.keys():
                if len(sent.split(' ')) < 30:
                    if sent not in sentence_scores.keys():
                        sentence_scores[sent] = word_frequencies[word]
                    else:
                        sentence_scores[sent] += word_frequencies[word]
 
    # Pick top 7 sentences with highest score
    summary_sentences = heapq.nlargest(7, sentence_scores, key=sentence_scores.get)
    summary = '\n'.join(summary_sentences)
    count += 1

Resumiendo, hacemos una petición HTTP a la URL recién encontrada y convertimos el resultado en un objeto BeautifulSoup, tal y como hicimos al principio del artículo.

Para calcular un resumen, extraemos todos los párrafos del artículo y los concatenamos. Después, eliminamos todos los caracteres especiales que puedan interferir en los cálculos.

En términos sencillos, se hace un resumen calculando las palabras más frecuentes y dando a cada frase una puntuación basada en la frecuencia de sus palabras. Al final, elegimos las 7 frases con mayor puntuación.

No es el tema de nuestro artículo, pero puede leer más aquí si siente curiosidad o incluso pasión por el Procesamiento del Lenguaje Natural.

Paso 6: Genera un CSV para almacenar tus datos

Avanzando hacia el último paso de esta guía, tenemos que ver los resultados del scraping. Hasta ahora, nos limitábamos a mostrarlos en el terminal porque solo había unas pocas filas de datos.

Pero el scraping en la vida real supone una cantidad considerable de información, así que deberíamos ver cómo podemos guardar los resultados en un archivo.

Utilicemos la librería nativa csv(por lo que no es necesario instalar nada más) y abramos un fichero llamado summaries.csv.

import csv
archivo_resúmenes = open('resúmenes.csv', mode='a', encoding='utf-8')

La biblioteca creará el archivo si no existe. Además, lo abrimos en modo 'append' porque cada enlace se procesa secuencialmente, uno a uno.

    summaries_writer = csv.writer(summaries_file, delimiter=',', quotechar='"', quoting=csv.QUOTE_MINIMAL)
 summaries_writer.writerow([full_link, summary])

Al final de la función compute_summary(), simplemente inicializamos el escritor y comenzamos a añadir los datos. Una fila se compone de la URL del artículo y su resumen.

Paso 6.1: Generar un archivo JSON

Otro formato de serialización de datos que se ha hecho popular en los últimos años es JavaScript Object Notation (JSON). Es fácilmente legible por humanos y práctico si quieres pasar los datos raspados a una API u otra aplicación.

En Python, la forma más sencilla de escribir un archivo JSON es pasar los datos a un objeto dict.

import json
 
summaries_file = open('summaries.json', mode='a', encoding='utf-8')
data = {}
data['summaries'] = []

Usaremos la librería nativa para ficheros JSON y abriremos un nuevo fichero, tal y como hicimos anteriormente con nuestro CSV. A continuación inicializamos un objeto dict vacío y una lista vacía que contendrá nuestros resúmenes.

data['summaries'].append({
'url': full_link,
      'summary': summary
})

Al final de la función compute_summary(), justo donde escribimos antes el CSV, ahora añadimos un nuevo objeto dict a la lista final.

json.dump(datos, archivo_resúmenes, sangría=4)

Y por último, en nuestra función main(), después de ejecutar el proceso extract_links(), escribimos el objeto final en el fichero. El parámetro indent sólo dará un formato bonito al resultado.

Conclusión y alternativas

Bueno, eso es todo, el final de nuestro tutorial. Espero que haya sido útil y te haya dado una buena idea sobre el web scraping usando Python.

Aprendimos sus ventajas y cómo puede mejorar su negocio/aplicación. Al mismo tiempo, equilibramos esta información con algunos de los retos que plantea el web scraping.

Si usted es un desarrollador, puede que le resulte emocionante construir por su cuenta un raspador web superando todos estos problemas. Puede ser una experiencia de aprendizaje genial.

Pero como propietario de una empresa (o como alguien que necesita datos para una aplicación real a gran escala), es posible que desee evitar los costes que conlleva (tiempo, dinero, personas).

En esta situación, el uso de una API dedicada resolverá el problema. WebScrapingAPI supera todos los posibles puntos de bloqueo: renderizado Javascript, proxies, CAPTHAs, etc., y ofrece características personalizables. Además, si no estás del todo seguro, recuerda que hay una opción de plan gratuito, así que ¿por qué no probarlo?