Descubre el número de grupos de captura en las expresiones regulares de Python

Question

¿Hay alguna manera de determinar cuántos grupos de captura hay en una expresión regular dada?

Me gustaría ser capaz de hacer lo siguientes aparatos:

def groups(regexp, s): 
    """ Returns the first result of re.findall, or an empty default 

    >>> groups(r'(\d)(\d)(\d)', '123') 
    ('1', '2', '3') 
    >>> groups(r'(\d)(\d)(\d)', 'abc') 
    ('', '', '') 
    """ 
    import re 
    m = re.search(regexp, s) 
    if m: 
     return m.groups() 
    return ('',) * num_of_groups(regexp) 

Esto me permite hacer cosas como:

first, last, phone = groups(r'(\w+) (\w+) ([\d\-]+)', 'John Doe 555-3456') 

Sin embargo, no sé cómo implementar num_of_groups. (Actualmente sólo trabajo a su alrededor.)

EDIT: Después de laadvice from rslite, he sustituido re.findall con re.search.

sre_parse parece la solución más robusta y completa, pero requiere un recorrido de árbol y parece ser un poco pesado.

La expresión regular de MizardX parece cubrir todas las bases, así que voy a ir con eso.

Answer 1

def num_groups(regex): 
    return re.compile(regex).groups 

Answer 2

En primer lugar, si solo necesita el primer resultado de re.findall, es mejor usar re.search que devuelva una coincidencia o None.

Para los grupos de números que podría contar el número de paréntesis de apertura '(' excepto aquellos que se escapó por '\' Se podría utilizar otra expresión regular para que:.

def num_of_groups(regexp): 
    rg = re.compile(r'(?<!\\)\(') 
    return len(rg.findall(regexp)) 

Tenga en cuenta que esto no lo hace funciona si la expresión regular contiene grupos que no capturan y también si '(' se escapó usándolo como '[(]'. Esto no es muy confiable. Pero dependiendo de las expresiones regulares que use puede ayudar.

Answer 3

La propiedad lastindex del objeto partido debe ser lo que está buscando. Consulte el re module docs.

Answer 4

Algo dentro de sre_parse podría ayudar.

A primera vista, tal vez algo en la línea de:

>>> import sre_parse 
>>> sre_parse.parse('(\d)\d(\d)') 
[('subpattern', (1, [('in', [('category', 'category_digit')])])), 
('in', [('category', 'category_digit')]), 
('subpattern', (2, [('in', [('category', 'category_digit')])]))] 

es decir, contar los elementos de tipo 'sub-patrón':

import sre_parse 

def count_patterns(regex): 
    """ 
    >>> count_patterns('foo: \d') 
    0 
    >>> count_patterns('foo: (\d)') 
    1 
    >>> count_patterns('foo: (\d(\s))') 
    1 
    """ 
    parsed = sre_parse.parse(regex) 
    return len([token for token in parsed if token[0] == 'subpattern']) 

en cuenta que sólo estamos contando los patrones de nivel de raíz, así que el último ejemplo sólo devuelve 1. Para cambiar esto, fichas necesitarían buscado de forma recursiva.

Answer 5

Podría ser incorrecto, pero no creo que haya una manera de encontrar la cantidad de grupos que se habrían devuelto si la expresión regular hubiera coincidido. La única forma en que puedo pensar para hacer que esto funcione de la manera que quieres es pasar el número de coincidencias que tu expresión regular particular espera como argumento.

Sin embargo, para aclarar: ¿Cuándo findall tiene éxito, solo desea que se devuelva la primera coincidencia, pero cuando falla, desea una lista de cadenas vacías? Porque el comentario parece mostrar todas las coincidencias que se devuelven como una lista.

Answer 6

Utilizando su código como base:

def groups(regexp, s): 
    """ Returns the first result of re.findall, or an empty default 

    >>> groups(r'(\d)(\d)(\d)', '123') 
    ('1', '2', '3') 
    >>> groups(r'(\d)(\d)(\d)', 'abc') 
    ('', '', '') 
    """ 
    import re 
    m = re.search(regexp, s) 
    if m: 
     return m.groups() 
    return ('',) * len(m.groups()) 

Answer 7

f_x = re.search(...) 
len_groups = len(f_x.groups())