Extracción y Procesamiento de Texto desde Páginas Web con NLTK

Curso de Fundamentos de Procesamiento de Lenguaje Natural con Python y NLTK

Contenido del curso

Introducción al Procesamiento de Lenguaje Natural

Fundamentos con NLTK

Perspectivas de lo que viene

24
Fundamentos del Procesamiento del Lenguaje Natural con NLTK
03:16 min

Tomar examen

Cursos Empresas Blog Live Conf Eventos Precios

0:0013:36

Extracción y Procesamiento de Texto desde Páginas Web con NLTK

Curso de Fundamentos de Procesamiento de Lenguaje Natural con Python y NLTK

Clase 21 de 24

Clase 21 / 24

Recursos

¿Cómo extraer texto de una página web para procesamiento de lenguaje natural?

En el fascinante mundo del procesamiento del lenguaje natural (PLN), a menudo nos encontramos con la necesidad de trabajar con texto que no está previamente procesado. Muchas veces, estos textos provienen de fuentes como páginas web en formato HTML o TXT. Aprender a extraer y preprocesar adecuadamente esta información es esencial para cualquier proyecto de PLN. En este artículo exploramos cómo puedes lograrlo utilizando Python y algunas librerías especializadas.

¿Qué librerías principales se utilizan?

Cuando se quieren procesar datos no estructurados de la web, es fundamental contar con las herramientas adecuadas. Las librerías más utilizadas en este caso son:

NLTK: Esta librería es invaluable para tareas de tokenización y manejo de stopwords.
Punk: Útil para tokenizar texto.
Request de urllib: Permite acceder y descargar contenido de páginas web mediante peticiones HTTP.
BeautifulSoup: Ideal para manejar datos en formato HTML, facilitando la extracción de texto y la limpieza de estos documentos.
Expresiones regulares (re): Ayudan a limpiar y estructurar texto de acuerdo a patrones específicos.

¿Cómo extraer texto desde una URL?

El punto de partida para extraer texto desde una URL es realizar una petición a la página web utilizando urllib. A continuación, los pasos básicos:

Definir la URL: Una variable contendrá el enlace de la página de la que deseamos extraer información.
```
url = "tu_url_aqui"
```
Realizar la petición: Utilizaremos la función urlopen de la librería request para obtener el contenido de la página.
```
response = request.urlopen(url)
raw_text = response.read().decode('utf-8')
```
Proceder al procesamiento: Una vez que obtenemos el texto plano, podemos medir su longitud, tokenizarlo e identificar colocaciones importantes.

¿Cuáles son los pasos para tokenizar y limpiar el texto?

Una vez que hemos extraído el texto, el siguiente paso consiste en limpiarlo y segmentarlo de manera efectiva. Aquí te mostramos cómo hacerlo:

Tokenización básica: Utiliza word_tokenize de NLTK para dividir el texto en palabras o tokens.
```
tokens = nltk.word_tokenize(raw_text)
```
Extracción de colocaciones: Usa NLTK para encontrar bi-gramas o tri-gramas significativos en el texto.
```
text = nltk.Text(tokens)
text.collocations()
```
Limpieza con expresiones regulares: Esta técnica es crucial para eliminar caracteres no deseados y lograr tokens más limpios.
```
import re
tokens = re.findall(r'\w+', raw_text)
```

¿Cómo manejar y extraer texto de un archivo HTML?

Para trabajar con archivos HTML, se recomienda la librería BeautifulSoup, la cual permite estructurar y limpiar eficientemente el contenido. Estos son los pasos esenciales:

Realizar la petición: Similar a un archivo TXT, se necesita extraer el contenido HTML con requests.get.
```
response = requests.get(url)
html = response.text
```
Parsear con BeautifulSoup: Convierte el texto en una estructura navegable forma y elimina etiquetas HTML innecesarias.
```
soup = BeautifulSoup(html, 'html.parser')
text = soup.get_text()
```
Tokenización y limpieza: Utiliza expresiones regulares para segmentar el texto.
```
tokens = re.findall(r'\w+', text)
```

¿Por qué es relevante el uso de expresiones regulares?

