33- 🔍 RegEx en Python: Guía Básica para Principiantes

Acordeón de los Índices

Índice de los temas

• Python RegEx
• RegEx Module
• RegEx in Python
• RegEx Functions
• Metacharacters
• Flags
• Special Sequences
• Sets
• The findall() Function
• The search() Function
• The split() Function
• The sub() Function
• Match Object

---

Python RegEx

🔍 Python RegEx: Introducción a las Expresiones Regulares

Las expresiones regulares (RegEx) son una secuencia de caracteres que forman un patrón de búsqueda. Se utilizan para buscar, hacer coincidir y manipular texto basado en patrones específicos. Python tiene un módulo incorporado llamado re que permite trabajar con expresiones regulares.

Con RegEx, puedes realizar tareas como:

• Verificar si una cadena contiene un patrón específico.
• Extraer todas las ocurrencias de un patrón en una cadena.
• Reemplazar las ocurrencias de un patrón con otra cadena.
• Dividir una cadena en subcadenas basadas en un patrón.

Las expresiones regulares son increíblemente poderosas y se utilizan en una amplia variedad de aplicaciones, desde la validación de datos hasta el procesamiento de texto complejo. Por ejemplo, podrías usar RegEx para:

• Validar formatos de correo electrónico.
• Extraer números de teléfono de un documento.
• Buscar todas las menciones de una palabra clave en un texto.
• Reemplazar todas las instancias de una palabra por otra.

En los siguientes temas, exploraremos cómo utilizar el módulo re de Python y los diferentes componentes de las expresiones regulares.

RegEx Module

⚙️ El Módulo re: Tu Caja de Herramientas para RegEx

Como mencionamos anteriormente, Python incluye un módulo llamado re que proporciona las herramientas necesarias para trabajar con expresiones regulares. Para empezar a usarlo, simplemente necesitas importarlo al inicio de tu script:

      
import re
      
     

Una vez importado, el módulo re pone a tu disposición una serie de funciones poderosas para realizar diversas operaciones con expresiones regulares. Estas funciones te permiten desde buscar patrones específicos en cadenas de texto hasta realizar reemplazos complejos y dividir cadenas basadas en criterios definidos por tus patrones RegEx.

En los siguientes temas, exploraremos en detalle algunas de las funciones más importantes del módulo re y cómo utilizarlas eficazmente.

RegEx in Python

🐍 RegEx en Python: Primeros Pasos

Trabajar con expresiones regulares en Python generalmente sigue un patrón sencillo:

1. Importar el módulo re: Ya lo vimos, es el primer paso para acceder a las funcionalidades de RegEx.
2. Definir el patrón: El corazón de una expresión regular es el patrón que defines. Este patrón es una cadena de texto con una sintaxis especial que describe lo que estás buscando.
3. Usar una función del módulo re: El módulo re ofrece varias funciones para aplicar tu patrón a una cadena de texto. Las más comunes son search(), findall(), match(), split() y sub().
4. Analizar el resultado: La función que uses devolverá un resultado, que puede ser un objeto de coincidencia (si se encontró el patrón), una lista de cadenas (con todas las coincidencias), o la cadena modificada (después de un reemplazo o división).

Por ejemplo, si quisiéramos buscar la primera aparición de la palabra "Python" en una cadena, podríamos hacer lo siguiente:

      
import re

texto = "Python es un lenguaje de programación popular. Aprendiendo Python."
patron = "Python"

resultado = re.search(patron, texto)

if resultado:
    print("¡Se encontró 'Python'!")
    print("Posición:", resultado.start())
else:
    print("No se encontró 'Python'.")
      
     

En los próximos temas, profundizaremos en la creación de patrones más complejos y el uso de las diferentes funciones del módulo re.

RegEx Functions

🛠️ Funciones Esenciales del Módulo re

El módulo re nos brinda un conjunto de funciones poderosas para trabajar con expresiones regulares. Cada función está diseñada para un propósito específico en la búsqueda y manipulación de texto.

• search()

  Busca la primera ocurrencia del patrón en la cadena. Si la encuentra, devuelve un objeto de coincidencia; de lo contrario, devuelve None.

          
  import re
  
  texto = "La lluvia en Sevilla es una maravilla."
  patron = "Sevilla"
  resultado = re.search(patron, texto)
  
  if resultado:
      print(f"Se encontró '{patron}' en la posición: {resultado.start()}")
  else:
      print(f"No se encontró '{patron}'.")
          
         

