Para hacer raspado web en Python con BeautifulSoup, necesitas dos bibliotecas: requests para descargar la página web, y beautifulsoup4 para extraer los datos del código HTML.
Instálalas con el comando pip install requests beautifulsoup4, y luego sigue la guía que aparece a continuación para extraer datos de una página web paso a paso.
Requisitos previos para el scraping en Python con BeautifulSoup
Antes de ponerte manos a la obra, no hace falta que seas un experto. Basta con saber leer y ejecutar un script Python Es más que suficiente para empezar.
Esto es lo que hay que instalar para empezar:
- Instalar Python así como un entorno de desarrollo.
- Instalar pip, la herramienta que permite añadir bibliotecas de Python con un solo comando.
- Instalar BeautifulSoup :
pip install beautifulsoup4Presta atención al nombre del paquete: en PyPI, eso está bien beautifulsoup4 que hay que escribir. El módulo que vas a importar a tu código se llama bs4.
- Instalar Requests Para descargar las páginas web:
pip install solicitudes- Instalar lxml (opcional), un analizador más rápido que utiliza BeautifulSoup para analizar el HTML:
pip install lxml¿Cómo hacer web scraping con Python y BeautifulSoup?
Aquí tienes un proyecto completo para recuperar el título de una página web y todos los enlaces que contiene.
Paso 1: Recuperar el contenido de la página con Requests
Para descargar una página web, tienes que enviar una Solicitud HTTP GET a una URL. Esa es la función de la biblioteca Requests.
Con cada solicitud, el servidor devuelve un código de estado que te indica si todo ha salido bien. Los principales que debes conocer:
- 200 éxito.
- 301 / 302 redirección.
- 404 Página no encontrada.
- 500 error interno del servidor.
Con Requests, compruebas este resultado mediante el atributo .código_estado. He aquí un ejemplo concreto: este código envía una solicitud a una página web, comprueba el código de estado y, si todo va bien, muestra un fragmento del contenido HTML.
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
Cuando recuperas el contenido de una página con respuesta.texto, obtienes una simple cadena de caracteres: todo el código HTML de la página, pero que no se puede utilizar tal cual. Para poder manipularlo fácilmente, creas un objeto BeautifulSoup, que transforma este código HTML sin formato en una estructura que puedes recorrer y analizar.
Siempre indica un analizador, por ejemplo "html.parser. BeautifulSoup interpreta entonces correctamente el HTML, sin mostrar ninguna advertencia. También puedes utilizar lxml, más rápido, que hay que instalar por separado.
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
El HTML es ahora un objeto BeautifulSoup. Puedes buscar y recuperar los datos que te interesen, etiqueta por etiqueta. Hay tres métodos que cubren la mayoría de las necesidades.
Usar find() y find_all()
encontrar() devuelve el primer elemento Encontrado. find_all() devuelve la lista completa los elementos correspondientes.
# 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"))
Selección de elementos por atributo
Puedes refinar la búsqueda según un atributo HTML, como clase, identificación o cualquier otro. Anotar : En Python, se escribe clase_ y no clase, para evitar el conflicto con la palabra reservada del lenguaje.
# Recuperar un elemento "div" con un identificador específico
contenedor = soup.find("div",)
# Obtener todos los enlaces con una clase específica
enlaces_nav = soup.find_all("a", class_="nav-link")
Usar selectores CSS con select()
Para realizar búsquedas más precisas, el método seleccionar() acepta Selectores CSS. Puedes seleccionar con precisión determinadas partes de una página, sin tener que revisar todo el código HTML manualmente.
# 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"]')
¿Cómo extraer datos de una tabla HTML con BeautifulSoup?
Los casos de uso reales suelen ser más complejos que simplemente recuperar un título o un enlace. Tendrás que gestionar el’extracción de datos estructurados al igual que las tablas y las listas, la paginación, y los errores más comunes en el scraping.
Extraer tablas y listas
Los sitios web suelen presentar sus datos en Tablas HTML (<table>, <tr>, <th>, <td>) o enumera (). Para convertir estas estructuras en datos que se puedan utilizar, debes recorrerlas línea por línea o elemento por elemento.
Para extraer un tabla HTMLEl principio es sencillo:
- Recuperar los encabezados (
<th>) para identificar los títulos de las columnas. - Recorrer cada línea (
<tr>) y buscar celdas (<td>) que contienen los datos. - Almacenar la información en una lista o en un diccionario.
Para un Lista HTML (
- Localizar todas las balizas
con find_all. - Recuperar su contenido (texto o enlace) y añadirlo a una lista de 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") recoge los encabezados y find_all("td") recoge las celdas de cada fila. Recorre las <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"]
Cada se transforma directamente en elemento de lista en Python, lo que da 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 distribuyen mediante enlaces de “página siguiente” o un paginación numerada (?página=1, ?página=2, etc.). En ambos casos, debes rizo para recuperar todas las páginas y fusionar los datos.
Ejemplo con un parámetro «page»:
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 paso a paso:
- Prepara el’URL con una plaza
{}para introducir el número de página.
BASE_URL = "https://bonjour.com/articles?page={}- Algunos sitios web bloquean las solicitudes que no incluyen la identidad del 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 Del 1 al 5.
para página en rango(1, 6):- Recupera el código HTML de la página con requests.
requests.get(url)- Limita el tiempo de espera si la página web no responde (tiempo de espera de 20 segundos).
requests.get(url, timeout=20)- Analiza la página con BeautifulSoup.
BeautifulSoup(response.text, "html.parser")- Recupera todos los títulos de artículos.
find_all("h2", class_="title")- Añade los artículos encontrados a una lista general.
all_articles.extend(artículos)- Introduce una romper entre cada solicitud para no sobrecargar el servidor y evitar que te bloqueen.
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 consiste simplemente en pulsar un botón. Te encontrarás con obstáculos frecuentes:
- Errores HTTP : 404 (página no encontrada), 403 (acceso prohibido) y 500 (error del servidor).
Ejemplo de gestión:
response = requests.get(url)
if response.status_code == 200:
print("Página recuperada correctamente")
elif response.status_code == 404:
print("Error: página no encontrada")
else:
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 solo lee el HTML estático. Si la página carga su contenido mediante JavaScript, no verás nada. En ese caso, debes utilizar una herramienta como Selenium Donde Playwright.
Para realizar un scraping eficaz sin que te bloqueen ni se dañe la página web, estas son las mejores prácticas:
- Respeta el archivo robots.txt de la página web que quieras analizar.
- Establece unas plazos entre las consultas con
time.sleep()para no sobrecargar el servidor. - Utiliza apoderados y haz que giren.
- Cambia regularmente tu User-Agent.
¿Cómo puedo scrapear la web con Selenium y BeautifulSoup?
Selenium controlar un navegador real, ejecuta el código JavaScript y muestra la página como si un usuario la estuviera navegando. BeautifulSoup A continuación, analiza el código HTML una vez que la página se haya cargado por completo y extraes todos los datos que quieras.
Paso 1: Instalar Selenium y BeautifulSoup
Aquí, en lugar de requests, utilizas Selenium para recuperar el contenido de la página. Instala las dos bibliotecas con este comando:
pip install selenium beautifulsoup4A continuación, tienes que descargar un WebDriver adaptado a la versión de tu navegador. Para Google Chrome, es ChromeDriver. Tienes dos opciones: colocarlo en la misma carpeta que tu script de Python, o el’añadir a la variable de entorno PATH de tu sistema.
Paso 2: Configuración de Selenium
Empieza por importar webdriver desde Selenium para controlar el navegador.
from selenium import webdriver
from selenium.webdriver.common.by import ByA continuación, abre un navegador. Es este el que abre la página y ejecuta el JavaScript, en este caso Chrome.
controlador = webdriver.Chrome()Indica al navegador cuál URL visitar.
driver.get("https://www.exemple.com")Si la página tarda en mostrar algunos elementos, puedes indicarle a Selenium que espere hasta 10 segundos.
driver.implicitly_wait(10)Paso 3: Recuperar el contenido de la página
Una vez que se haya cargado la página, obtienes el DOM completo : el código fuente HTML obtenido tras ejecutar el JavaScript.
html_content = driver.page_sourcePaso 4: Análisis HTML con BeautifulSoup
Ahora envía este código fuente a BeautifulSoup para 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
títulos = soup.find_all('h2')
for título in títulos:
print(título.get_text())BeautifulSoup ofrece métodos muy potentes como find(), find_all() y los selectores CSS para seleccionar y extraer elementos concretos del HTML.
Paso 5: Cerrar el navegador
Muy importante: cierra siempre el navegador después de ejecutar el programa para liberar recursos.
driver.quit()De este modo, combinas la potencia de Selenium para simular la navegación humana (clics, desplazamientos) con la eficacia de BeautifulSoup para el análisis de HTML. Es el método ideal para extraer datos de una página web que carga sus datos mediante JavaScript.
preguntas frecuentes
¿Cuál es la mejor herramienta para el web scraping en Python?
No hay ningún…’herramienta de raspado No hay una solución universal, sino soluciones adaptadas a tu proyecto. Estas son las tres más utilizadas:
- BeautifulSoup : sencillo y eficaz para analizar código HTML y extraer contenido rápidamente. Ideal si estás empezando o si tienes proyectos pequeños.
- Scrapy : un marco completo, diseñado para gestionar grandes volúmenes de datos con funciones avanzadas.
- Playwright : ideal para sitios web complejos generados mediante JavaScript. Simula un navegador real e interactúa con la página como lo haría una persona.
¿Cómo se utiliza BeautifulSoup para extraer el contenido de una etiqueta div?
Con BeautifulSoup, seleccionas una etiqueta concreta mediante un Selector CSS. Para extraer el contenido de una etiqueta <div>, sigue estos pasos.
1. Acceder a la página web con requests, y a continuación analizar el código HTML con BeautifulSoup.
from bs4 import BeautifulSoup
import requests
url = "URL_DE_TON_SITE" # Remplace par l'URL réelle
reponse = requests.get(url)
html_content = reponse.text
soup = BeautifulSoup(html_content, "html.parser")2. Utilizar el método seleccionar() con tu selector CSS para seleccionar la etiqueta <div>.
Para recuperar el primer elemento, utiliza sopa.seleccionar_uno. Para recuperar todos los elementos, utiliza sopa.seleccionar. A continuación se muestra un ejemplo de código HTML:
<div>
<h2>Titre de l'article</h2>
<p>Voici le contenu du paragraphe.</p>
</div>Y aquí tienes el ejemplo con el selector CSS div.artículo :
# Récupérer le premier div avec la classe "article"
div_article = soup.select_one("div.article")
# Afficher son contenu texte
if div_article:
print(div_article.get_text(strip=True))3. Extraer los elementos que hay dentro de la <div>.
# Récupérer le titre à l'intérieur du div
titre = soup.select_one("div.article h2").get_text()
# Récupérer le paragraphe à l'intérieur du div
paragraphe = soup.select_one("div.article p").get_text()
print("Titre :", titre)
print("Paragraphe :", paragraphe)¿Cómo pueden utilizarse conjuntamente Requests y BeautifulSoup?
Estas dos bibliotecas son adicional : una descarga la página y la otra la analiza.
1. requests envía una solicitud HTTP y descarga el código HTML sin formato de la página.
import requests
url = "https://sitecible.com"
response = requests.get(url) # requête HTTP
print(response.text) # affiche le HTML brutEn este momento, solo tienes un texto enorme lleno de etiquetas (<html>, <div>, <p>etc.).
2. BeautifulSoup analiza este código HTML sin formato y lo transforma en una estructura organizada. A continuación, puedes navegar por la página, localizar las etiquetas y recuperar los datos.
from bs4 import BeautifulSoup
soup = BeautifulSoup(response.text, "html.parser") # analyse le HTML
titre = soup.find("h1").get_text() # extrait le contenu d'un <h1>
print(titre)¿Por qué mi código de web scraping no funciona en algunos sitios?
A veces puede ocurrir que tu script no recupere nada. Algunas páginas web no proporcionan todo su contenido directamente en HTML: utilizan JavaScript para cargar los datos de forma dinámica. Sin embargo, BeautifulSoup no sabe analizar los datos generados por JavaScript. En ese caso, debes recurrir a herramientas como Playwright Donde Selenium.
¿Qué papel desempeña BeautifulSoup en el web scraping?
BeautifulSoup desempeña el papel de’Analizador HTML. Convierte el código de una página en un objeto estructurado que puedes recorrer fácilmente. En pocas palabras, es el traductor entre el HTML sin formato y tu código Python.
Web scraping: ¿BeautifulSoup o Scrapy?
BeautifulSoup y Scrapy son realmente diferentes, aunque ambos sirvan para raspado web.
| BeautifulSoup | Scrapy |
|---|---|
| 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 y gestión de errores. |
BeautifulSoup es la opción perfecta para empezar: hace que el’Extracción de datos HTML en Python sencillo y rápido.
Si prefieres reducir al mínimo la parte de código, la herramienta Datos brillantes ofrece conjuntos de datos listos para usar con el fin de reducir la parte de programación.
Español