Las expresiones regulares son herramientas poderosas que facilitan la identificación de patrones complejos dentro del texto. Al definir patrones específicos, puedes extraer datos de manera más precisa, mejorar la calidad del tokenizado y eliminar ruido innecesario en el texto. Además, estas expresiones son altamente personalizables, lo que te permite adaptarlas a las particularidades de cada proyecto específico.

Ejercicio propuesto: Experimentación con expresiones regulares

Te invitamos a que experimentes mejorando las expresiones regulares utilizadas para el tokenizado de texto. Comparte tus resultados y reflexiones sobre cómo optimizaste el proceso en los comentarios para fomentar el aprendizaje colaborativo.

Explorar estas técnicas y herramientas te proveerá una base sólida para enfrentar los desafíos del procesamiento de textos en ambientes reales. Si también buscas profundizar en estas metodologías, considera explorar cursos relacionados como Ingeniería de Datos y Web Scraping. ¡Adelante, sigue aprendiendo y experimentando!

Gabriel Obregón

Hace un año

🧠Extracción de texto web para Procesamiento de Lenguaje Natural (PLN)

🌍 1. Concepto clave

El PLN necesita trabajar con texto sin procesar. Muchas fuentes provienen de páginas web (HTML o TXT). 👉 Objetivo: aprender a extraer y preprocesar información con Python para usarla en análisis lingüísticos.

⚙️ 2. Herramientas esenciales 🧰

🔹 NLTK → Tokenización y manejo de stopwords.

🔹 Punkt → Divide el texto en oraciones o palabras.

🔹 urllib.request → Descarga contenido web (HTTP).

🔹 BeautifulSoup → Limpia y extrae texto desde HTML.

🔹 re (Expresiones regulares) → Limpieza y detección de patrones.

💡 Estas librerías trabajan juntas para transformar texto web en datos analizables.

🔗 3. Extracción de texto desde una URL

Objetivo: obtener el texto plano de una página web.

🪜 Pasos principales:

1️⃣ Definir la URL

url = "tu_url_aqui"

2️⃣ Hacer la petición

from urllib import request

response = request.urlopen(url)

raw_text = response.read().decode('utf-8')

3️⃣ Procesar el texto

Mide la longitud.
Tokeniza el contenido.
Busca colocaciones (palabras frecuentes en conjunto).

🧩 Resultado: texto en bruto listo para limpieza y análisis.

✂️ 4. Tokenización y limpieza del texto

🎯 Propósito: dividir y depurar el texto para análisis lingüístico.

Pasos clave:

🪄 Tokenizar palabras

tokens = nltk.word_tokenize(raw_text)

🔍 Encontrar colocaciones

text = nltk.Text(tokens)

text.collocations()

🧽 Limpiar con expresiones regulares

import re

tokens = re.findall(r'\w+', raw_text)

✨ Con esto obtienes un texto sin símbolos ni ruido.

🧩 5. Extracción desde archivos HTML

🎯 Meta: obtener solo el texto útil de un documento HTML.

🚀 Pasos:

1️⃣ Solicitar el contenido

import requests

response = requests.get(url)

html = response.text

2️⃣ Parsear con BeautifulSoup

from bs4 import BeautifulSoup

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

text = soup.get_text()

3️⃣ Tokenizar y limpiar

tokens = re.findall(r'\w+', text)

📤 Ahora tienes texto puro, sin etiquetas ni código.

🧮 6. Importancia de las expresiones regulares

💡 Expresiones regulares (regex) = patrones que te permiten:

✅ Encontrar estructuras específicas.

✅ Limpiar texto con precisión.

✅ Eliminar ruido visual o caracteres especiales.

✅ Personalizar el análisis según el proyecto.

🧠 Son esenciales para transformar texto caótico en información útil.

Comentarios (24)24 comentarios

Facundo Nicolás García Martoni

Profesor

Hace 7 años

url 2 --> https://www.gutenberg.org/files/2701/2701-h/2701-h.htm

Andrés Lancheros

Hace 6 años

Para eliminar los signos de puntuación y los caracteres especiales es posible usar nltk.RegexpTokenizer

Jorge Sebastian Alvarez Herrera

Por si se les buguea NLTK como a mi

text = nltk.Text(tokens)
print('; '.join(text.collocation_list()))

