Dividere l'elenco di espressioni di funzione possibilmente nidificate in Python

Question

PostgreSQL consente di creare indici su espressioni, ad esempio CREATE INDEX ON films ((lower(title))). Ha anche una funzione di informazione pg_get_expr() che traduce il formato interno dell'espressione in testo, ad esempio, lower(title) nell'esempio precedente. Le espressioni possono diventare piuttosto pelose a volte. Ecco alcuni esempi (in Python):

sample_exprs = [ 
    'lower(c2)', 
    'lower(c2), lower(c3)', 
    "btrim(c3, 'x'::text), lower(c2)", 
    "date_part('month'::text, dt), date_part('day'::text, dt)", 
    '"substring"(c2, "position"(c2, \'_begin\'::text)), "substring"(c2, "position"(c2, \'_end\'::text))', 
    "(((c2)::text || ', '::text) || c3), ((c3 || ' '::text) || (c2)::text)", 
    'f1(f2(arga, f3()), arg1), f4(arg2, f5(argb, argc)), f6(arg3)'] 

L'ultimo elemento non è davvero da Postgres, ma è solo un esempio estremo di ciò che il mio codice dovrebbe gestire.

Ho scritto una funzione Python per dividere le liste di testo nelle espressioni componente. Ad esempio, tale elemento è suddiviso in:

f1(f2(arga, f3()), arg1) 
f4(arg2, f5(argb, argc)) 
f6(arg3) 

ho sperimentato con str metodi come find() e count() e regex anche considerati, ma alla fine ho scritto una funzione che è quello che avrei scritto in C (essenzialmente contando i parenti aperti e chiusi per trovare dove rompere il testo). Ecco la funzione:

def split_exprs(idx_exprs): 
    keyexprs = [] 
    nopen = nclose = beg = curr = 0 
    for c in idx_exprs: 
     curr += 1 
     if c == '(': 
      nopen += 1 
     elif c == ')': 
      nclose += 1 
      if nopen > 0 and nopen == nclose: 
       if idx_exprs[beg] == ',': 
        beg += 1 
       if idx_exprs[beg] == ' ': 
        beg += 1 
       keyexprs.append(idx_exprs[beg:curr]) 
       beg = curr 
       nopen = nclose = 0 
    return keyexprs 

La domanda è se c'è un altro Pythonic o modo elegante per fare questo o di usare espressioni regolari per risolvere questo.

Answer 1

Se stai cercando di renderlo più pitone, l'unico modo che posso pensare è la leggibilità.

Inoltre, evito un ramo e una variabile contando le pile. L'unico suggerimento pitonico che posso dare è usare la variabile 'index' con la funzione enumerate(...). Come in

for i, j in enumerate(<iterable>)

Ciò creerà una variabile, i, che sarà pari al numero di loop corrente, dove j sarà variabile iterazione previsto.

def split_fns(fns): 
    paren_stack_level = 0 
    last_pos = 0 
    output = [] 
    for curr_pos, curr_char in enumerate(fns): 
     if curr_char == "(": 
      paren_stack_level += 1 
     elif curr_char == ")": 
      paren_stack_level -= 1 
      if not paren_stack_level: 
       output.append(fns[last_pos:curr_pos+1].lstrip(" ,")) 
       last_pos = curr_pos+1 
    return output 

for i in sample_exprs: 
    print(split_fns(i)) 

Answer 2

Ecco la mia versione, più divinatorio, meno confusione credo, e funziona su flusso di caratteri, anche se non vedo alcun vantaggio in quanto :)

def split_fns(fns): 
    level = 0 
    stack = [[]] 
    for ch in fns: 
     if level == 0 and ch in [' ',',']: 
      continue   
     stack[-1].append(ch) 

     if ch == "(": 
      level += 1 
     elif ch == ")": 
      level -= 1 
      if level == 0: 
       stack.append([]) 

    return ["".join(t) for t in stack if t]