Python

Tutorial Python: Tipos de selectores

Beautiful Soup y sus selectores permiten el scraping preciso en HTML. Aprende a usarlos eficazmente para extraer y manipular datos en Python.

Selectores por etiquetas (tag)

Los selectores por etiquetas permiten extraer elementos HTML específicos basándose en el nombre de la etiqueta. Este método es fundamental para navegar por el árbol DOM y acceder a contenidos concretos de una página web.

Para encontrar la primera ocurrencia de una etiqueta, se utiliza el método find(). Por ejemplo, para obtener el primer encabezado <h1> de un documento:

from bs4 import BeautifulSoup

html = '''
<html>
  <body>
    <h1>Página de ejemplo</h1>
    <p>Este es un párrafo.</p>
    <h1>Otro encabezado</h1>
  </body>
</html>
'''

soup = BeautifulSoup(html, 'html.parser')
encabezado = soup.find('h1')
print(encabezado.text)  # Salida: Página de ejemplo

Si se requiere obtener todas las etiquetas de un tipo específico, se utiliza el método find_all(). Este método devuelve una lista con todas las ocurrencias encontradas:

encabezados = soup.find_all('h1')
for idx, h1 in enumerate(encabezados, start=1):
    print(f'Encabezado {idx}: {h1.text}')
# Salida:
# Encabezado 1: Página de ejemplo
# Encabezado 2: Otro encabezado

Además de find() y find_all(), es posible acceder directamente a las etiquetas como atributos del objeto BeautifulSoup. Sin embargo, solo devuelve la primera coincidencia y es más adecuado para etiquetas únicas como <title>:

html = '''
<html>
  <head>
    <title>Documento de prueba</title>
  </head>
  <body>
    <p>Contenido del documento.</p>
  </body>
</html>
'''

soup = BeautifulSoup(html, 'html.parser')
titulo = soup.title
print(titulo.text)  # Salida: Documento de prueba

Es importante tener en cuenta que los selectores por etiquetas son sensibles al nombre de la etiqueta, por lo que debe coincidir exactamente con el del documento HTML. Esto facilita la búsqueda cuando se conoce de antemano la estructura del HTML que se está analizando.

Cuando se trabaja con documentos más complejos, se puede combinar el uso de selectores por etiquetas con otros métodos para navegar jerárquicamente por el árbol DOM:

div_contenido = soup.find('div')
parrafos = div_contenido.find_all('p')
for p in parrafos:
    print(p.text)

En este ejemplo, se busca la primera etiqueta <div> y luego se extraen todos los párrafos <p> que contiene. Esto permite refinar la búsqueda y obtener elementos dentro de un contexto específico.

El uso de selectores por etiquetas es importante para extraer información estructurada y es el primer paso para manipular y analizar documentos HTML con Beautiful Soup.

Selectores por atributos y clases (class, id)

En Beautiful Soup, los selectores por atributos y clases permiten localizar etiquetas HTML basándose en los valores de sus atributos, especialmente class e id. Estos selectores son fundamentales para extraer información específica cuando las etiquetas poseen clases o identificadores asignados, una práctica común en páginas web modernas.

Para encontrar una etiqueta con una clase específica, se utiliza el método find() o find_all(), pasando el nombre de la clase mediante el parámetro class_. Por ejemplo, para obtener todos los párrafos con la clase resaltado:

from bs4 import BeautifulSoup

html = '''
<html>
  <body>
    <p class="resaltado">Este es un párrafo resaltado.</p>
    <p>Este es un párrafo normal.</p>
    <p class="resaltado importante">Otro párrafo resaltado e importante.</p>
  </body>
</html>
'''

soup = BeautifulSoup(html, 'html.parser')
parrafos_resaltados = soup.find_all('p', class_='resaltado')

for p in parrafos_resaltados:
    print(p.text)
# Salida:
# Este es un párrafo resaltado.
# Otro párrafo resaltado e importante.