Marcelo Sánchez

En mi caso uso la librería re y el método sub para quitar los controls string.

import re

url = 'http://www.gutenberg.org/files/2554/2554-0.txt'

response = request.urlopen(url)
raw = response.read().decode('utf8')
raw = re.sub('[\n\r]+', '', raw)
raw

Augusto Gonzalez

Hice un filtro fino para los token y asi me quedo:

filter_tokens = []
for token in tokens:
  tokenize = nltk.regexp_tokenize(token, pattern)
  if tokenize and len(tokenize[0]) > 2:
    filter_tokens.append(tokenize[0])

Bento Cussei

Hace 5 años

Una patron que me funciona muy bien es texto en ingles es este:

r'\w+|\S\w*'

Debido a que el idioma ingles tiene contracciones. Veamos un ejemplo:

texto = "I am big! It's the picture that got small."
print(re.findall(r'\w+', texto))

Salida: ['I', 'am', 'big', 'It', 's', 'the', 'picture', 'that', 'got', 'small']

Que pasó aqui? Perdi la información de la contracción It's además de las puntiaciones, que dependendo del analise que estamos haciendo sí puede ser importante. Ahora veamos el otro patrón:

texto = "I am big! It's the picture that got small."
print(re.findall(r'\w+|\S\w*', texto))

Salida: ['I', 'am', 'big', '!', 'It', "'s", 'the', 'picture', 'that', 'got', 'small', '.']

Que pasó aqui? Tengo las puntuaciones (ojo que no siempre son necesários). Pero tengo algo que sí es importante el 's . Cada vez que encuentro un token junto a este caracter ' puede indicar que esté ligado con el token anterior. Y así no pierdo la contracción.

Henry Mendiburu Díaz

!pip install -q html2text
import html2text

url = 'https://www.gutenberg.org/files/2701/2701-h/2701-h.htm'
r = requests.get(url)
html = r.text

text = html2text.html2text(html)
print(text)

Santiago Restrepo Escalante

pattern = r'''(?x)                  # Flag para iniciar el modo verbose
              (?:[A-Z]\.)+            # Hace match con abreviaciones como U.S.A.
              | \w+(?:-\w+)*         # Hace match con palabras que pueden tener un guión interno
              | \$?\d+(?:\.\d+)?%?  # Hace match con dinero o porcentajes como $15.5 o 100%
              | \.\.\.              # Hace match con puntos suspensivos
              | [][.,;"'?():-_`]    # Hace match con signos de puntuación
              
              '''

tokens = nltk.regexp_tokenize(raw, pattern)
tokens[:20]

Christian Sanclemente

[(word, fdist[word]) for word in set(token) if len(word)>3 and fdist[word]>3]

Luis Cardona

Me arrojaba error al correr el word_tokenizer, pidiendome descargar punkt_tab, lo descargué:

nltk.download('punkt_tab')

y ya con esto funcionó normal

Wilson Montenegro

Gracias si funciona, parece que ya se actualizo la librería y ahora tiene otros métodos.

Maria Guadalupe Gramajo

https://www.nltk.org/book/ch03.html En este enlace encontrarán el paso a paso del ejercicio por si lo necesitan

Carlos Andrés Pinilla Castillo

Hace 4 años

Crear estructura en NLTK que tiene montado procedimientos para agilizar el procesamiento.

Armando RC

No se si me equivoco pero el método de get_text() ya elimina las etiquetas de html, en mi experiencia al aplicar la expresión regular \w+ no me muestra los h1,h2,h3 como en el video.

Edilberto Christian Martín Matos Sánchez

Si es correcto lo que indicas. Igual a mi

Jhon Freddy Puentes Nuñez

URLs usadas:

url = 'http://www.gutenberg.org/files/2554/2554-0.txt'

url = 'https://www.gutenberg.org/files/2701/2701-h/2701-h.htm'

nice_tokens = [(word, freqdist[word]) for word in set(tokens) if len(word)>3 and freqdist[word]>5]
nice_tokens[:10]

Juan Jose Quiroga Torrez

existe algun procedimiento si quiero trabajar con un documento word con nltk???, especificamente quiero enfocarme a extraer lo que se genera con control de cambios

Alberto Perdomo