• findall()

  Devuelve una lista con todas las coincidencias no superpuestas del patrón en la cadena. Si no hay coincidencias, devuelve una lista vacía.

          
  import re
  
  texto = "Manzana, banana, manzana, cereza."
  patron = "manzana"
  resultados = re.findall(patron, texto, re.IGNORECASE)
  print(f"Se encontraron: {resultados}")
          
         

• match()

  Intenta hacer coincidir el patrón al inicio de la cadena. Si la coincidencia tiene éxito, devuelve un objeto de coincidencia; de lo contrario, devuelve None. Solo busca al principio de la cadena.

          
  import re
  
  texto = "Hola mundo"
  patron = "Hola"
  resultado = re.match(patron, texto)
  
  if resultado:
      print(f"Coincidencia al inicio: {resultado.group()}")
  else:
      print("No hay coincidencia al inicio.")
          
         

• split()

  Divide la cadena en una lista de subcadenas, utilizando el patrón como delimitador.

          
  import re
  
  texto = "uno,dos,tres,cuatro"
  patron = ","
  resultados = re.split(patron, texto)
  print(f"Cadena dividida: {resultados}")
          
         

• sub()

  Reemplaza todas las ocurrencias del patrón en la cadena con una cadena de reemplazo.

          
  import re
  
  texto = "Reemplazar los espacios con guiones bajos."
  patron = r"\s+"
  reemplazo = "_"
  nueva_cadena = re.sub(patron, reemplazo, texto)
  print(f"Cadena modificada: {nueva_cadena}")
          
         

Estas funciones son la base para realizar operaciones complejas de búsqueda y manipulación de texto con expresiones regulares en Python. En los siguientes temas, exploraremos cómo construir patrones efectivos utilizando metacaracteres y secuencias especiales.

Metacharacters

✨ Metacaracteres: Los Ladrillos de tus Patrones RegEx

Los metacaracteres son caracteres especiales que tienen un significado predefinido en las expresiones regulares. En lugar de coincidir consigo mismos, controlan cómo se interpretan los patrones. Dominar los metacaracteres es crucial para construir expresiones regulares precisas y efectivas.

Aquí tienes una descripción detallada de algunos de los metacaracteres más comunes:

• [] (Conjunto de caracteres)

  Se utiliza para definir un conjunto de caracteres que deseas coincidir. Por ejemplo:

  • [aeiou] coincide con cualquier vocal minúscula.
  • [0-9] coincide con cualquier dígito del 0 al 9.
  • [a-zA-Z] coincide con cualquier letra mayúscula o minúscula.
  • [^0-9] coincide con cualquier carácter que NO sea un dígito (el ^ al principio niega el conjunto).

• . (Cualquier carácter)

  El punto coincide con cualquier carácter individual, excepto el carácter de nueva línea (\n) por defecto. Si quieres que coincida con la nueva línea también, puedes usar el flag re.DOTALL (o re.S).

• ^ (Comienzo de la cadena)

  Se utiliza para asegurar que la coincidencia ocurra al principio de la cadena.

• $ (Fin de la cadena)

  Se utiliza para asegurar que la coincidencia ocurra al final de la cadena.

• * (Cero o más ocurrencias)

  El asterisco después de un carácter (o un grupo) significa que ese carácter puede aparecer cero o más veces.

• + (Una o más ocurrencias)

  El signo más después de un carácter (o un grupo) significa que ese carácter debe aparecer una o más veces.

• ? (Cero o una ocurrencia)

  El signo de interrogación después de un carácter (o un grupo) significa que ese carácter puede aparecer cero o una vez.

• {} (Número específico de ocurrencias)

  Las llaves se utilizan para especificar el número exacto de veces que un carácter (o grupo) debe aparecer:

  • {n}: Exactamente n ocurrencias.
  • {n,}: n o más ocurrencias.
  • {n,m}: Entre n y m ocurrencias (ambos inclusive).

• | (Alternancia - OR lógico)

  La barra vertical se utiliza para especificar una de varias opciones. Por ejemplo, gato|perro coincide con "gato" o "perro".

• () (Grupo de captura)

  Los paréntesis se utilizan para agrupar una parte del patrón. Esto permite aplicar cuantificadores a un grupo completo y también capturar la parte de la cadena que coincide con el grupo para su posterior uso.