Es importante notar que si una etiqueta tiene múltiples clases, el selector coincidirá si contiene la clase especificada, independientemente de las demás clases asociadas.

Para seleccionar elementos por su atributo id, se sigue un procedimiento similar. Por ejemplo, para encontrar un elemento con id="principal":

html = '''
<html>
  <body>
    <div id="principal">
      <h1>Página Principal</h1>
      <p>Bienvenido a la página principal.</p>
    </div>
    <div id="secundario">
      <p>Esta es una sección secundaria.</p>
    </div>
  </body>
</html>
'''

soup = BeautifulSoup(html, 'html.parser')
div_principal = soup.find('div', id='principal')
print(div_principal.h1.text)
# Salida: Página Principal

Al utilizar el atributo id, aseguramos la unicidad del elemento seleccionado, ya que los identificadores deben ser únicos dentro de un documento HTML.

Además de class e id, es posible buscar por otros atributos utilizando el parámetro attrs, donde se pasa un diccionario con los pares atributo-valor deseados. Por ejemplo, para encontrar enlaces con un atributo name específico:

html = '''
<html>
  <body>
    <a href="https://ejemplo.com" name="inicio">Inicio</a>
    <a href="https://ejemplo.com/contacto" name="contacto">Contacto</a>
  </body>
</html>
'''

soup = BeautifulSoup(html, 'html.parser')
enlace_contacto = soup.find('a', attrs={'name': 'contacto'})
print(enlace_contacto['href'])
# Salida: https://ejemplo.com/contacto

Esta técnica permite refinar las búsquedas y extraer elementos con atributos personalizados, lo cual es útil en páginas con estructuras complejas.

Cuando se necesita buscar elementos con múltiples clases, se puede proporcionar una lista de clases al parámetro class_:

html = '''
<html>
  <body>
    <span class="etiqueta importante">Etiqueta Importante</span>
    <span class="etiqueta">Etiqueta Normal</span>
    <span class="etiqueta destacada importante">Etiqueta Destacada e Importante</span>
  </body>
</html>
'''

soup = BeautifulSoup(html, 'html.parser')
etiquetas_importantes = soup.find_all('span', class_=['etiqueta', 'importante'])

for etiqueta in etiquetas_importantes:
    print(etiqueta.text)
# Salida:
# Etiqueta Importante
# Etiqueta Destacada e Importante

En este caso, se seleccionan las etiquetas que contienen ambas clases especificadas, lo que permite una búsqueda más precisa.

Para realizar búsquedas más avanzadas, es posible utilizar expresiones regulares en los valores de los atributos:

import re

enlaces = soup.find_all('a', href=re.compile(r'^https://'))

for enlace in enlaces:
    print(enlace['href'])
# Salida:
# https://ejemplo.com
# https://ejemplo.com/contacto

Mediante el uso de expresiones regulares, capturamos todos los enlaces cuyo atributo href comienza con https://.

Otra funcionalidad útil es emplear funciones anónimas (lambdas) para definir criterios de búsqueda más complejos:

def tiene_datos(tag):
    return tag.has_attr('data-info') and tag.name == 'div'

divs_con_datos = soup.find_all(tiene_datos)

for div in divs_con_datos:
    print(div['data-info'])

Con este enfoque, podemos personalizar completamente las condiciones bajo las cuales se seleccionan los elementos.

Finalmente, es posible combinar diferentes criterios de búsqueda para lograr una mayor especificidad:

elemento_especifico = soup.find('span', class_='destacada', id='especial', attrs={'data-tipo': 'importante'})
print(elemento_especifico.text)

Esta búsqueda selecciona un <span> con la clase destacada, el id especial y un atributo data-tipo con valor importante.

Uso de selectores CSS para búsquedas avanzadas

En Beautiful Soup, los selectores CSS permiten realizar búsquedas más precisas y flexibles dentro del árbol HTML. Estos selectores son familiares para quienes conocen el desarrollo web, ya que utilizan la misma sintaxis que se emplea en las hojas de estilo CSS para identificar elementos específicos en una página.

