l'analyse des parenthèses imbriquées dans python, récupérez le contenu par niveau

Apparemment ce problème arrive assez souvent, après la lecture de

Expression régulière pour détecter semi-colon C++ terminée pour & tandis que les boucles

et la réflexion sur le problème pendant un certain temps, j'ai écrit une fonction pour renvoyer le contenu à l'intérieur d'un nombre arbitraire de imbriquée ()

La fonction pourrait facilement être étendu à toute expression régulière de l'objet, de poster ici pour vos pensées et considérations.

tout refactoring conseils seraient appréciés

(remarque, je suis nouveau sur python encore, et n'avait pas envie de chercher comment lever des exceptions ou que ce soit, donc j'ai juste eu le retour de la fonction "erreur" si on couldin pas comprendre ce qui se passait)

Modifié pour prendre en compte les commentaires:

def ParseNestedParen(string, level):
    """
    Return string contained in nested (), indexing i = level
    """
    CountLeft = len(re.findall("\(", string))
    CountRight = len(re.findall("\)", string))
    if CountLeft == CountRight:
        LeftRightIndex = [x for x in zip(
        [Left.start()+1 for Left in re.finditer('\(', string)], 
        reversed([Right.start() for Right in re.finditer('\)', string)]))]

    elif CountLeft > CountRight:
        return ParseNestedParen(string + ')', level)

    elif CountLeft < CountRight:
        return ParseNestedParen('(' + string, level)

    return string[LeftRightIndex[level][0]:LeftRightIndex[level][1]]

source d'informationauteur justin cress

Vous ne le faites pas clair exactement ce que les spécifications de votre fonction, mais ce comportement semble mal pour moi:

>>> ParseNestedParen('(a)(b)(c)', 0)
['a)(b)(c']
>>> nested_paren.ParseNestedParen('(a)(b)(c)', 1)
['b']
>>> nested_paren.ParseNestedParen('(a)(b)(c)', 2)
['']

D'autres commentaires sur votre code:

Docstring dit "générer", mais la fonction renvoie une liste, pas un générateur.
Depuis qu'une chaîne n'est jamais revenu, pourquoi retourner dans une liste?
Dans quelles circonstances la fonction renvoie la chaîne fail?
À plusieurs reprises d'appeler re.findall puis jeter le résultat, c'est du gaspillage.
Vous essayez de rééquilibrer les parenthèses dans la chaîne, mais vous pouvez le faire une parenthèse à la fois:

>>> ParseNestedParen(')' * 1000, 1)
RuntimeError: maximum recursion depth exceeded while calling a Python object

Comme Thomi dit dans le question-vous liés à"les expressions régulières sont vraiment le mauvais outil pour le travail!"

La manière habituelle pour analyser des expressions imbriquées est d'utiliser une pile, le long de ces lignes:

def parenthetic_contents(string):
    """Generate parenthesized contents in string as pairs (level, contents)."""
    stack = []
    for i, c in enumerate(string):
        if c == '(':
            stack.append(i)
        elif c == ')' and stack:
            start = stack.pop()
            yield (len(stack), string[start + 1: i])

>>> list(parenthetic_contents('(a(b(c)(d)e)(f)g)'))
[(2, 'c'), (2, 'd'), (1, 'b(c)(d)e'), (1, 'f'), (0, 'a(b(c)(d)e)(f)g')]

#!/usr/bin/env python
import re

def ParseNestedParen(string, level):
    """
    Generate strings contained in nested (), indexing i = level
    """
    if len(re.findall("\(", string)) == len(re.findall("\)", string)):
        LeftRightIndex = [x for x in zip(
        [Left.start()+1 for Left in re.finditer('\(', string)], 
        reversed([Right.start() for Right in re.finditer('\)', string)]))]

    elif len(re.findall("\(", string)) > len(re.findall("\)", string)):
        return ParseNestedParen(string + ')', level)

    elif len(re.findall("\(", string)) < len(re.findall("\)", string)):
        return ParseNestedParen('(' + string, level)

    else:
        return 'fail'

    return [string[LeftRightIndex[level][0]:LeftRightIndex[level][1]]]

Tests:

if __name__ == '__main__':

    teststring = "outer(first(second(third)second)first)outer"

    print(ParseNestedParen(teststring, 0))
    print(ParseNestedParen(teststring, 1))
    print(ParseNestedParen(teststring, 2))

    teststring_2 = "outer(first(second(third)second)"

    print(ParseNestedParen(teststring_2, 0))
    print(ParseNestedParen(teststring_2, 1))
    print(ParseNestedParen(teststring_2, 2))

    teststring_3 = "second(third)second)first)outer"

    print(ParseNestedParen(teststring_3, 0))
    print(ParseNestedParen(teststring_3, 1))
    print(ParseNestedParen(teststring_3, 2))

de sortie:

Running tool: python3.1

['first(second(third)second)first']
['second(third)second']
['third']
['first(second(third)second)']
['second(third)second']
['third']
['(second(third)second)first']
['second(third)second']
['third']
>>>

Parenthèses correspondant nécessite un analyseur avec un push-down automate. Certaines bibliothèques existent, mais les règles sont assez simples pour que l'on puisse l'écrire à partir de zéro:

def push(obj, l, depth):
    while depth:
        l = l[-1]
        depth -= 1

    l.append(obj)

def parse_parentheses(s):
    groups = []
    depth = 0

    try:
        for char in s:
            if char == '(':
                push([], groups, depth)
                depth += 1
            elif char == ')':
                depth -= 1
            else:
                push(char, groups, depth)
    except IndexError:
        raise Exception('Parentheses mismatch')

    if depth > 0:
        raise Exception('Parentheses mismatch')
    else:
        return groups

print(parse_parentheses('a(b(cd)f)')) # ['a', ['b', ['c', 'd'], 'f']]

Vous devez vous connecter pour publier un commentaire.