Regex Match равное количество двух символов

Question

Я хотел бы сопоставить параметры любой функции в виде строки с использованием регулярного выражения. В качестве примера предположим следующую строку:

predicate(foo(x.bar, predicate(foo(...), bar)), bar) 

это может быть частью более длинной последовательности

predicate(foo(x.bar, predicate(foo(...), bar)), bar)predicate(foo(x.bar, predicate(foo(...), bar)), bar)predicate(foo(x.bar, predicate(foo(...), bar)), bar) 

Теперь я хочу, чтобы найти все подстроки, которые представляют собой функцию/предиката и его параметры (т.е. первый пример - целая строка, а также вложенный predicate(foo(...), bar)). Проблема заключается в том, что я не могу просто соответствовать как этот

predicate\(.*, bar\) 

, как я может тогда соответствовать более параметров предиката, если * жаден, или меньше, если он ленив. Это потому, что такие предикаты() могут быть вложенными.

мне нужно регулярное выражение, которое находит строку predicate(...), где ... соответствует любой строке, которая содержит равное количество ( х и )-х (ленивых).

Если это имеет значение: я использую регулярное выражение с модулем re в python.

Answer 1

Добавление PyPI package regex, как предложено @Tim Pietzcker, вы можете использовать recursive regexes.

>>> import regex 
>>> s = 'predicate(foo(x.bar, predicate(foo(...), bar)), bar)' 
>>> pattern = regex.compile(r'(\w+)(?=\(((?:\w+\((?2)\)|[^()])*)\))') 
>>> pattern.findall(s) 
[('predicate', 'foo(x.bar, predicate(foo(...), bar)), bar'), 
('foo', 'x.bar, predicate(foo(...), bar)'), 
('predicate', 'foo(...), bar'), 
('foo', '...')] 

Вы также можете ограничить его искать только "предикат":

>>> pattern = regex.compile(r'(predicate)(?=\(((?:\w+\((?2)\)|[^()])*)\))') 
>>> pattern.findall(s) 
[('predicate', 'foo(x.bar, predicate(foo(...), bar)), bar'), 
('predicate', 'foo(...), bar')] 

Answer 2

import re 

def parse(s): 
    pattern = re.compile(r'([^(),]+)|\s*([(),])\s*') 
    stack = [] 
    state = 0 # 0 = before identifier, 1 = after identifier, 2 = after closing paren 
    current = None 
    args = [] 
    for match in pattern.finditer(s): 
     if match.group(1): 
     if state != 0: 
      raise SyntaxError("Expected identifier at {0}".format(match.start())) 
     current = match.group(1) 
     state = 1 
     elif match.group(2) == '(': 
     if state != 1: 
      raise SyntaxError("Unexpected open paren at {0}".format(match.start())) 
     stack.append((args, current)) 
     state = 0 
     current = None 
     args = [] 
     elif match.group(2) == ',': 
     if state != 0: args.append(current) 
     state = 0 
     current = None 
     elif match.group(2) == ')': 
     if state != 0: args.append(current) 
     if len(stack) == 0: 
      raise SyntaxError("Unmatched paren at {0}".format(match.start())) 
     newargs = args 
     args, current = stack.pop() 
     current = (current, newargs) 
     state = 2 
    if state != 0: args.append(current) 
    if len(stack) > 0: 
     raise SyntaxError("Unclosed paren") 
    return args 

>>> from pprint import pprint 
>>> pprint(parse('predicate(foo(x.bar, predicate(foo(...), bar)), bar)'), width=1) 
[('predicate', 
    [('foo', 
    ['x.bar', 
    ('predicate', 
     [('foo', 
     ['...']), 
     'bar'])]), 
    'bar'])] 

возвращает список всех разделенных запятыми выражений верхнего уровня. Вызов функций становится кортежем имени и аргументов.

Answer 3

Вы можете создать регулярное выражение, чтобы найти все вызовы функций внутри вашего кода. Что-то вроде этого:

([_a-zA-Z]+)(?=\() 

Затем с помощью re модуля, необходимо создать структуру данных индексации вызовов функций в коде.

import re 

code = 'predicate(foo(x.bar, predicate(foo(...), bar)), bar)predicate(foo(x.bar, predicate(foo(...), bar)), bar)predicate(foo(x.bar, predicate(foo(...), bar)), bar)' 
code_cp = code 

regex = re.compile(r'([_a-zA-Z]+)(?=\()') 
matches = re.findall(regex, code) 
structured_matches = [] 

for m in matches: 
    beg = str.index(code, m) 
    end = beg + len(m) 
    structured_matches.append((m, beg, end)) 
    code = code[:beg] + '_' * len(m) + code[end:] 

Это даст вам структуру данных, которая выглядит следующим образом:

[ 
    ('predicate', 0, 9), 
    ('foo', 10, 13), 
    ('predicate', 21, 30), 
    ('foo', 31, 34), 
    ('predicate', 52, 61), 
    ('foo', 62, 65), 
    ('predicate', 73, 82), 
    ('foo', 83, 86), 
    ('predicate', 104, 113), 
    ('foo', 114, 117), 
    ('predicate', 125, 134), 
    ('foo', 135, 138) 
] 

Вы можете использовать эту структуру данных в сочетании с parse функции, чтобы вытащить содержимое скобок каждого вызова функции.

def parse(string): 
    stack = [] 
    contents = '' 
    opened = False 

    for c in string: 
     if len(stack) > 0: 
      contents += c 
     if c == '(': 
      opened = True 
      stack.append('o') 
     elif c == ')': 
      stack.pop() 
      if opened and len(stack) == 0: 
       break 

    return contents[:-1] 


paren_contents = [] 

for m in structured_matches: 
    fn_name, beg, end = m 
    paren_contents.append((fn_name, parse(code_cp[end:]))) 

В конце концов, paren_contents должен выглядеть примерно так:

[ 
    ('predicate', 'foo(x.bar, predicate(foo(...), bar)), bar'), 
    ('foo', 'x.bar, predicate(foo(...), bar)'), 
    ('predicate', 'foo(...), bar'), ('foo', '...'), 
    ('predicate', 'foo(x.bar, predicate(foo(...), bar)), bar'), 
    ('foo', 'x.bar, predicate(foo(...), bar)'), 
    ('predicate', 'foo(...), bar'), ('foo', '...'), 
    ('predicate', 'foo(x.bar, predicate(foo(...), bar)), bar'), 
    ('foo', 'x.bar, predicate(foo(...), bar)'), 
    ('predicate', 'foo(...), bar'), 
    ('foo', '...') 
] 

Надеемся, что это указывает вам в правильном направлении.