• \ (Barra invertida - Escape)

  La barra invertida se utiliza para "escapar" metacaracteres si quieres que coincidan literalmente. Por ejemplo, para buscar un punto literal, usarías \.. También se utiliza para crear secuencias especiales (que veremos en el siguiente tema).

Comprender cómo funcionan estos metacaracteres te permitirá construir patrones de búsqueda muy precisos y poderosos.

Flags

🚩 Flags: Modificando el Comportamiento de tus RegEx

Las flags, también conocidas como modificadores, son parámetros opcionales que puedes pasar a las funciones del módulo re para personalizar la forma en que se realizan las búsquedas de patrones. Estas flags pueden hacer que las coincidencias sean insensibles a mayúsculas y minúsculas, afectar cómo se interpretan los metacaracteres y mucho más.

Aquí tienes algunas de las flags más utilizadas en Python:

• re.IGNORECASE o re.I

  Esta flag hace que la coincidencia del patrón no distinga entre mayúsculas y minúsculas. Por ejemplo, el patrón "python" coincidirá con "Python", "PYTHON" y "python" si se usa esta flag.

          
  import re
  
  texto = "Python es diferente de PYTHON."
  patron = "python"
  resultado1 = re.search(patron, texto)
  resultado2 = re.search(patron, texto, re.IGNORECASE)
  
  print(f"Sin flag: {resultado1}")
  print(f"Con flag re.IGNORECASE: {resultado2}")
          
         

• re.DOTALL o re.S

  Por defecto, el metacaracter . coincide con cualquier carácter excepto la nueva línea (\n). La flag re.DOTALL hace que . coincida con todos los caracteres, incluyendo la nueva línea.

          
  import re
  
  texto = "primera línea\nsegunda línea"
  patron1 = r"."
  patron2 = r"."
  
  resultado1 = re.search(patron1, texto)
  resultado2 = re.search(patron2, texto, re.DOTALL)
  
  print(f"Sin flag (primer carácter): {resultado1.group()}")
  print(f"Con flag re.DOTALL (primer carácter): {resultado2.group()}")
          
         

• re.MULTILINE o re.M

  En el modo multilínea, las anclas ^ y $ coinciden con el inicio y el final de cada línea (no solo el inicio y el final de toda la cadena).

          
  import re
  
  texto = "línea uno\nlínea dos\nlínea tres"
  patron1 = r"^línea"
  patron2 = r"^línea"
  
  resultado1 = re.findall(patron1, texto)
  resultado2 = re.findall(patron2, texto, re.MULTILINE)
  
  print(f"Sin flag re.MULTILINE: {resultado1}")
  print(f"Con flag re.MULTILINE: {resultado2}")
          
         

• re.ASCII o re.A

  Hace que \w, \W, \b, \B, \s y \S realicen coincidencias basadas solo en el conjunto de caracteres ASCII.

• re.DEBUG

  Muestra información de depuración sobre el patrón compilado.

Puedes combinar varias flags utilizando el operador | (OR bit a bit). Por ejemplo, re.IGNORECASE | re.DOTALL.

El uso adecuado de las flags puede simplificar tus patrones de búsqueda y hacerlos más versátiles.

Special Sequences

✨ Secuencias Especiales: Atajos para Patrones Comunes

