파이썬 구문 분석 괄호 블록
https://stackoverflow.com/questions/1651487
-
22-07-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
Russian문제
파이썬에서 일치하는 괄호에 포함 된 텍스트 덩어리를 구문 분석하는 가장 좋은 방법은 무엇입니까?
"{ { a } { b } { { { c } } } }"
처음에 반환해야합니다.
[ "{ a } { b } { { { c } } }" ]
입력으로 넣는 것을 반환해야합니다.
[ "a", "b", "{ { c } }" ]
돌아와야합니다 :
[ "{ c }" ]
[ "c" ]
[]
해결책
의사 코드 :
For each string in the array:
Find the first '{'. If there is none, leave that string alone.
Init a counter to 0.
For each character in the string:
If you see a '{', increment the counter.
If you see a '}', decrement the counter.
If the counter reaches 0, break.
Here, if your counter is not 0, you have invalid input (unbalanced brackets)
If it is, then take the string from the first '{' up to the '}' that put the
counter at 0, and that is a new element in your array.
다른 팁
또는이 pyparsing 버전 :
>>> from pyparsing import nestedExpr
>>> txt = "{ { a } { b } { { { c } } } }"
>>>
>>> nestedExpr('{','}').parseString(txt).asList()
[[['a'], ['b'], [[['c']]]]]
>>>
나는 Python을 처음 접 했으므로 쉽게 가십시오. 그러나 여기에 작동하는 구현이 있습니다.
def balanced_braces(args):
parts = []
for arg in args:
if '{' not in arg:
continue
chars = []
n = 0
for c in arg:
if c == '{':
if n > 0:
chars.append(c)
n += 1
elif c == '}':
n -= 1
if n > 0:
chars.append(c)
elif n == 0:
parts.append(''.join(chars).lstrip().rstrip())
chars = []
elif n > 0:
chars.append(c)
return parts
t1 = balanced_braces(["{{ a } { b } { { { c } } } }"]);
print t1
t2 = balanced_braces(t1)
print t2
t3 = balanced_braces(t2)
print t3
t4 = balanced_braces(t3)
print t4
산출:
['{ a } { b } { { { c } } }']
['a', 'b', '{ { c } }']
['{ c }']
['c']
구문 분석 lepl (설치 가능 $ easy_install lepl):
from lepl import Any, Delayed, Node, Space
expr = Delayed()
expr += '{' / (Any() | expr[1:,Space()[:]]) / '}' > Node
print expr.parse("{{a}{b}{{{c}}}}")[0]
산출:
Node
+- '{'
+- Node
| +- '{'
| +- 'a'
| `- '}'
+- Node
| +- '{'
| +- 'b'
| `- '}'
+- Node
| +- '{'
| +- Node
| | +- '{'
| | +- Node
| | | +- '{'
| | | +- 'c'
| | | `- '}'
| | `- '}'
| `- '}'
`- '}'
당신은 또한 그들을 한 번에 구문 분석 할 수 있지만 {a} 의미합니다 "a" 보다는 ["a"] 약간 이상합니다. 형식을 올바르게 이해 한 경우 :
import re
import sys
_mbrack_rb = re.compile("([^{}]*)}") # re.match doesn't have a pos parameter
def mbrack(s):
"""Parse matching brackets.
>>> mbrack("{a}")
'a'
>>> mbrack("{{a}{b}}")
['a', 'b']
>>> mbrack("{{a}{b}{{{c}}}}")
['a', 'b', [['c']]]
>>> mbrack("a")
Traceback (most recent call last):
ValueError: expected left bracket
>>> mbrack("{a}{b}")
Traceback (most recent call last):
ValueError: more than one root
>>> mbrack("{a")
Traceback (most recent call last):
ValueError: expected value then right bracket
>>> mbrack("{a{}}")
Traceback (most recent call last):
ValueError: expected value then right bracket
>>> mbrack("{a}}")
Traceback (most recent call last):
ValueError: unbalanced brackets (found right bracket)
>>> mbrack("{{a}")
Traceback (most recent call last):
ValueError: unbalanced brackets (not enough right brackets)
"""
stack = [[]]
i, end = 0, len(s)
while i < end:
if s[i] != "{":
raise ValueError("expected left bracket")
elif i != 0 and len(stack) == 1:
raise ValueError("more than one root")
while i < end and s[i] == "{":
L = []
stack[-1].append(L)
stack.append(L)
i += 1
stack.pop()
stack[-1].pop()
m = _mbrack_rb.match(s, i)
if m is None:
raise ValueError("expected value then right bracket")
stack[-1].append(m.group(1))
i = m.end(0)
while i < end and s[i] == "}":
if len(stack) == 1:
raise ValueError("unbalanced brackets (found right bracket)")
stack.pop()
i += 1
if len(stack) != 1:
raise ValueError("unbalanced brackets (not enough right brackets)")
return stack[0][0]
def main(args):
if args:
print >>sys.stderr, "unexpected arguments: %r" % args
import doctest
r = doctest.testmod()
print r
return r[0]
if __name__ == "__main__":
sys.exit(main(sys.argv[1:]))
파서 (이 경우 LEPL)를 사용하려면 최종 구문 분석 목록이 아닌 중간 결과를 원한다면 이것이 당신이 찾고 있던 종류라고 생각합니다.
>>> nested = Delayed()
>>> nested += "{" + (nested[1:,...]|Any()) + "}"
>>> split = (Drop("{") & (nested[:,...]|Any()) & Drop("}"))[:].parse
>>> split("{{a}{b}{{{c}}}}")
['{a}{b}{{{c}}}']
>>> split("{a}{b}{{{c}}}")
['a', 'b', '{{c}}']
>>> split("{{c}}")
['{c}']
>>> split("{c}")
['c']
처음에는 불투명 해 보일지 모르지만 실제로는 매우 간단합니다 : o)
중첩 중첩 브래킷에 대한 매치 자의 재귀 정의입니다 (정의에서 "+"및 [...]는 일치 한 후 모든 것을 단일 문자열로 유지합니다). 그 다음에 나뉘다 "{"... "}"( "Drop"으로 폐기)로 둘러싸인 무언가의 가능한 한 많은 일치 ( [:])를 말하며 중첩 된 표현이나 문자가 포함되어 있습니다.
마지막으로, 위의 pyparsing 예제와 동일한 형식을 보여주는 "All In One"파서의 LEPL 버전이 있지만, 입력에 공백이 어떻게 나타나는지에 대해 더 유연하다.
>>> with Separator(~Space()[:]):
... nested = Delayed()
... nested += Drop("{") & (nested[1:] | Any()) & Drop("}") > list
...
>>> nested.parse("{{ a }{ b}{{{c}}}}")
[[['a'], ['b'], [[['c']]]]]
클리너 솔루션. 이렇게하면 가장 바깥 쪽 브래킷에 둘러싸인 문자열이 반환됩니다. 아무것도 반환되지 않으면 일치하지 않았습니다.
def findBrackets( aString ):
if '{' in aString:
match = aString.split('{',1)[1]
open = 1
for index in xrange(len(match)):
if match[index] in '{}':
open = (open + 1) if match[index] == '{' else (open - 1)
if not open:
return match[:index]
사용 그라코 (문법 컴파일러):
#!/usr/bin/env python
import json
import grako # $ pip install grako
grammar_ebnf = """
bracketed = '{' @:( { bracketed }+ | any ) '}' ;
any = /[^{}]+?/ ;
"""
model = grako.genmodel("Bracketed", grammar_ebnf)
ast = model.parse("{ { a } { b } { { { c } } } }", "bracketed")
print(json.dumps(ast, indent=4))
산출
[
"a",
"b",
[
[
"c"
]
]
]
다음은 비슷한 사용 사례를 위해 제시 한 솔루션입니다. 이것은 허용 된 PSUedo 코드 답변을 기반으로 느슨하게 사용되었습니다. 외부 라이브러리에 의존성을 추가하고 싶지 않았습니다.
def parse_segments(source, recurse=False):
"""
extract any substring enclosed in parenthesis
source should be a string
"""
unmatched_count = 0
start_pos = 0
opened = False
open_pos = 0
cur_pos = 0
finished = []
segments = []
for character in source:
#scan for mismatched parenthesis:
if character == '(':
unmatched_count += 1
if not opened:
open_pos = cur_pos
opened = True
if character == ')':
unmatched_count -= 1
if opened and unmatched_count == 0:
segment = source[open_pos:cur_pos+1]
segments.append(segment)
clean = source[start_pos:open_pos]
if clean:
finished.append(clean)
opened = False
start_pos = cur_pos+1
cur_pos += 1
assert unmatched_count == 0
if start_pos != cur_pos:
#get anything that was left over here
finished.append(source[start_pos:cur_pos])
#now check on recursion:
for item in segments:
#get rid of bounding parentheses:
pruned = item[1:-1]
if recurse:
results = parse_tags(pruned, recurse)
finished.expand(results)
else:
finished.append(pruned)
return finished
제휴하지 않습니다 StackOverflow
