¿Cómo hacer web scraping en Python con BeautifulSoup?

¿Quiere sumergirse en el mundo de raspado web ¿pero sin enredarse en códigos complicados?

Con Python y la biblioteca BeautifulSoup, tu puedes fácilmente extraer y organizar datos de un sitio web en solo unas pocas líneas.

Requisitos previos para el scraping en Python con BeautifulSoup

✅ Antes de empezar, es importante tener algunos fundamentos de programación. Esto le permitirá comprender mejor cómo funciona el código. No es necesario ser un experto, pero saber leer y ejecutar un script Python te será de gran ayuda.

A continuación, le indicamos lo que debe hacer en primer lugar hacer scraping en Python con BeautifulSoup :

pip install beautifulsoup4

pip install solicitudes

¿Cómo hacer web scraping con Python y BeautifulSoup?

Siga nuestro tutorial para realizar un sencillo proyecto de web scraping.

Proyecto : recuperar el título de una página y todos los enlaces que contiene.

Paso 1: Recuperar el contenido de la página con Requests

Para llevar a cabo una Solicitud HTTP GET a una URL, utilice la función Solicitudes.

📌 Cuando envías una petición HTTP con Requests, el servidor siempre devuelve un código de estado. Estos códigos indican si la solicitud se ha realizado correctamente o no.

200 éxito.
301 / 302 redirección.
404 Página no encontrada.
500 error interno del servidor.

solicitudes de importación

# URL de destino
url = "https://bonjour.com"

# Enviar una petición GET
response = requests.get(url)

# Comprueba el código de estado
if response.status_code == 200:
    print("Éxito: ¡la página ha sido recuperada!")
    html = response.text # Contenido HTML de la página
    print("Extracto del contenido HTML:")
    print(html[:500]) # muestra sólo los 500 primeros caracteres
si no
    print(f "Error: código de estado {response.status_code}")
  

Paso 2: Analizar el código HTML con BeautifulSoup

from bs4 import BeautifulSoup
importar peticiones

url = "https://bonjour.com"
response = requests.get(url)
html = respuesta.texto

# Se recomienda especificar el analizador sintáctico
soup = BeautifulSoup(html, "html.parser")

Paso 3: Encontrar y extraer elementos

# Recuperar título <h1>
h1 = soup.find("h1")
print(h1.get_text())

# Recuperar todos los enlaces <a>
gravámenes = soup.find_all("a")
para lien en liens:
    print(lien.get_text(), lien.get("href"))

# Recuperar un div con un id específico
container = soup.find("div", id="main")

# Recuperar todos los enlaces con una clase específica
nav_links = soup.find_all("a", class_="nav-link")

# Todos los enlaces en los títulos de los artículos
article_links = soup.select("articulo h2 a")

# Todos <a> cuyo atributo href empiece por "http".
links_http = soup.select('a[href^="http"]')

Él Selectores CSS son muy potentes si desea seleccionar partes concretas de una página sin tener que revisar todo el código HTML manualmente.

¿Cómo extraer datos de una tabla HTML con BeautifulSoup?

Hasta ahora, hemos visto cómo recuperar títulos, enlaces o texto de una página web.

⚠ Pero, a menudo, los casos de uso reales son más complejos: extracción de datos estructurados como tablas o listas, la gestión de la paginación o incluso la resolución de errores frecuentes relacionados con el scraping. Eso es precisamente lo que vamos a ver juntos.

Extraer tablas y listas