Las secuencias especiales en RegEx son combinaciones de la barra invertida (`\`) seguida de otro carácter. Estas secuencias representan patrones comunes y hacen que nuestras expresiones regulares sean más concisas y legibles.

Aquí tienes algunas de las secuencias especiales más útiles:

• \d

  Coincide con cualquier dígito decimal (0-9). Es equivalente a la clase de carácter [0-9].

          
  import re
  
  texto = "El año es 2023."
  patron = r"\d{4}"
  resultado = re.search(patron, texto)
  
  if resultado:
      print(f"Año encontrado: {resultado.group()}")
          
         

• \D

  Coincide con cualquier carácter que NO sea un dígito. Es equivalente a la clase de carácter [^0-9].

          
  import re
  
  texto = "Código: ABC-123"
  patron = r"\D+"
  resultado = re.search(patron, texto)
  
  if resultado:
      print(f"Parte no numérica: {resultado.group()}")
          
         

• \s

  Coincide con cualquier carácter de espacio en blanco (espacio, tabulador, nueva línea, retorno de carro, avance de formulario, tabulador vertical).

          
  import re
  
  texto = "Palabra\tseparada\npor espacios."
  patron = r"\s+"
  resultados = re.split(patron, texto)
  print(f"Palabras: {resultados}")
          
         

• \S

  Coincide con cualquier carácter que NO sea un espacio en blanco.

          
  import re
  
  texto = "Texto\tcon\nespacios."
  patron = r"\S+"
  resultados = re.findall(patron, texto)
  print(f"Elementos no espaciados: {resultados}")
          
         

• \w

  Coincide con cualquier carácter alfanumérico (letras, números y el guion bajo). Es equivalente a [a-zA-Z0-9_].

          
  import re
  
  texto = "identificador_1 = 10"
  patron = r"\w+"
  resultados = re.findall(patron, texto)
  print(f"Elementos alfanuméricos: {resultados}")
          
         

• \W

  Coincide con cualquier carácter que NO sea alfanumérico. Es equivalente a [^a-zA-Z0-9_].

          
  import re
  
  texto = "nombre!@dominio.com"
  patron = r"\W+"
  resultado = re.search(patron, texto)
  
  if resultado:
      print(f"Caracteres no alfanuméricos: {resultado.group()}")
          
         

• \b

  Coincide con un límite de palabra. Es la posición entre una palabra y un carácter que no es una palabra (como un espacio, una puntuación o el inicio/fin de la cadena).

          
  import re
  
  texto = "El gato come pescado."
  patron1 = r"\bgato\b"  # Coincide con la palabra "gato" completa
  patron2 = r"gato\b"   # Coincide con "gato" al final de una palabra
  
  resultado1 = re.search(patron1, texto)
  resultado2 = re.search(patron2, texto)
  
  print(f"Coincidencia completa de 'gato': {resultado1}")
  print(f"Coincidencia de 'gato' al final: {resultado2}")
          
         

• \B

  Coincide con una NO frontera de palabra.

• \\

  Coincide con una barra invertida literal.

El uso inteligente de estas secuencias especiales puede simplificar enormemente la creación de patrones de búsqueda comunes.

Sets

⚙️ Sets: Definiendo Rangos de Caracteres

Un set en RegEx se define utilizando un par de corchetes []. Los caracteres dentro de los corchetes representan un conjunto de caracteres que deseas coincidir. El motor de RegEx intentará encontrar CUALQUIER carácter que esté dentro de ese set en la posición dada del patrón.

Aquí exploramos diferentes formas de definir sets:

• Caracteres individuales

  Puedes listar caracteres individuales dentro de los corchetes. Por ejemplo:

  • [abc]: Coincide con "a", "b" o "c".
  • [12345]: Coincide con cualquier dígito del 1 al 5.

          
  import re
  
  texto = "Texto con a, b y z."
  patron = r"[abz]"
  resultados = re.findall(patron, texto)
  print(f"Coincidencias: {resultados}")
          
         

• Rangos de caracteres

  Para especificar un rango de caracteres de forma más concisa, puedes usar un guion -. Por ejemplo:

  • [a-z]: Coincide con cualquier letra minúscula de la "a" a la "z".
  • [A-Z]: Coincide con cualquier letra mayúscula de la "A" a la "Z".
  • [0-9]: Coincide con cualquier dígito del 0 al 9.
  • [a-zA-Z0-9]: Coincide con cualquier letra (mayúscula o minúscula) o dígito.

          
  import re
  
  texto = "Código: A1b2C3d4"
  patron = r"[A-Za-z0-9]"
  resultados = re.findall(patron, texto)
  print(f"Caracteres alfanuméricos: {resultados}")
          
         

• Negación de sets

  Si el primer carácter dentro de los corchetes es un signo de intercalación ^, el set se niega. Esto significa que coincidirá con CUALQUIER carácter que NO esté dentro del set.

  • [^abc]: Coincide con cualquier carácter que no sea "a", "b" o "c".
  • [^0-9]: Coincide con cualquier carácter que no sea un dígito.

          
  import re
  
  texto = "Símbolos !@# en el texto."
  patron = r"[^a-zA-Z\s.]"  # Coincide con cualquier cosa que no sea letra, espacio o punto.
  resultados = re.findall(patron, texto)
  print(f"Símbolos encontrados: {resultados}")
          
         

• Combinación de sets

  Puedes combinar diferentes sets dentro de un mismo par de corchetes.

  • [a-z0-9_]: Coincide con cualquier letra minúscula, dígito o guion bajo (similar a \w en modo ASCII).

Los sets son una herramienta fundamental para definir patrones de búsqueda flexibles y precisos, permitiéndote especificar conjuntos de caracteres de manera eficiente.

The findall() Function

🎣 La Función findall(): Encontrando Todas las Coincidencias

La función findall() del módulo re es una de las herramientas más utilizadas cuando necesitas encontrar todas las ocurrencias de un patrón en una cadena de texto. A diferencia de search(), que solo devuelve la primera coincidencia, findall() devuelve una lista que contiene todas las coincidencias no superpuestas del patrón en la cadena.

La sintaxis básica de findall() es:

      
re.findall(patrón, cadena, flags=0)
      
     

Donde:

• patrón: Es la expresión regular que deseas buscar.
• cadena: Es la cadena en la que quieres realizar la búsqueda.
• flags (opcional): Son las flags que modifican el comportamiento de la búsqueda (como re.IGNORECASE).

El valor de retorno de findall() es una lista de cadenas. Cada elemento de la lista es una de las coincidencias encontradas en la cadena.

Ejemplos de uso de findall()

• Encontrar todas las palabras

          
  import re
  
  texto = "El perro corre y el gato también corre."
  patron = r"\b\w+\b"  # Encuentra todas las palabras completas
  resultados = re.findall(patron, texto)
  print(f"Palabras encontradas: {resultados}")
          
         

• Encontrar todos los números

          
  import re
  
  texto = "Los precios son: 10, 25.50 y 100."
  patron = r"\d+(\.\d+)?"  # Encuentra números enteros y decimales
  resultados = re.findall(patron, texto)
  print(f"Números encontrados: {resultados}")
          
         

• Encontrar todas las direcciones de correo electrónico (ejemplo simplificado)

          
  import re
  
  texto = "Contacta con nosotros en info@example.com o ventas@otroejemplo.net."
  patron = r"\b\w+@\w+\.\w+\b"
  resultados = re.findall(patron, texto)
  print(f"Correos electrónicos encontrados: {resultados}")
          
         

Es importante recordar que si el patrón contiene grupos de captura (definidos por paréntesis), findall() devolverá una lista de tuplas, donde cada tupla contiene las coincidencias de los grupos. Si no hay grupos de captura, devuelve una lista de las coincidencias completas.

      
import re

texto = "Fechas: 2023-10-26 y 2024-01-15."
patron = r"(\d{4})-(\d{2})-(\d{2})"  # Tres grupos de captura para año, mes y día
resultados = re.findall(patron, texto)
print(f"Fechas encontradas (grupos): {resultados}")
     
     

findall() es una herramienta poderosa para extraer información específica de grandes cantidades de texto de manera eficiente.

The search() Function

🔍 La Función search(): Buscando la Primera Coincidencia

La función search() del módulo re busca la primera ubicación donde el patrón de expresión regular produce una coincidencia en la cadena. A diferencia de findall(), que devuelve todas las coincidencias, search() se detiene en la primera que encuentra.

La sintaxis básica de search() es:

      
re.search(patrón, cadena, flags=0)
      
     

Donde:

• patrón: Es la expresión regular que deseas buscar.
• cadena: Es la cadena en la que quieres realizar la búsqueda.
• flags (opcional): Son las flags que modifican el comportamiento de la búsqueda.

El valor de retorno de search() es un objeto de coincidencia (Match Object) si el patrón se encuentra en la cadena. Si el patrón no se encuentra, devuelve None.

Trabajando con el Objeto de Coincidencia

Cuando search() encuentra una coincidencia, devuelve un objeto que contiene información sobre esa coincidencia, como:

• La cadena original.
• La posición de inicio y fin de la coincidencia.
• El grupo o grupos que coinciden con el patrón (si se usaron paréntesis).

Puedes acceder a esta información utilizando métodos del objeto de coincidencia, como span(), start(), end() y group(). Exploraremos el objeto de coincidencia en detalle más adelante.

Ejemplos de uso de search()

• Buscar la primera palabra que empiece con "P"

          
  import re
  
  texto = "La primera palabra es Python."
  patron = r"\bP\w+"
  resultado = re.search(patron, texto)
  
  if resultado:
      print(f"Primera palabra con 'P' encontrada: {resultado.group()}")
      print(f"Posición de inicio: {resultado.start()}")
      print(f"Posición de fin: {resultado.end()}")
  else:
      print("No se encontró ninguna palabra que empiece con 'P'.")
          
         

• Verificar si una cadena contiene un número

          
  import re
  
  texto = "El código es ABC123XYZ."
  patron = r"\d+"
  resultado = re.search(patron, texto)
  
  if resultado:
      print("Se encontró un número.")
      print(f"Número encontrado: {resultado.group()}")
  else:
      print("No se encontró ningún número.")
          
         

• Buscar una fecha con un formato específico

          
  import re
  
  texto = "La fecha del evento es 2023-11-10."
  patron = r"\d{4}-\d{2}-\d{2}"
  resultado = re.search(patron, texto)
  
  if resultado:
      print(f"Fecha encontrada: {resultado.group()}")
  else:
      print("No se encontró ninguna fecha con el formato YYYY-MM-DD.")
          
         

search() es ideal cuando solo necesitas encontrar la primera ocurrencia de un patrón y obtener información sobre ella.

The split() Function

✂️ La Función split(): Dividiendo Cadenas con RegEx

La función split() del módulo re divide una cadena en una lista de subcadenas, utilizando las ocurrencias del patrón como delimitadores. Es una forma poderosa y flexible de segmentar texto basado en criterios definidos por expresiones regulares.

La sintaxis básica de split() es:

      
re.split(patrón, cadena, maxsplit=0, flags=0)
      
     

Donde:

• patrón: Es la expresión regular que se utilizará como delimitador.
• cadena: Es la cadena que se va a dividir.
• maxsplit (opcional): Si se especifica, indica el número máximo de divisiones que se realizarán. Si es 0 (o no se especifica), se realizarán todas las divisiones posibles.
• flags (opcional): Son las flags que modifican el comportamiento de la búsqueda del patrón.

El valor de retorno de split() es una lista de las subcadenas resultantes de la división.

Ejemplos de uso de split()

• Dividir una cadena por comas y espacios

          
  import re
  
  texto = "manzana, pera,  banana,uva"
  patron = r",\s*"  # Coincide con una coma seguida de cero o más espacios
  resultados = re.split(patron, texto)
  print(f"Lista de frutas: {resultados}")
          
         

• Dividir una cadena por números

          
  import re
  
  texto = "parte123parte456parte789"
  patron = r"\d+"
  resultados = re.split(patron, texto)
  print(f"Partes divididas por números: {resultados}")
          
         

• Dividir una cadena por saltos de línea (máximo 2 divisiones)

          
  import re
  
  texto = "Línea 1\nLínea 2\nLínea 3\nLínea 4"
  patron = r"\n"
  resultados = re.split(patron, texto, maxsplit=2)
  print(f"Dividido por saltos de línea (máximo 2): {resultados}")
          
         

Es importante notar que si el patrón contiene grupos de captura, las cadenas que coinciden con los grupos también se incluirán en la lista resultante, intercaladas con las subcadenas divididas.

      
import re

texto = "palabra1(separador)palabra2"
patron = r"(\(|\))"  # Coincide con paréntesis de apertura o cierre (y los captura)
resultados = re.split(patron, texto)
print(f"Dividido con captura de delimitadores: {resultados}")
     
     

La función split() ofrece una gran flexibilidad para segmentar texto de manera inteligente basándose en patrones complejos.

The sub() Function

🔄 La Función sub(): Reemplazando Texto con RegEx

La función sub() del módulo re permite reemplazar todas las ocurrencias de un patrón en una cadena con una nueva subcadena. Es una herramienta muy poderosa para realizar transformaciones de texto complejas.

La sintaxis básica de sub() es:

      
re.sub(patrón, reemplazo, cadena, count=0, flags=0)
      
     

Donde:

• patrón: Es la expresión regular que se buscará en la cadena.
• reemplazo: Es la cadena con la que se reemplazarán las coincidencias del patrón. También puede ser una función (que recibe el objeto de coincidencia como argumento).
• cadena: Es la cadena en la que se realizarán las sustituciones.
• count (opcional): Especifica el número máximo de reemplazos que se realizarán. Si es 0 (o no se especifica), se reemplazarán todas las ocurrencias.
• flags (opcional): Son las flags que modifican el comportamiento de la búsqueda del patrón.

El valor de retorno de sub() es la nueva cadena resultante después de realizar los reemplazos.

Ejemplos de uso de sub()

• Reemplazar todos los espacios con guiones bajos

          
  import re
  
  texto = "Este es un texto con espacios."
  patron = r"\s+"
  reemplazo = "_"
  nueva_cadena = re.sub(patron, reemplazo, texto)
  print(f"Cadena modificada: {nueva_cadena}")
          
         

• Eliminar todos los dígitos de una cadena

          
  import re
  
  texto = "Producto Código: ABC-123-DEF-456"
  patron = r"\d+"
  reemplazo = ""
  nueva_cadena = re.sub(patron, reemplazo, texto)
  print(f"Cadena sin dígitos: {nueva_cadena}")
          
         

• Reemplazar la primera ocurrencia de una palabra (con count=1)

          
  import re
  
  texto = "La casa azul tiene una puerta azul."
  patron = r"\bazul\b"
  reemplazo = "verde"
  nueva_cadena = re.sub(patron, reemplazo, texto, count=1)
  print(f"Cadena con el primer reemplazo: {nueva_cadena}")
          
         

• Usando una función como reemplazo (para cambiar mayúsculas a minúsculas)

          
  import re
  
  def minuscula(coincidencia):
      return coincidencia.group(0).lower()
  
  texto = "ALGUNAS PALABRAS EN MAYÚSCULAS."
  patron = r"[A-Z]+"
  nueva_cadena = re.sub(patron, minuscula, texto)
  print(f"Cadena en minúsculas: {nueva_cadena}")
          
         

La función sub() es extremadamente versátil y permite realizar modificaciones de texto sofisticadas basadas en patrones definidos por expresiones regulares.

Match Object

📦 El Objeto de Coincidencia (Match Object)

Cuando utilizas funciones como re.search() o re.match() y se encuentra una coincidencia, estas funciones no devuelven directamente la cadena coincidente. En su lugar, devuelven un objeto llamado **Match Object**. Este objeto contiene información detallada sobre la coincidencia, incluyendo la cadena coincidente en sí, su ubicación dentro de la cadena original y cualquier grupo capturado por el patrón.

Métodos del Objeto de Coincidencia

El objeto de coincidencia proporciona varios métodos útiles para acceder a la información de la coincidencia:

• group()

  Devuelve la parte de la cadena donde hubo coincidencia. Si se proporcionan uno o más argumentos (números de grupo), devuelve la subcadena (o tupla de subcadenas) coincidente con ese grupo.

          
  import re
  
  texto = "Nombre: Juan Pérez, Edad: 30"
  patron = r"Nombre: (\w+) (\w+), Edad: (\d+)"
  resultado = re.search(patron, texto)
  
  if resultado:
      print(f"Coincidencia completa: {resultado.group()}")
      print(f"Nombre completo: {resultado.group(0)}") # Equivalente a group() sin argumentos
      print(f"Primer nombre (grupo 1): {resultado.group(1)}")
      print(f"Apellido (grupo 2): {resultado.group(2)}")
      print(f"Edad (grupo 3): {resultado.group(3)}")
      print(f"Todos los grupos: {resultado.groups()}") # Devuelve una tupla con todos los grupos
  else:
      print("No se encontró coincidencia.")
          
         

• start()

  Devuelve la posición inicial de la coincidencia.

          
  import re
  
  texto = "El número 123 está aquí."
  patron = r"\d+"
  resultado = re.search(patron, texto)
  
  if resultado:
      print(f"La coincidencia comienza en la posición: {resultado.start()}")
          
         

• end()

  Devuelve la posición final de la coincidencia (el índice del carácter siguiente al último de la coincidencia).

          
  import re
  
  texto = "El número 123 está aquí."
  patron = r"\d+"
  resultado = re.search(patron, texto)
  
  if resultado:
      print(f"La coincidencia termina en la posición: {resultado.end()}")
          
         

• span()

  Devuelve una tupla que contiene las posiciones inicial y final de la coincidencia: (start, end).

          
  import re
  
  texto = "El número 123 está aquí."
  patron = r"\d+"
  resultado = re.search(patron, texto)
  
  if resultado:
      print(f"El rango de la coincidencia es: {resultado.span()}")
          
         

Comprender y utilizar los métodos del objeto de coincidencia te permite extraer información específica y detallada sobre las partes de la cadena que coinciden con tu patrón de expresión regular.

---

Ir al indice