2.36. Grupos y anclas#

Un patrón puede hacer algo más que decir «esta cadena coincide»: puede separar las partes coincidentes y entregar cada una a la aplicación por su nombre. Los paréntesis alrededor de una parte de un patrón la convierten en un grupo de captura; el objeto de coincidencia expone entonces cada grupo como una subcadena independiente.

2.36.1. Grupos de captura#

Envuelve cualquier parte de un patrón en (...) para capturar lo que coincidió:

>>> import re
>>> m = re.search(r'temp (\d+) at (\d+)s', 'temp 42 at 137s ok')
>>> m.group(0)
'temp 42 at 137s'
>>> m.group(1)
'42'
>>> m.group(2)
'137'

  • El grupo 0 es siempre la coincidencia completa.

  • Los grupos 1, 2, … son las subcadenas capturadas, numeradas de izquierda a derecha por su paréntesis de apertura.

  • Llamar a match.group() con un índice posterior al último grupo provoca un IndexError.

Un patrón habitual es «coincidir con una estructura conocida y capturar las partes variables como enteros»:

def parse_temp(line):
    m = re.search(r'temp (\d+) at (\d+)s', line)
    if not m:
        return None
    return int(m.group(1)), int(m.group(2))

2.36.2. Grupos sin captura#

Los paréntesis también agrupan una subexpresión para que un cuantificador pueda aplicarse a todo el grupo. Ese es el único propósito de la agrupación en r'(ab)+': «uno o más de ab». El hecho de que ab aparezca como grupo 1 es un efecto secundario.

Para agrupar sin capturar, usa (?:...):

>>> re.search(r'(?:ab)+', 'xababy').group(0)
'abab'

Los grupos sin captura mantienen los números de grupo ordenados cuando un patrón usa la agrupación para dar estructura pero no le interesa extraer cada parte.

2.36.3. Anclas#

Las anclas no coinciden con un carácter: coinciden con una posición.

  • ^ – inicio de la cadena.

  • $ – final de la cadena.

Las anclas son lo que hace que re.match() y re.search() se comporten de forma diferente. re.match(p, s) es lo mismo que re.search('^' + p, s): obliga al patrón a empezar en la posición 0. Añadir $ al final de un patrón hace entonces que el patrón coincida con la cadena entera y nada más:

>>> re.search(r'^\d+$', '12345')
<match num=1>
>>> re.search(r'^\d+$', '12345 ok') is None
True

^ y $ en el módulo re de MicroPython siempre significan el inicio y el final de la cadena completa pasada a re.search(). No existe ninguna bandera re.MULTILINE que haga que coincidan en cada salto de línea incrustado, y $ tampoco coincide con la posición anterior a un \n final: tiene que ser el final absoluto de la entrada. Para obtener un comportamiento por línea, divide primero la entrada en saltos de línea y ejecuta el patrón en cada línea.

2.36.4. Conjuntos de caracteres#

Los corchetes definen un conjunto explícito de caracteres. La coincidencia consume exactamente un carácter del conjunto.

  • [abc] – uno de a, b, c.

  • [a-z] – un carácter en el rango a-z (ambos incluidos).

  • [a-zA-Z0-9] – letras o dígitos. Tres rangos combinados.

  • [^abc] – no uno de a, b, c. El ^ solo niega cuando es el primer carácter dentro de los corchetes.

Ejemplos:

>>> re.search(r'[A-F0-9]{6}', 'colour #1a2b3c rest').group(0)
'1A2B3C'
>>> re.search(r'[A-F0-9]{6}', 'colour #1a2b3c rest') is None
True

La primera llamada devuelve None en la práctica porque el texto literal está en minúsculas. El módulo re de MicroPython no tiene ninguna bandera re.IGNORECASE: para coincidir sin distinguir mayúsculas y minúsculas, escribe ambos casos dentro del conjunto:

>>> re.search(r'[A-Fa-f0-9]{6}', 'colour #1a2b3c rest').group(0)
'1a2b3c'

Los atajos de clase (\d, \s, \w y sus formas negadas) también pueden usarse dentro de [...]: [\w-] significa «caracteres de palabra o un guion literal».

2.36.5. Cuantificadores codiciosos frente a perezosos#

Los cuantificadores *, +, ? y {m,n} son codiciosos de forma predeterminada: coinciden con tantos caracteres como el resto del patrón siga permitiendo. A menudo eso es exactamente lo que se quiere; a veces no:

>>> re.search(r'<(.+)>', 'a <b> <c> d').group(1)
'b> <c'

El .+ codicioso capturó hasta el último >. Añadir ? hace que el cuantificador sea perezoso: coincide con lo menos posible:

>>> re.search(r'<(.+?)>', 'a <b> <c> d').group(1)
'b'

La forma perezosa se detiene en el primer >. Los cuantificadores perezosos aparecen constantemente al extraer delimitadores equilibrados de una cadena.

2.36.6. Retrorreferencias en la sustitución#

re.sub() puede referirse a los grupos capturados en la cadena de reemplazo mediante \1, \2, … La sustitución reescribe cada coincidencia usando las partes capturadas:

>>> re.sub(r'(\d+)\.(\d+)', r'\2.\1', 'swap 12.34 and 5.6')
'swap 34.12 and 6.5'

Cada coincidencia captura dos números, y el reemplazo los intercambia. \g<1> es una sintaxis alternativa para lo mismo: útil cuando el siguiente carácter en el reemplazo es un dígito (r'\g<1>0' para añadir un cero literal al grupo 1 en lugar de leer «grupo 10»).

2.36.7. Lo que no está disponible#

Un recordatorio de lo que el módulo re de MicroPython no admite, por si un patrón de CPython acaba aquí y te sorprende:

  • Anticipación (?=...) y retrospección (?<=...) – no implementadas.

  • Grupos con nombre (?P<name>...) y retrorreferencias con nombre (?P=name) – no implementados.

  • Constantes de banderas como re.IGNORECASE, re.MULTILINE, re.DOTALL – no se respetan. Construye tú mismo el conjunto sin distinción de mayúsculas y minúsculas o divide previamente la entrada.

  • Los métodos match.groups(), match.span(), match.start() y match.end() están condicionados a un nivel de ROM que ninguna placa OpenMV de las distribuidas habilita. El código que dependa de ellos no se ejecutará en la cámara.

Con patrones, grupos y anclas, el conjunto de herramientas de expresiones regulares de la cámara es lo bastante pequeño para aprenderlo de una sentada y lo bastante completo para hacer todo, salvo el análisis sensible al contexto.