Introducción al Procesamiento de Lenguaje Natural

1

Procesamiento de Lenguaje Natural con Python y NLTK

2

Creación de chatbots con NLTK y spaCy

3

Procesamiento de Texto con NLTK en Python

Fundamentos con NLTK

4

Procesamiento de Texto en Python con Expresiones Regulares

5

Expresiones Regulares: Patrones de Búsqueda en Texto

6

Tokenización de texto con expresiones regulares en Python

7

Estadísticas en Procesamiento de Lenguaje Natural con Python

8

Diccionarios y Frecuencia de Palabras en Python

9

Análisis de texto con NLTK: Filtrado y visualización de frecuencia

10

Análisis de Ennegramas y Colocaciones en Textos

11

Extracción de N-gramas y Agregación de Frecuencias con NLTK

12

Identificación estadística de colocaciones en textos usando Pandas y NLTK

13

Análisis de Bigramas con Plotly: Visualiza Frecuencias y PMI

14

Extracción de colocaciones en textos usando NLTK

15

Recursos Léxicos en Procesamiento de Lenguaje Natural

16

Recursos Léxicos en Python: Vocabularios y Stopwords

17

Traducción de Palabras con Swadesh en Python

18

Sinsets y su uso en Procesamiento de Lenguaje Natural

19

Sinsets: Uso de WordNet en Python para manejo de sinónimos

20

Medición de Similitud Semántica con WordNet

21

Extracción y preprocesamiento de texto en páginas web HTML

22

Funciones Modulares en Google Colab: Organiza Tu Código Eficientemente

23

Procesamiento de texto con expresiones regulares en Python

Perspectivas de lo que viene

24

Modelos de Clasificación de Texto: Análisis de Sentimientos

No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Procesamiento de texto con expresiones regulares en Python

23/24
Recursos

¿Cómo crear funciones reutilizables en Google Colab?

A medida que te adentras en el mundo de la programación y procesamiento de textos, emplear librerías como NLTK, Matplotlib y otras es fundamental para obtener distintas perspectivas a la hora de analizar textos. Sin embargo, al trabajar en Google Colab, escribir código celda por celda puede parecer desordenado. Así que, ¡es tiempo de ordenar el caos! Aprende a definir funciones que podrás reutilizar en distintos proyectos, ¡haciendo tu código más limpio y eficiente!

¿Por qué compartimentar el código?

Trabajar en un entorno como Google Colab a menudo lleva a perder la noción de mantener un código organizado. Esto es normal, pero no debe convertirse en un hábito. Utilizar funciones para compartimentar el código es clave para:

  • Facilitar la reutilización del código en diferentes proyectos.
  • Ahorrar espacio y mantener tu notebook más ordenado.
  • Potenciar buenas prácticas de programación.

¿Cómo crear y utilizar funciones en Python?

La simplicidad es clave cuando defines tus propias funciones. Vamos a ilustrar esto con un ejemplo práctico:

Implementar la función get_text

Esta función realizará un procesamiento de texto a partir de un archivo almacenado en Google Drive usando expresiones regulares.

import re

def get_text(file):
    with open(file, 'r') as f:
        text = f.read()
    text = re.sub(r'pattern1', '', text)
    text = re.sub(r'pattern2', '', text)
    return text

Con esta función, puedes leer un archivo, procesar su contenido y obtener un texto más limpio, todo en unas pocas líneas de código.

¿Cómo trasladar funciones a archivos externos?

¿Tienes varias funciones y no quieres llenar todo tu notebook? ¡Llévalas a un archivo Python externo! Utiliza las "magias" de Python para crear un archivo directamente en Google Colab:

!touch /ruta/a/tu/directorio/mifuncion.py

Luego, copia y pega tu función en ese nuevo archivo. Esto te permitirá importar y usar tu función como si fuera una librería:

import sys
sys.path.append('/ruta/a/tu/directorio')
import mifuncion

mifuncion.get_text('/ruta/al/archivo.txt')

¿Cómo crear la función freckWords?

Apliquemos estas habilidades en un ejercicio práctico creando una función que retorne las palabras más comunes de un texto almacenado en una URL:

from nltk import FreqDist
from bs4 import BeautifulSoup
import requests

def freckWords(url, n):
    response = requests.get(url)
    raw = response.text
    soup = BeautifulSoup(raw, 'html.parser')
    text = soup.get_text()
    tokens = text.split()
    fd = FreqDist(tokens)
    return fd.most_common(n)

Implementa esta función en un archivo externo, y luego impórtalo en tu notebook para disfrutar de un código organizado y eficiente.

Conclusión

Crear funciones reutilizables y organizadas es una parte esencial en el desarrollo de un código limpio y eficiente. No solo ayuda a mantener estructura, sino que también maximiza tu productividad al simplificar el manejo del código. Con práctica, estas habilidades transformarán tu forma de programar en un entorno colaborativo como Google Colab. ¡Continúa explorando y mejorando, tus proyectos te lo agradecerán!

Aportes 15

Preguntas 2

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

Le agregue tambien que eliminara los signos de puntuacion y los stopwords, ya que sin eso los primeros 20 que tienen mas frecuencia son signos de puntuacion y stopwords.

from urllib import request
import re
from bs4 import BeautifulSoup
import nltk
from nltk import word_tokenize
from string import punctuation
from nltk.corpus import stopwords

def get_text(file):
  #Read text from file...
  text = open(file).read()
  text = re.sub(r'<.*?', ' ', text)
  text = re.sub(r'\s+', ' ', text)
  return text