Para utilizar selectores CSS en Beautiful Soup, se emplea el método select() para obtener una lista de elementos que coinciden con el selector, o select_one() para obtener solo el primero que coincide. Por ejemplo:

from bs4 import BeautifulSoup

html = '''
<html>
  <body>
    <div class="contenedor">
      <ul id="lista">
        <li class="item">Elemento 1</li>
        <li class="item destacado">Elemento 2</li>
        <li class="item">Elemento 3</li>
      </ul>
    </div>
  </body>
</html>
'''

soup = BeautifulSoup(html, 'html.parser')

# Seleccionar todos los elementos con la clase 'item'
items = soup.select('.item')
for item in items:
    print(item.text)

# Salida:
# Elemento 1
# Elemento 2
# Elemento 3

En este ejemplo, utilizamos el selector .item para obtener todas las etiquetas que tienen la clase item. Es importante destacar que en los selectores CSS, las clases se indican con un punto (.) y los identificadores (id) con una almohadilla (#).

Si queremos seleccionar un elemento con un id específico, usamos el carácter # seguido del valor del identificador:

# Seleccionar el elemento con id 'lista'
lista = soup.select_one('#lista')
print(lista.name)  # Salida: ul

Los selectores CSS permiten combinar diferentes criterios para realizar búsquedas más sofisticadas. Por ejemplo, para seleccionar un <li> que tenga las clases item y destacado simultáneamente:

# Seleccionar elementos <li> con clases 'item' y 'destacado'
item_destacado = soup.select('li.item.destacado')
print(item_destacado[0].text)  # Salida: Elemento 2

Aquí, combinamos el nombre de la etiqueta con múltiples clases sin espacios entre ellas. Esto indica que buscamos elementos que posean todas las clases especificadas.

Para seleccionar elementos anidados, utilizamos los combinadores en los selectores. Por ejemplo, para obtener todos los <li> que son descendientes de un <ul> con id="lista":

# Seleccionar todos los <li> dentro del elemento con id 'lista'
items_lista = soup.select('#lista li')
for item in items_lista:
    print(item.text)
# Salida:
# Elemento 1
# Elemento 2
# Elemento 3

El espacio en el selector #lista li indica que buscamos todos los <li> que sean descendientes de #lista, sin importar el nivel de anidamiento.

Si deseamos seleccionar solo los hijos directos, utilizamos el símbolo >:

# Seleccionar los <li> que son hijos directos de '#lista'
items_directos = soup.select('#lista > li')

Los selectores CSS también permiten buscar elementos basándose en atributos. Por ejemplo, para seleccionar <li> con un atributo data-tipo igual a especial:

html = '''
<ul id="lista">
  <li data-tipo="normal">Elemento A</li>
  <li data-tipo="especial">Elemento B</li>
  <li data-tipo="normal">Elemento C</li>
</ul>
'''

soup = BeautifulSoup(html, 'html.parser')

# Seleccionar <li> con atributo data-tipo igual a 'especial'
item_especial = soup.select_one('li[data-tipo="especial"]')
print(item_especial.text)  # Salida: Elemento B

En este caso, empleamos el selector li[data-tipo="especial"] para filtrar elementos basándonos en el valor de un atributo personalizado.

Además, podemos utilizar operadores en los selectores de atributos para búsquedas más avanzadas. Por ejemplo, ^= busca atributos que empiezan con un valor determinado, $= busca los que terminan con un valor y *= busca los que contienen un valor específico:

html = '''
<div class="mensaje importante">Mensaje 1</div>
<div class="mensaje info">Mensaje 2</div>
<div class="mensaje alerta">Mensaje 3</div>
'''

soup = BeautifulSoup(html, 'html.parser')

# Seleccionar divs cuyas clases contengan la palabra 'importante'
mensajes_importantes = soup.select('div[class*="importante"]')
for mensaje in mensajes_importantes:
    print(mensaje.text)

# Salida:
# Mensaje 1

Aquí, el selector div[class*="importante"] obtiene los <div> cuya clase contiene la cadena "importante".

Los pseudo-clases como :nth-child() también son útiles para acceder a elementos en posiciones específicas. Para seleccionar el tercer <li> de una lista:

# Seleccionar el tercer elemento de la lista
tercer_item = soup.select_one('li:nth-child(3)')
print(tercer_item.text)  # Salida: Elemento 3

Esto es especialmente útil cuando la estructura HTML no proporciona identificadores o clases únicas para los elementos.

Es posible combinar múltiples selectores para afinar aún más las búsquedas. Por ejemplo, seleccionar todos los enlaces <a> que están dentro de un <div> con clase navegacion y que tienen una clase activo:

# Seleccionar enlaces activos dentro de la navegación
enlaces_activos = soup.select('div.navegacion a.activo')

Los selectores CSS ofrecen una manera eficiente de navegar y extraer información de documentos HTML complejos. Al familiarizarse con su sintaxis, se puede escribir código más conciso y mejorar la legibilidad de los scripts de scraping.

Es importante recordar que algunas características avanzadas de CSS3, como :has(), no están soportadas por Beautiful Soup debido a limitaciones en los analizadores subyacentes como lxml o html.parser. Por ello, es recomendable consultar la documentación oficial para conocer las capacidades y limitaciones al utilizar selectores CSS en Beautiful Soup.

Cuando los selectores CSS no son suficientes para ciertas tareas, se pueden complementar con métodos como find_all() o con funciones personalizadas que permitan filtrar los elementos de forma más específica.

Búsqueda con expresiones regulares

Las expresiones regulares ofrecen una forma flexible de buscar patrones en cadenas de texto. En Beautiful Soup, permiten realizar búsquedas más avanzadas al encontrar etiquetas, atributos o contenido que coincidan con patrones específicos. Para utilizarlas, es necesario importar el módulo re de la biblioteca estándar de Python.

Por ejemplo, para encontrar todas las etiquetas <a> cuyo atributo href comienza con https, se puede utilizar:

import re
from bs4 import BeautifulSoup

html = '''
<html>
  <body>
    <a href="http://ejemplo.com">Enlace 1</a>
    <a href="https://ejemplo.org">Enlace 2</a>
    <a href="ftp://ejemplo.net">Enlace 3</a>
  </body>
</html>
'''

soup = BeautifulSoup(html, 'html.parser')

enlaces_seguro = soup.find_all('a', href=re.compile('^https'))
for enlace in enlaces_seguro:
    print(enlace['href'])

# Salida:
# https://ejemplo.org

En este ejemplo, re.compile('^https') crea una expresión regular que coincide con cualquier cadena que comience con https. Al pasar esta expresión al parámetro href de find_all(), Beautiful Soup busca todas las etiquetas <a> cuyo atributo href coincida con el patrón definido.

También es posible utilizar expresiones regulares para buscar etiquetas basadas en su nombre. Si se desea encontrar todas las etiquetas que empiezan con la letra d, se puede hacer lo siguiente:

# Buscar todas las etiquetas cuyo nombre empieza con 'd'
etiquetas_d = soup.find_all(re.compile('^d'))
for etiqueta in etiquetas_d:
    print(etiqueta.name)

Este código encontrará etiquetas como <div>, <dl>, <dt>, etc. La expresión regular ^d indica que el nombre de la etiqueta debe comenzar con la letra d.

Para buscar elementos basados en el texto contenido, se utiliza el argumento string junto con una expresión regular:

# Encontrar todas las etiquetas que contienen la palabra 'Descargar'
descargas = soup.find_all(string=re.compile('Descargar'))
for texto in descargas:
    print(texto)

Este método buscará texto que coincida con el patrón en cualquier parte del contenido de las etiquetas, lo que es útil para localizar elementos por su contenido textual.

Las expresiones regulares también son útiles al buscar por atributos personalizados. Por ejemplo, si se desea encontrar todas las imágenes con formatos jpg o png:

# Buscar imágenes con extensión .jpg o .png
imagenes = soup.find_all('img', src=re.compile('\.(jpg|png)$'))
for img in imagenes:
    print(img['src'])

La expresión regular \.(jpg|png)$ busca cadenas que terminan con .jpg o .png, permitiendo filtrar las imágenes por su tipo de archivo.

Además, se pueden combinar expresiones regulares con funciones lambda para realizar búsquedas más complejas. Por ejemplo, para encontrar todas las etiquetas <li> cuya clase contiene la palabra activo:

# Buscar <li> con clase que contiene 'activo'
items_activos = soup.find_all('li', class_=lambda x: x and re.search('activo', x))
for item in items_activos:
    print(item.text)

En este caso, la función lambda evalúa si el atributo class_ contiene la cadena activo utilizando re.search(). Esto es útil cuando las clases de las etiquetas son múltiples y se necesitan patrones más específicos.

Es importante destacar que, para mejorar el rendimiento, es recomendable precompilar las expresiones regulares si se van a reutilizar en múltiples búsquedas:

patron_href = re.compile('^https')
enlaces_seguro = soup.find_all('a', href=patron_href)

La precompilación evita recompilar la expresión en cada iteración, optimizando el proceso de búsqueda.

Al trabajar con documentos HTML más complejos, las expresiones regulares permiten realizar búsquedas anidadas. Por ejemplo, para encontrar todas las etiquetas <span> dentro de un <div> con clase contenido que tengan un atributo data-id numérico:

# Buscar <span> dentro de <div class="contenido"> con data-id numérico
import re

div_contenido = soup.find('div', class_='contenido')
spans = div_contenido.find_all('span', attrs={'data-id': re.compile('^\d+$')})
for span in spans:
    print(span['data-id'])

La expresión regular ^\d+$ asegura que el data-id contenga solo dígitos, garantizando que el atributo es numérico.

También es posible buscar etiquetas cuyo texto coincida con un patrón específico. Si se necesita encontrar todas las etiquetas que contienen una fecha en formato dd/mm/yyyy:

# Buscar etiquetas con fechas en formato dd/mm/yyyy
fechas = soup.find_all(string=re.compile('^\d{2}/\d{2}/\d{4}$'))
for fecha in fechas:
    print(fecha)

Esta expresión regular ^\d{2}/\d{2}/\d{4}$ busca exactamente cadenas que representen fechas en el formato especificado.

El uso de expresiones regulares en Beautiful Soup es una herramienta invaluable para extraer información cuando los elementos HTML no tienen identificadores únicos o clases predecibles. Al dominar las expresiones regulares, se amplían las posibilidades de búsqueda y filtrado dentro de documentos HTML de estructura compleja o desconocida.

Selectores combinados y anidados para precisión

Al realizar web scraping con Beautiful Soup, a menudo es necesario refinar las búsquedas para extraer información específica de documentos HTML complejos. Los selectores combinados y anidados permiten aumentar la precisión en la extracción de datos, combinando múltiples criterios y aprovechando la estructura jerárquica del HTML.

Para combinar múltiples criterios en una búsqueda, se pueden utilizar los parámetros del método find() o find_all(). Por ejemplo, para encontrar todas las etiquetas <div> que tienen la clase "contenido" y un atributo data-tipo igual a "importante":

from bs4 import BeautifulSoup

html = '''
<div class="contenido" data-tipo="importante">
    <p>Artículo destacado</p>
</div>
<div class="contenido" data-tipo="normal">
    <p>Artículo regular</p>
</div>
'''

soup = BeautifulSoup(html, 'html.parser')

divs_importantes = soup.find_all('div', class_='contenido', attrs={'data-tipo': 'importante'})

for div in divs_importantes:
    print(div.p.text)
# Salida: Artículo destacado

En este ejemplo, combinamos el selector por clase (class_='contenido') con un selector por atributo (attrs={'data-tipo': 'importante'}) para obtener resultados más precisos.

Además, es posible anidar búsquedas para navegar por la estructura del documento. Primero se encuentra un elemento padre y luego se busca dentro de él. Por ejemplo, para encontrar todos los enlaces dentro de un <div> con id="menu":

html = '''
<div id="menu">
    <ul>
        <li><a href="/inicio">Inicio</a></li>
        <li><a href="/contacto">Contacto</a></li>
    </ul>
</div>
<div id="contenido">
    <a href="/privacidad">Política de Privacidad</a>
</div>
'''

soup = BeautifulSoup(html, 'html.parser')

menu = soup.find('div', id='menu')
enlaces_menu = menu.find_all('a')

for enlace in enlaces_menu:
    print(enlace['href'])
# Salida:
# /inicio
# /contacto

Aquí, primero buscamos el <div> con id="menu" y luego, dentro de ese elemento, encontramos todos los <a> utilizando find_all(). Este enfoque anidado mejora la exactitud de la búsqueda al enfocarse en una sección específica del HTML.

Los selectores CSS también se pueden combinar para búsquedas más detalladas. Por ejemplo, para seleccionar los elementos <li> que contienen un enlace activo:

html = '''
<ul class="navegacion">
    <li class="activo"><a href="/home">Home</a></li>
    <li><a href="/servicios">Servicios</a></li>
    <li class="activo"><a href="/contacto">Contacto</a></li>
</ul>
'''

soup = BeautifulSoup(html, 'html.parser')

items_activos = soup.select('ul.navegacion li.activo a')

for item in items_activos:
    print(item['href'])
# Salida:
# /home
# /contacto

En este caso, utilizamos un selector CSS combinado ul.navegacion li.activo a para obtener los enlaces dentro de elementos <li> con la clase "activo" que están dentro de una lista desordenada con clase "navegacion".

También es posible usar selectores descendientes y combinadores para especificar relaciones entre elementos. Por ejemplo, para seleccionar todas las etiquetas <span> que son hijas directas de un <p> con clase "destacado":

html = '''
<p class="destacado"><span>Texto 1</span></p>
<p class="destacado"><b><span>Texto 2</span></b></p>
<p><span>Texto 3</span></p>
'''

soup = BeautifulSoup(html, 'html.parser')

spans = soup.select('p.destacado > span')

for span in spans:
    print(span.text)
# Salida:
# Texto 1

Aquí, el selector p.destacado > span selecciona los <span> que son hijos directos de un <p> con clase "destacado". Como resultado, solo se obtiene "Texto 1" y se excluyen los <span> que están más profundamente anidados o en otros elementos.

Para búsquedas más complejas, se pueden combinar selectores con expresiones regulares. Por ejemplo, para encontrar todos los elementos cuya clase empieza con "btn-":

import re

html = '''
<button class="btn-primario">Aceptar</button>
<button class="btn-secundario">Cancelar</button>
<button class="enlace">Más información</button>
'''

soup = BeautifulSoup(html, 'html.parser')

botones = soup.find_all(class_=re.compile('^btn-'))

for boton in botones:
    print(boton.text)
# Salida:
# Aceptar
# Cancelar

La función re.compile('^btn-') crea una expresión regular que coincide con cualquier clase que empiece con "btn-". Esto permite seleccionar todos los botones independientemente de su tipo específico.

Otra técnica para alcanzar mayor precisión es utilizar funciones personalizadas en las búsquedas. Por ejemplo, para encontrar todas las etiquetas <meta> con atributo name cuyo valor contiene la palabra "description":

def es_meta_descripcion(tag):
    return tag.name == 'meta' and 'name' in tag.attrs and 'description' in tag['name']

metas = soup.find_all(es_meta_descripcion)

for meta in metas:
    print(meta['content'])

En este caso, definimos una función que verifica si una etiqueta es <meta>, tiene el atributo name, y si el valor de name contiene "description". Esto permite realizar búsquedas altamente específicas.

Anidar métodos de Beautiful Soup es otra forma de refinar búsquedas. Por ejemplo, para encontrar dentro de una sección específica todos los títulos de nivel 2 que tengan una clase particular:

html = '''
<section id="articulo">
    <h2 class="titulo">Introducción</h2>
    <p>Contenido de la introducción.</p>
    <h2>Desarrollo</h2>
    <p>Contenido del desarrollo.</p>
    <h2 class="titulo">Conclusión</h2>
    <p>Contenido de la conclusión.</p>
</section>
'''

soup = BeautifulSoup(html, 'html.parser')

seccion_articulo = soup.find('section', id='articulo')
titulos = seccion_articulo.find_all('h2', class_='titulo')

for titulo in titulos:
    print(titulo.text)
# Salida:
# Introducción
# Conclusión

Aquí, primero localizamos la <section> con id="articulo" y luego buscamos todos los <h2> dentro de esa sección que tienen la clase "titulo". Esto demuestra cómo la anidación de búsquedas mejora la precisión.

Para manejar estructuras HTML complejas, los selectores combinados y anidados son esenciales. Permiten construir consultas que reflejan la estructura real del documento, facilitando la extracción de información relevante.

Finalmente, es posible combinar diferentes tipos de selectores en una misma búsqueda. Por ejemplo, para encontrar enlaces externos en el pie de página:

html = '''
<footer>
    <a href="/aviso-legal">Aviso Legal</a>
    <a href="https://twitter.com/empresa" class="social">Twitter</a>
    <a href="https://facebook.com/empresa" class="social">Facebook</a>
</footer>
'''

soup = BeautifulSoup(html, 'html.parser')

enlaces_footer = soup.select('footer a.social[href^="https"]')

for enlace in enlaces_footer:
    print(enlace['href'])
# Salida:
# https://twitter.com/empresa
# https://facebook.com/empresa

En el selector footer a.social[href^="https"], combinamos selectores de etiqueta, clase y atributo con un operador de inicio (^=) para obtener los enlaces deseados. De esta manera, obtenemos únicamente los enlaces que apuntan a redes sociales externas.

Finalmente, el uso de selectores combinados y anidados en Beautiful Soup es fundamental para realizar búsquedas precisas y rápidas en documentos HTML. Al dominar estas técnicas, se puede extraer información específica incluso en estructuras web complejas.

Aprende Python GRATIS online

Ejercicios de esta lección Tipos de selectores

Evalúa tus conocimientos de esta lección Tipos de selectores con nuestros retos de programación de tipo Test, Puzzle, Código y Proyecto con VSCode, guiados por IA.

Polimorfismo

Puzzle

Clases y objetos

Beautiful Soup y sus selectores permiten el scraping preciso en HTML. Aprende a usarlos eficazmente para extraer y manipular datos en Python.

Selectores por etiquetas (tag)

Selectores por atributos y clases (class, id)

Uso de selectores CSS para búsquedas avanzadas

Búsqueda con expresiones regulares

Selectores combinados y anidados para precisión

Ejercicios de esta lección Tipos de selectores

Todas las lecciones de Python

Introducción Y Entorno

Introducción Y Entorno

Sintaxis

Sintaxis

Sintaxis

Sintaxis

Sintaxis

Programación Funcional

Programación Orientada A Objetos

Programación Orientada A Objetos

Programación Orientada A Objetos

Programación Orientada A Objetos

Programación Orientada A Objetos

Estructuras De Datos

Estructuras De Datos

Estructuras De Datos

Estructuras De Datos

Biblioteca Estándar

Biblioteca Estándar

Biblioteca Estándar

Biblioteca Estándar

Biblioteca Estándar

Paquetes Y Módulos

Paquetes Y Módulos

Web Scraping

Web Scraping

Web Scraping

Web Scraping

Web Scraping

Web Scraping

Web Scraping

Acceso A Bases De Datos

Certificados de superación de Python

Programación con Python

20h 0m

Ciencia de datos con Numpy con Python

15h 0m

Ciencia de datos con Pandas con Python

20h 0m

Objetivos de aprendizaje de esta lección