Los sitios web suelen presentar sus datos en Tablas HTML (<table>, <tr>, <th>, <td>) o enumera (

/
,
1. ). Para transformar estas estructuras en datos utilizables, hay que aprender a recorrerlas línea a línea o elemento a elemento.

   Cuando quieras extraer una tabla HTMLEl principio es sencillo:

   • ✅ Recuperar cabeceras (<th>) para identificar los títulos de las columnas.
   • ✅ Examine cada línea (<tr>) y buscar celdas (<td>) que contienen los datos reales.
   • ✅ Almacenar información en una lista o diccionario.

   Para un Lista HTML (

   o
   con
   1. ) :
      • ✅ Localizar todas las etiquetas
      • con encontrar_todos.
      • ✅ Recuperar su contenido (texto o enlace) y añadirlo a una lista Python.

      En resumen :

      Las etiquetas <table>, <tr>, <th>, <td> se utilizan para reconstruir una tabla.
      Las etiquetas

      /
      ,
      1. se utilizan para transformar una lista HTML en una lista Python.

         He aquí un ejemplo con una tabla:

         html = """
         <table>
           <tr>
             <th>apellido</th>
             <th>Edad</th>
             <th>Pueblo</th>
           </tr>
           <tr>
             <td>Alicia</td>
             <td>25</td>
             <td>París</td>
           </tr>
           <tr>
             <td>Beto</td>
             <td>30</td>
             <td>Lyon</td>
           </tr>
         </table>
         """
         
         # Crear el objeto BeautifulSoup
         soup = BeautifulSoup(html, "html.parser")
         
         # Extraer las cabeceras del array
         headers = [th.get_text(strip=True) for th in soup.find_all("th")]
         print("Cabeceras:", cabeceras)
         
         # Extrae las filas de datos (omite la primera fila, ya que son las cabeceras)
         filas = []
         for tr in sop.find_all("tr")[1:]:
             celdas = [td.get_text(strip=True) for td in tr.find_all("td")]
             si celdas:
                 rows.append(cells)
         
         print("Líneas :", filas)
         

         Toma, find_all("th") recupera las cabeceras y find_all("td") recupera las celdas de cada fila. Hacemos un bucle sobre <tr> para reconstruir la tabla fila por fila.

         He aquí un ejemplo basado en una lista:

         from bs4 import BeautifulSoup
         
         html_list = """
         
           
         Manzana
           
         Plátano
           
         Naranja
         
         """
         
         soup = BeautifulSoup(html_list, "html.parser")
         
         # Recuperar elementos de la lista
         items = [li.get_text(strip=True) for li in soup.find_all("li")]
         print("Lista extraída:", items) # ["Manzana", "Plátano", "Naranja"]
         

         Aquí, cada

      2. se transforma directamente en un elemento de lista Python, dando como resultado ["Manzana", "Plátano", "Naranja"].

         Gestión de la paginación y los enlaces

         A menudo, los datos no caben en una sola página. Se reparten en varias páginas utilizando “página siguiente” o un paginación numerada (?página=1, ?página=2, ...).

         📌 En ambos casos, debes rizo (navegar en bucle) para recuperar todas las páginas y combinar los datos.

         Ejemplo con un parámetro de página :

         tiempo de importación
         importar peticiones
         from bs4 import BeautifulSoup
         
         # Ejemplo de URL con paginación
         BASE_URL = "https://bonjour.com/articles?page={}"
         HEADERS = {"User-Agent": "Mozilla/5.0"}
         
         all_articles = []
         
         # Supongamos que hay 5 páginas para navegar
         for página in rango(1, 6):
             url = BASE_URL.format(página)
             r = requests.get(url, headers=HEADERS, timeout=20)
             if r.status_code == 200:
                 soup = BeautifulSoup(r.text, "html.parser")
                 # Extraer los títulos de los artículos
                 articles = [h2.get_text(strip=True) for h2 in soup.find_all("h2", class_="title")]
                 all_articles.extend(artículos)
             si no:
                 print(f "Error en la página {page} (código : {r.status_code})")
             time.sleep(1.0) # cortesía
         
         print("Artículos recuperados:", todos_los_artículos)

         Una breve explicación:

         • Prepare la URL con una ubicación {} para insertar el número de página.

         BASE_URL = "https://bonjour.com/articles?page={}

         • Algunos sitios bloquean las solicitudes sin “identidad de navegador”. Añadir un User-Agent evita que te confundan con un bot.

         headers = {"User-Agent": "Mozilla/5.0"}
         requests.get(url, headers=cabeceras) 

         • Bucle de la página 1 a la 5.

         para página en rango(1, 6):

         • Recupera el HTML de la página.

         requests.get(url)

         • Limitar el tiempo de espera si el sitio no responde.

         requests.get(url, timeout=20)

         • Parser la page.

         BeautifulSoup(response.text, "html.parser")

         • Recuperar todos los títulos de los artículos.

         find_all("h2", class_="title")

         • Añade los elementos encontrados a una lista global.

         all_articles.extend(artículos)

         • Introduce una pausa entre cada petición para no sobrecargar el servidor y evitar ser baneado.

         time.sleep(1.0)

         • Después del bucle, todos_los_artículos contiene los 5 títulos de las páginas.

         Errores y retos comunes

         ❗ El scraping no siempre consiste en pulsar un botón y listo. Es posible que te encuentres con obstáculos frecuentes como:

         • Errores HTTP

         404 página no encontrada
         403 sin acceso
         500 error del servidor

         Ejemplo :

         response = requests.get(url)
         si response.status_code == 200:
             # Página OK
             print("Página recuperada correctamente")
         elif response.status_code == 404:
             print("Error: página no encontrada")
         si no
             print("Código devuelto:", response.status_code)
         

         • Sitios que bloquean el scraping

         Algunos detectan las solicitudes automáticas y bloquean el acceso.

         • Páginas dinámicas (JavaScript)

         BeautifulSoup sólo lee HTML estático. Si la página carga su contenido con JavaScriptno verás nada.

         ✅ En este caso, utilice herramientas como Selenio Donde Dramaturgo.

         Sin embargo, si quieres hacer scraping de forma eficaz sin que te bloqueen o dañen el sitio, aquí tienes las mejores prácticas:

         • ✔ Respetar la archivo robots.txt de un sitio web.
         • ✔ Puesta en marcha plazos entre peticiones para no sobrecargar el servidor (usando time.sleep()).
         • ✔ Uso apoderados y gíralos.
         • ✔ Cambie regularmente su Agente de usuario.

         ¿Cómo puedo scrapear la web con Selenium y BeautifulSoup?

         

         ⚠ Un recordatorio : BeautifulSoup es un excelente analizador HTML, pero no puede ejecutar JavaScript desde una página web. ¡Ahí es donde Selenium se convierte en tu aliado!

         Básicamente, el selenio controlar un navegador realEjecuta JavaScript y muestra la página como si un humano estuviera navegando. BeautifulSoup analizará el código HTML una vez que la página esté completamente renderizada. Así que usted puede extraer lo que quieras.

         Paso 1: Instalar Selenium y BeautifulSoup

         Aquí, en lugar de utilizar la biblioteca Request, vamos a utilizar Selenio. Para instalarlo, hay que pasar por pip.

         pip install selenium beautifulsoup4 

         A continuación, debe descargar e instalar WebDriver que corresponde a la versión de su navegador (por ejemplo, ChromeDrive para Google Chrome).

         ✅ Puede colocarlo en la misma carpeta que su script Python o en la’añadir a la variable de entorno PATH de su sistema.

         Paso 2: Configuración de Selenium

         En primer lugar, debe importar webdriver de Selenium para controlar un navegador.

         from selenium import webdriver
         from selenium.webdriver.common.by import By 

         A continuación, se inicia un navegador. Este abrirá la página web y ejecutará el código JavaScript (Ejemplo: Chrome).

         controlador = webdriver.Chrome() 

         Usted indica al navegador qué página debe visitar.

         driver.get("https://www.exemple.com") 

         Si la página tarda en mostrar algunos elementos, puedes indicarle a Selenium que espere un poco.

         driver.implicitly_wait(10) 

         Paso 3: Recuperar el contenido de la página

         Una vez que se haya cargado la página, puede recuperar el archivo DOM completo (código fuente HTML tras la ejecución de JS).

         html_content = driver.page_source 

         Paso 4: Análisis HTML con BeautifulSoup

         Ahora pasa este código fuente a BeautifulSoup para poder utilizarlo:

         from bs4 import BeautifulSoup # Crear un objeto BeautifulSoup soup = BeautifulSoup(html_content, 'html.parser') # Ejemplo: recuperar todos los títulos de la página titles = soup.find_all('h2') for title in titles: print(title.get_text()) 

         👉 BeautifulSoup ofrece potentes métodos como find(), find_all() y selectores CSS para objetivo y extraer elementos Código HTML.

         Paso 5: Cerrar el navegador

         Muy importante: ¡cierre siempre el navegador después de la ejecución para liberar recursos!

         driver.quit() 

         ✅ ¡Y ahí lo tienes! Ya puedes combinar la potencia de Selenium para simular la navegación humana (clics, desplazamientos, etc.) con la eficacia de BeautifulSoup para el análisis del código HTML.

         preguntas frecuentes

         ¿Cuál es la mejor herramienta para el web scraping en Python?

         No existe realmente una herramienta universal mejor, sino soluciones adaptadas a cada proyecto.

         🔥 BeautifulSoup Analizador HTML: sencillo y eficaz para analizar HTML y extraer contenidos rápidamente. Es ideal si estás empezando o si tienes proyectos pequeños.

         🔥 Chatarra : es un marco completo, diseñado para gestionar grandes volúmenes de datos con funciones avanzadas.

         🔥 Dramaturgo : perfecto para sitios complejos generados por JavaScript, ya que simula un navegador real y permite interactuar con la página como lo haría un humano.

         Cómo utilizar BeautifulSoup para extraer contenido de una etiqueta <div> ?

         Con BeautifulSoup, puede apuntar a una baliza específica utilizando un Selector CSS. Para extraer el contenido de un <div>Estos son los pasos:

         1. Recupere la página con Requests, luego analícela con BeautifulSoup

         from bs4 import BeautifulSoup
         importar peticiones
         
         url = "URL_OF YOUR_SITE" # Sustituir por la URL real
         response = requests.get(url)
         html_content = response.text
         
         soup = BeautifulSoup(html_content, "html.parser")

         2. Utilice la seleccionar() pasándole el selector CSS para que apunte a la etiqueta <div>

         Para recuperar el primer elemento, utilice sopa.seleccionar_uno