def freq_words(url, n):
  req = request.urlopen(url)
  html = req.read().decode('utf8')
  raw = BeautifulSoup(html, 'html.parser')
  stop_words = stopwords.words('english')
  text = raw.get_text()
  tokens = word_tokenize(text)
  tokens = [token.lower() for token in tokens]
  tokens = [token for token in tokens if token not in punctuation]
  tokens = [token for token in tokens if token not in stop_words]
  fd = nltk.FreqDist(tokens)
  return [t for (t, _) in fd.most_common(n)]

El signo de exclamación «!» en nuestro entorno de ejecución en Colab nos permite ejecutar comandos Bash como si lo hiciéramos desde nuestra línea de comandos local (o consola). Basta con añadir «!» delante de comando que queremos ejecutar en Colab. Dos ejemplos:

!git clone     #traernos nuestro proyecto desde GitHub a nuestro entorno de Google Colab 
!pip install    #Si necesitamos instalar con el gestor de paquetes pip de Python alguna librería que no venga preinstalada en Colab

Al hacer el ejercicio me encontré con varios problemas:

  1. Es necesario importar word_tokenize de nltk
  2. También se debe descargar el recurso ‘punkt’
  3. Cuando hacía cambios en el archivo que contenía el módulo, al volver a correr el import seguía teniendo errores porque realmente no se estaba actualizando la dependencia, como si quedara en algún tipo de caché. Para obligar a que cargara de nuevo fue necesario usar el siguiente código:
from importlib import reload
reload(freq_words)

Espero que pueda ayudar a algunos que estén varados

Tengo un tutorial que escribi en otro curso respecto a los python Magics, ojala les apoye en su formación

https://platzi.com/tutoriales/1794-pandas/6960-ipython-magics-commands/

![](

Muy buena estas dos clases.
Me ayuda un monton!

from urllib import request
from bs4 import BeautifulSoup

def freq_words(url, n, threshold):
  req = request.urlopen(url)
  html = req.read().decode('utf8')
  raw = BeautifulSoup(html, 'html.parser')
  text = raw.get_text()
  text = re.sub(r'<.*?>', ' ', text)
  text = re.sub(r'\s+', ' ', text)
  text = re.sub(r'function', ' ', text)
  text = re.sub(r'return', ' ', text)
  text = re.sub(r'target', ' ', text)
  text = re.sub(r'class', ' ', text)
  text = re.sub(r'sas_*', ' ', text)
  tokens = word_tokenize(text)
  tokens = [t.lower() for t in tokens if len(t) > threshold]
  fd = nltk.FreqDist(tokens)
  return [t for (t, _) in fd.most_common(n)]```

Wow genial, no conocía esta forma de trabajar con Google Collab!

Les dejo el codigo para usar si tienen que eliminar alguna libreria que hayan agregado por error

sys.path.remove('ruta de libreria a remover')

Espero les sirva

Estuvo muy genial este forma de trabajar en colab, al menos a mi me será muy funcional esta clase.
Gracias Francisco y Saludos!

### Ventajas del Código Estructurado: * **Reutilización**: Las funciones pueden ser reutilizadas fácilmente sin duplicar el código. * **Claridad**: El código es más legible y fácil de entender. * **Mantenimiento**: Si necesitas cambiar algo (como la forma en que montas Google Drive), solo cambias la función correspondiente sin afectar otras partes del código. ### Agregar Más Funciones Si tienes más tareas que realizar (como procesar datos, generar gráficos, etc.), puedes seguir encapsulándolas en funciones adicionales. Esto te permitirá mantener un flujo de trabajo modular y escalable.

Para los que estan trabajando en jupyter:
import re
def get_text(file):
text = open(file, “r”, encoding=“utf-8”).read()
text = re.sub(r’<.*?>’, ’ ‘, text)
text = re.sub(r’\s+’, ’ ', text)
return text

`AttributeError: module 'read' has no attribute 'get_text'` Buenos dias comunidad, Les comparto un error que tuve y como se arreglo (digo "se" arreglo, porque no entiendo el origen del error, asi que si alguien me ayuda..bienvenido). El primer archivo se llama read.py y el segundo read2.py. La cuestion es que el primer archivo tira el error y el segundo no. Internamente, ambos archivos son identicos (de hecho copie y pegue el primero en el segundo) ![](https://static.platzi.com/media/user_upload/Error-dc75f89e-4801-41a7-a225-9d300ef2f5ad.jpg) Atino a pensar que no puedo usar el nombre read! pero bueno, lo dejo por si le sirve a alguien mas

para los que usan Jupyter Notebook este es el codigo para crear archivos

!type nul >read.py
import nltk
from nltk import word_tokenize
from urllib import request
from bs4 import BeautifulSoup
nltk.download("punkt")
def freq_words(url, n, threshold):
	req = request.urlopen(url)
	html = req.read().decode('utf8')
	raw = BeautifulSoup(html, 'html.parser')
	text = raw.get_text()
	text = re.sub(r'<.*?>', ' ', text)
	text = re.sub(r'\s+', ' ', text)
	text = re.sub(r'function', ' ', text)
	text = re.sub(r'return', ' ', text)
	text = re.sub(r'target', ' ', text)
	text = re.sub(r'class', ' ', text)
	text = re.sub(r'sas_*', ' ', text)
	tokens = word_tokenize(text)
	tokens = [t.lower() for t in tokens if len(t) > 		threshold]
	fd = nltk.FreqDist(tokens)
	return [t for (t, _) in fd.most_common(n)]