Tokenización de Texto con Expresiones Regulares en Python

Les dejo el patrón visto en clase, con explicaciones en español que hice 😄

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
'''

texto = """ Cuando sea el rey del mundo (imaginaba él en su cabeza) no tendré que  preocuparme por estas bobadas. 
            Era solo un niño de 7 años, pero pensaba que podría ser cualquier cosa que su imaginación le permitiera 
            visualizar en su cabeza ...""" 

En lugar de usar [\t\n]+ para definir un rango de espacios, tabs, etc. pueden usar el metacaracter \s, específicamente diseñado para reconocer diferentes clases de espacios 😉

El metacaracter \W lo que hace es hacer match con todo lo que no sea un caracter alfanumérico (como paréntesis, símbolos raros, etc.)

Más o menos así me sentí en el minuto 8:20

texto = 'En los E.U. esa postal vale $15.50 ...'

Normalización de texto (como aplicación de las expresiones regulares)

# Imprimimos el texto con un salto de linea
print('esta es \n una prueba')

# Forzamos a Python a que nos imprima el texto como texto plano a pesar de los caracteres especiales como el salto de linea. 
print(r'esta es \n una prueba')

Tokenización: Es el proceso mediante el cual se sub-divide una cadena de texto en unidades lingüísticas mínimas (palabras)

# Ejemplo: 

texto = """ Cuando sea el rey del mundo (imaginaba él en su cabeza) no tendré que  preocuparme por estas bobadas. 
            Era solo un niño de 7 años, pero pensaba que podría ser cualquier cosa que su imaginación le permitiera 
            visualizar en su cabeza ...""" 
# Caso 1: Tokenizar por espacios vacíos
print(re.split(r' ',texto))
# Caso 2: Tokenizar usado expresiones regulares usando regex
print(re.split(r'[ \t\n]+', texto))
# Caso 3: Usando el parámetro W
print(re.split(r'[ \W\t\n]+', texto))

Tokenizando con NLTK

texto = 'En los E.U. esa postal vale $15.50 ...'
print(re.split(r'[ \W\t\n]+', texto))

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
              '''
nltk.regexp_tokenize(texto, pattern)

Excelente clase!.
Creo que cabe aclarar que la primer expresión regular “[ \W\t\n]+” se enfocaba en buscar:

• espacios.
• espacios de TAB
• finales de linea y caracteres que no fuesen palabras, números o puntos.
  Y dividir en donde hiciera match.
  Pero la segunda expresión regular “(?x) ...” se enfocaba hacer match con la palabras, frases y/o expresiones.

Tokenización con expresiones regulares

Python no interpreta el texto raw por defecto, si no que admite cosas espciales como tabs con \t o enters con \n. Podemos indicarle que lea solo raw:

print('Esta es \n una prueba')
print(r'Esta es \n otra prueba')

Tokenización: Es el proceso mediante el cual se sub-divide una cadena de texto en unidades linguísticas minimas (palabras)

texto = """ Cuando sea el rey del mundo (imaginaba él en su cabeza) no tendré que  preocuparme por estas bobadas.
						Era solo un niño de 7 años, pero pensaba que podría ser cualquier cosa que su imaginación le permitiera
						visualizar en su cabeza ..."""

Caso 1: Tokenizar por espacios vacíos. Aquí hay ruido, caracteres que no son parte de las palabras y queremos remover.

print(re.split(r' ', texto))

Caso 2: Tokenizador usando expresiones regulares

print(re.split(r'[ \W\t\n]+', texto))

Tokenizador de NLTK

Si usamos lo anterior, nos ignora abreviaciones, precios, como esto:

texto = 'En los E.U. esa postal vale $15.50 ...'
print(re.split('[ \W\t\n]+', texto))

Para poder considerar esto, debemos usar expresiones regulares mucho más complejas, como esta:

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
						'''

nltk.regexp_tokenize(texto, pattern)

Diablos, ahora otro curso a la lista de pendientes… Por qué elegí esta carrera? Jaja!

Un sitio web con un repositorio de patrones regex (Regex Repository)

https://owasp.org/www-community/OWASP_Validation_Regex_Repository

Esta linea:

| \.\.\. 

Puede ser represantado de la siguiente forma:

| \.{3,3}

Tambien se podria hacer asi:

print(re.split(r'[\b\W+\b]+', texto))

NLTK puede tokenizar por palabras directamente el útlimo ejemplo (el que tiene trampas para el regex).

nltk.tokenize.word_tokenize(texto, language="Spanish", preserve_line=True)

Me parece mucho más limpio que definir esa regex que no cubre todos los casos.

Tokenizador avanzado

import re
with open('texto_rey.txt', 'r', encoding =  'utf-8') as f:
    flatten = (re.findall(r',+|\.+|\w+|\(.+ ?\)', f.read()))
    print(flatten)

la subo antes de ver el ejercicio, mi método: Primero busqué literalmente la frase entre paréntesis abstrayendo cada elemento y así sucesivamente con el ‘o’ inclusivo.

ER para reconocer caracteres muy especiales

No se sí notaron pero con el texto inical la tokenización deja los parentesis como parte del arreglo. Digo por si acaso. 😉

Cual es el link de los notebooks?

por favor compartan los .ipynb correspondientes a cada clase

Buen curso

¿Cómo podría buscar **KEY: VALUE ** con una expresión regular en un invoice?