Para recuperar todos los elementos, utilice sopa.seleccionar

         Ejemplo HTML:

         <div class="article">
           <h2>Título del artículo</h2>
           <p>Esto es lo que dice el párrafo.</p>
         </div>

         Ejemplo con CSS :

         # Recuperar el primer div con la clase "article
         div_article = soup.select_one("div.article")
         
         # Mostrar su contenido de texto
         if div_article:
         print(div_article.get_text(strip=True))

         En este caso, el selector CSS es div.artículo.

         3. Extraer elementos dentro de la <div>

         # Recuperar el título dentro del div
         title = soup.select_one("div.articulo h2").get_text()
         
         # Recuperar el párrafo dentro del div
         paragraph = soup.select_one("div.articulo p").get_text()
         
         print("Título:", título)
         print("Párrafo:", párrafo)

         ¿Cómo pueden utilizarse conjuntamente Requests y BeautifulSoup?

         Estas dos bibliotecas se complementan mutuamente.

         1. Requests recupera el contenido de una página web con una solicitud HTTP.

         Envía una petición HTTP al sitio de destino y descarga el código HTML sin procesar de la página.

         solicitudes de importación
         
         url = "https://sitecible.com"
         response = requests.get(url) # Petición HTTP
         print(response.text) # muestra el HTML sin procesar

         En esta fase, todo lo que tienes es un enorme texto lleno de etiquetas (<html>,<div><p>etc.).

         2. BeautifulSoup analiza este contenido HTML para extraer lo que le interesa.

         Toma el HTML sin formato y lo transforma en una estructura organizada. Gracias a ello, puedes navegar fácilmente por el HTML: localizar, extraer y recuperar datos.

         from bs4 import BeautifulSoup
         
         soup = BeautifulSoup(response.text, "html.parser") # analiza el HTML
         title = soup.find("h1").get_text() # extrae el contenido de a <h1>
         print(título)

         ¿Por qué mi código de web scraping no funciona en algunos sitios?

         Es posible que su script no recupere nada, porque algunos sitios no proporcionan todo el contenido directamente en HTML.

         Estos sitios utilizan JavaScript para cargar datos de forma dinámica. Sin embargo, BeautifulSoup no permite’analizar los datos generados por JavaScript.

         En este caso, debe recurrir a herramientas como Dramaturgo Donde Selenio.

         ¿Qué papel desempeña BeautifulSoup en el web scraping?

         BeautifulSoup desempeña el papel de’Analizador HTML.

         Toma el código fuente de una página en forma de texto sin formato y lo transforma en un objeto estructurado que se puede navegar fácilmente.

         Sin esta biblioteca, verá un enorme bloque de texto ilegible. En pocas palabras, BeautifulSoup es el traductor entre la librería HTML plano y su Código Python.

         Web scraping: ¿BeautifulSoup vs Scrapy?

         BeautifulSoup y Chatarra son muy diferentes, aunque ambos se utilizan para el web scraping.

         BeautifulSoup	Chatarra
         Una biblioteca sencilla utilizada únicamente para analizar HTML y extraer datos.	Un marco completo que gestiona todo el proceso de scraping (consultas, seguimiento de enlaces, paginación, exportación de datos, gestión de errores).

         En resumen, BeautifulSoup facilita la’Extracción de datos HTML en Python. Esta biblioteca es perfecta para principiantes, ya que hace que el scraping sea rápido y sencillo.

         De lo contrario, si no desea sin codificación, la herramienta completa Datos brillantes es también una excelente solución para el web scraping.

         👉 ¡Ahora cuéntanos en los comentarios qué has conseguido rascar!