Acordeón de los Índices
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:
- Importar el módulo
re: Ya lo vimos, es el primer paso para acceder a las funcionalidades de RegEx. - 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.
- Usar una función del módulo
re: El móduloreofrece varias funciones para aplicar tu patrón a una cadena de texto. Las más comunes sonsearch(),findall(),match(),split()ysub(). - 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 flagre.DOTALL(ore.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}: Exactamentenocurrencias.{n,}:no más ocurrencias.{n,m}: Entrenymocurrencias (ambos inclusive).
-
|(Alternancia - OR lógico)La barra vertical se utiliza para especificar una de varias opciones. Por ejemplo,
gato|perrocoincide 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.IGNORECASEore.IEsta 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.DOTALLore.SPor defecto, el metacaracter
.coincide con cualquier carácter excepto la nueva línea (\n). La flagre.DOTALLhace 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.MULTILINEore.MEn 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.ASCIIore.AHace que
\w,\W,\b,\B,\sy\Srealicen coincidencias basadas solo en el conjunto de caracteres ASCII. -
re.DEBUGMuestra 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:
-
\dCoincide 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()}") -
\DCoincide 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()}") -
\sCoincide 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}") -
\SCoincide 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}") -
\wCoincide 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}") -
\WCoincide 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()}") -
\bCoincide 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}") -
\BCoincide 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\wen 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 (comore.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.
0 Comentarios
Si desea contactar comigo, lo puede hacer atravez deste formulario gracias