Expresiones Regulares con el Módulo re en Python

Las expresiones regulares en Python permiten el patrón avanzado de coincidencia, extracción y manipulación de texto. El módulo estándar re proporciona soporte completo para esta funcionalidad.

Metacaracteres Comunes

. (punto): Coincide con cualquier carácter excepto el salto de línea en modo normal. Con el flag DOTALL, incluye los saltos de línea.

import re
resultado1 = re.findall('f.*a', 'faf24\nfadfa', re.DOTALL)
resultado2 = re.findall('f.*a', 'faf24\nfadfa')
print(resultado1)  # Salida: ['faf24\nfadfa']
print(resultado2)  # Salida: ['faf24', 'fadfa']

^ (acento circunflejo): Coincide con el inicio de una cadena. En modo MULTILINE, también coincide con el enicio de cada línea.

texto = 'foo1\nfoo2\n'
res1 = re.findall('^foo.*', texto)
res2 = re.findall('^foo.*', texto, re.MULTILINE)
print(res1)  # Salida: ['foo1']
print(res2)  # Salida: ['foo1', 'foo2']

$ (signo de dólar): Coincide con el final de una cadena o con el último salto de línea. En modo MULTILINE, coincide con el final de cada línea.

ejemplo = 'foo1\nfoo2\n'
salida1 = re.findall('(foo.$)', ejemplo)
salida2 = re.findall('(foo.$)', ejemplo, re.MULTILINE)
print(salida1)  # Salida: ['foo2']
print(salida2)  # Salida: ['foo1', 'foo2']

* (asterisco): Repite el patrón anterier cero o más veces, con preferencia por el mayor número de coincidencias.

patron = 'ab*'
print(re.findall(patron, 'bbb'))  # Salida: []
print(re.findall(patron, 'a'))    # Salida: ['a']
print(re.findall(patron, 'abbb')) # Salida: ['abbb']

+ (más): Repite el patrón anterior una o más veces, con preferencia por el mayor número.

print(re.findall('ab+', 'a'))    # Salida: []
print(re.findall('ab+', 'abbb')) # Salida: ['abbb']

? (interrogación): Repite el patrón anterior cero o una vez.

print(re.findall('ab?', 'a'))    # Salida: ['a']
print(re.findall('ab?', 'abbb')) # Salida: ['ab']
# Para números decimales
nums = re.findall(r'\d+\.?\d*', 'texto123 con 1.56 y 42')
print(nums)  # Salida: ['123', '1.56', '42']

*?, +?, ??: Versiones no codiciosas que coinciden con el menor número posible de caracteres.

html_tag = '<h1>título</h1>'
print(re.findall('<(.*)>', html_tag))   # Salida: ['H1>título', html_tag))  # Salida: ['H1', '/H1']

Expresiones Extendidas

(?...): Extensiones que modifican el comportamianto. Por ejemplo, (?i) ignora mayúsculas y minúsculas.

texto_mixto = 'Hello hello'
coincidencias = re.findall('(?i)hello', texto_mixto)
print(coincidencias)  # Salida: ['Hello', 'hello']

(?:...): Agrupación sin captura.

ejemplo = 'abc123'
resultado = re.findall(r'(?:\d+)([a-z]+)', ejemplo)
print(resultado)  # Salida: ['abc']

(?P<nombre>...): Grupos con nombre para referencias legibles.

cadena = '2023-10-05'
match = re.match(r'(?P<año>\d{4})-(?P<mes>\d{2})-(?P<día>\d{2})', cadena)
if match:
    print(match.group('año'))  # Salida: '2023'

Secuencias Especiales

\d: Coincide con dígitos (equivalente a [0-9] en modo no Unicode).

\w: Coincide con caracteres alfanuméricos y guiones bajos.

\s: Coincide con caracteres en blanco.

Funciones del Módulo re

re.compile(pattern[, flags]): Compila una expresión regular en un objeto regex para reutilización eficiente.

patron_compilado = re.compile(r'\b\w{4}\b')
cadena = 'Este es un texto ejemplo'
print(patron_compilado.findall(cadena))  # Salida: ['Este', 'texto']

re.search(pattern, string[, flags]): Busca la primera coincidencia en la cadena.

busqueda = re.search(r'\d+', 'abc123def')
if busqueda:
    print(busqueda.group())  # Salida: '123'

re.match(pattern, string[, flags]): Coincide solo al inicio de la cadena.

coincidencia = re.match(r'Hola', 'Hola mundo')
print(coincidencia.group() if coincidencia else None)  # Salida: 'Hola'

re.findall(pattern, string[, flags]): Devuelve todas las coincidencias como una lista.

lista = re.findall(r'\d+', 'num1 2 num3')
print(lista)  # Salida: ['1', '2', '3']

re.sub(pattern, repl, string[, count]): Reemplaza coincidencias.

nuevo_texto = re.sub(r'old', 'new', 'old string with old words')
print(nuevo_texto)  # Salida: 'new string with new words'

Objetos Regex y de Coincidencia

Los objetos compilados (regex) tienen métodos como match() y search(). Los objetos de coincidencia (Match) permiten acceder a grupos y posiciones.

regex = re.compile(r'(\w+) (\w+)')
match = regex.match('John Doe')
if match:
    print(match.group(1))  # Salida: 'John'
    print(match.groups())  # Salida: ('John', 'Doe')

Ejercicios Prácticos

1. Validar contraseña con al menos una mayúscula, una minúscula, un dígito y un carácter especial, longitud mínima 6.

contraseña = 'Abc123!'
if re.search(r'(?=.*[A-Z])(?=.*[a-z])(?=.*\d)(?=.*[!@#$%^&*]).{6,}', contraseña):
    print('Contraseña válida')

2. Extraer fechas en formato AAAA-MM-DD de un texto.

texto_fecha = 'Evento el 2023-10-05 y otro el 2024-01-15.'
fechas = re.findall(r'\d{4}-\d{2}-\d{2}', texto_fecha)
print(fechas)  # Salida: ['2023-10-05', '2024-01-15']

Etiquetas: Python Regex re-module metacaracteres expresiones-regular

Publicado el 7-3 16:45

Friki Work