Word tiene su propio control de cambios ya incluido en las ultimas versiones:

https://support.microsoft.com/es-es/office/realizar-un-seguimiento-de-los-cambios-en-word-197ba630-0f5f-4a8e-9a77-3712475e806a.

Por otra parte estos son archivos binarios, significa que ademas de la información de texto en el archivo hay infomación de metadatos incluida. Se podria hacer un script con una filosofia similar al web scrapping para extraer la infromación de estos.

mi objetivo es que una vez que este generado un doc con control de cambios subir el doc para usar procesamiento de lenguaje natural para localizar esos cambios, y nose que herramienta o que procedimiento tengo que realizar para hacer esto

Sergio Fernandez

Hace 2 años

No funciona el link a dia de hoy

Diego Obed Lopez Casimiro

A mi si me funciono

Jhon Freddy Tavera Blandon


tokens_moby_dick = procesar_texto(url_moby_dick)
tokens_crimen_castigo = procesar_texto(url_crimen_castigo, encoding='utf-8-sig')

print(f"Número de tokens en 'Moby Dick': {len(tokens_moby_dick)}")
print(f"Tokens de 'Moby Dick' (muestra): {tokens_moby_dick[:50]}")

print(f"\nNúmero de tokens en 'Crimen y Castigo': {len(tokens_crimen_castigo)}")
print(f"Tokens de 'Crimen y Castigo' (muestra): {tokens_crimen_castigo[:50]}")

David Duque Uribe

Hace 3 años

Mejorando el tokenizado según lo aprendido en clases anteriores

pattern = r'''(?x)                  # Flag para iniciar el modo verbose
              (?:[A-Z]\.)+            # Hace match con abreviaciones como U.S.A.
              | \w+(?:-\w+)*         # Hace match con palabras que pueden tener un guión interno
              | \$?\d+(?:\.\d+)?%?  # Hace match con dinero o porcentajes como $15.5 o 100%
              | \.\.\.              # Hace match con puntos suspensivos
              | [][.,;"'?():-_`]    # Hace match con signos de puntuación
'''

tokens_1 = nltk.regexp_tokenize(raw, pattern)
print(tokens_1[:20])

Introducción al Procesamiento de Lenguaje Natural

Fundamentos del Procesamiento de Lenguaje Natural con Python y NLTK

Evolución y Técnicas del Procesamiento del Lenguaje Natural

Procesamiento del Lenguaje Natural con Python y NLTK

Fundamentos con NLTK

Procesamiento de Lenguaje Natural con Python en Google Colab

Expresiones Regulares en Python: Patrones de Búsqueda Avanzados

Tokenización de Texto con Expresiones Regulares en Python

Estadística para Procesamiento del Lenguaje: Riqueza Léxica y Métricas

Cálculo de frecuencias con NLTK y diccionarios en Python

Filtrado y Visualización de Frecuencias de Palabras con NLTK y NumPy

Estadísticas de Ennegramas y Colocaciones en Textos

Extracción de Ngramas y Bigramas con NLTK en Python

Análisis de Colocaciones con NLTK y Pandas en Python

Visualización de Colocaciones en Textos con Pandas y Plotly

Identificación de Colocaciones en Textos con NLTK y PMI

Recursos Léxicos: Uso y Aplicación en Procesamiento del Lenguaje

Recursos Léxicos en Python: Vocabularios, Frecuencias y Stopwords

Traducción de palabras con Swadesh en procesamiento de lenguaje natural

Uso de WarNet para Procesamiento del Lenguaje Natural

Análisis de Sinsets e Hipónimos con NLTK y WordNet en Google Colab

Medición de Similitud Semántica con WordNet en Python

Extracción y Procesamiento de Texto desde Páginas Web con NLTK

Organización de Código en Google Colab con Funciones y Módulos

Funciones y Buenas Prácticas en Google Colab y Python

Perspectivas de lo que viene

Fundamentos del Procesamiento del Lenguaje Natural con NLTK

Extracción y Procesamiento de Texto desde Páginas Web con NLTK

Progreso del curso

Introducción al Procesamiento de Lenguaje Natural

Fundamentos con NLTK

Perspectivas de lo que viene

Recursos

Recursos