我正在寻找一种扩展由斜线分隔的数字的方法。除了斜线之外，还可以在一些（或所有）数字周围使用括号来表示可以重复的“组”（直接在括号后面的次数）或反复重复（后跟's'为如第二组例子所示）。一些例子是：
1 -> ['1'] -> No slashes, no parentheses
1/2/3/4 -> ['1', '2', '3', '4'] -> basic example with slashes
1/(2)4/3 -> ['1', '2', '2', '2', '2', '3'] -> 2 gets repeated 4 times
1/(2/3)2/4 -> ['1', '2', '3', '2', '3', '4'] -> 2/3 is repeated 2 times
(1/2/3)2 -> ['1', '2', '3', '1', '2', '3'] -> Entire sequence is repeated twice
(1/2/3)s -> ['1', '2', '3', '3', '2', '1'] -> Entire sequence is repeated in reverse
1/(2/3)s/4 -> ['1', '2', '3', '3', '2', '4'] -> 2/3 is repeated in reverse
在最一般的情况下，甚至可能有嵌套的括号，我知道这通常会使正则表达式的使用变得不可能。在我需要处理的当前数据集中，没有像这样的嵌套集，但我可以在将来看到它的潜在用途。例如：
1/(2/(3)2/4)s/5 -> 1/(2/3/3/4)s/5
-> 1/2/3/3/4/4/3/3/2/5
-> ['1', '2', '3', '3', '4', '4', '3', '3', '2', '5']
我当然知道正则表达式不能完成所有这些（尤其是重复/反转括号集）。但是，如果我能得到一个正则表达式，至少将括号中的字符串与不在括号中的字符串分开，那么我可能很容易做出一些循环来处理其余部分。所以，我正在寻找的正则表达式会做类似的事情：
1 -> ['1']
1/2/3/4 -> ['1', '2', '3', '4']
1/(2)4/3 -> ['1', '(2)4', '3']
1/(2/3)2/4 -> ['1', '(2/3)2', '4']
1/(2/(3)2/4)s/5 -> ['1', '(2/(3)/2/4)s', '5']
然后我可以循环这个结果并继续扩展任何括号，直到我只有数字。
修改
我在原帖中并不完全清楚。在我尝试使示例尽可能简单的过程中，我可能会过度简化它们。这需要适用于数字＆gt; = 10以及负数。
例如：
1/(15/-23)s/4 -> ['1', '(15/-23)s', '4']
-> ['1', '15', '-23', '-23', '15', '4']
答案 0 :(得分：3)
由于你正在处理嵌套的括号，正则表达式在这里帮助不了多少。它不能轻易地将字符串转换为列表，正如您最终想要的那样。
你最好自己解析一下这个字符串。您可以尝试使用此代码，只是为了满足您的要求：
def parse(s):
li = []
open = 0
closed = False
start_index = -1
for index, c in enumerate(s):
if c == '(':
if open == 0:
start_index = index
open += 1
elif c == ')':
open -= 1
if open == 0:
closed = True
elif closed:
li.append(s[start_index: index + 1])
closed = False
elif open == 0 and c.isdigit():
li.append(c)
return li
这将为您提供以下列表中的字符串'1/(2/(3)2/4)s/5'：
['1', '(2/(3)2/4)s', '5']
对于字符串'1/(15/-23)s/4'，根据您更改的要求，这会给出：
['1', '(15/-23)s', '4']
现在，你需要进一步打破括号以获得不同的列表元素。
在这里你可以使用正则表达式，只需要同时处理最内部的括号：
import re
def expand(s):
''' Group 1 contains the string inside the parenthesis
Group 2 contains the digit or character `s` after the closing parenthesis
'''
match = re.search(r'\(([^()]*)\)(\d|s)', s)
if match:
group0 = match.group()
group1 = match.group(1)
group2 = match.group(2)
if group2.isdigit():
# A digit after the closing parenthesis. Repeat the string inside
s = s.replace(group0, ((group1 + '/') * int(group2))[:-1])
else:
s = s.replace(group0, '/'.join(group1.split('/') + group1.split('/')[::-1]))
if '(' in s:
return expand(s)
return s
li = parse('1/(15/-23)2/4')
for index, s in enumerate(li):
if '(' in s:
s = expand(s)
li[index] = s.split('/')
import itertools
print list(itertools.chain(*li))
这将为您提供所需的结果：
['1', '15', '-23', '-23', '15', '4']
上面的代码遍历从parse(s)方法生成的列表，然后对于每个元素，递归地扩展最内部的括号。
答案 1 :(得分：3)
这是完成这项工作的另一种方法。
def expand(string):
level = 0
buffer = ""
container = []
for char in string:
if char == "/":
if level == 0:
container.append(buffer)
buffer = ""
else:
buffer += char
elif char == "(":
level += 1
buffer += char
elif char == ")":
level -= 1
buffer += char
else:
buffer += char
if buffer != "":
container.append(buffer)
return container
答案 2 :(得分：0)
正则表达式是这项工作的完全错误的工具。关于为什么正则表达式不合适（If you want to know why, here's an online course），有一个冗长的解释。一个简单的递归解析器很容易编写来处理它，你可能在完成调试正则表达式之前完成它。
这是一个缓慢的一天，所以我自己把它自己写完，并附有doctests。
def parse(s):
"""
>>> parse('1')
['1']
>>> parse('1/2/3/4')
['1', '2', '3', '4']
>>> parse('1/(2)4/3')
['1', '2', '2', '2', '2', '3']
>>> parse('1/(2/3)2/4')
['1', '2', '3', '2', '3', '4']
>>> parse('(1/2/3)2')
['1', '2', '3', '1', '2', '3']
>>> parse('1/(2/3)s/4')
['1', '2', '3', '3', '2', '4']
>>> parse('(1/2/3)s')
['1', '2', '3', '3', '2', '1']
>>> parse('1/(2/(3)2/4)s/5')
['1', '2', '3', '3', '4', '4', '3', '3', '2', '5']
"""
return _parse(list(s))
def _parse(chars):
output = []
while len(chars):
c = chars.pop(0)
if c == '/':
continue
elif c == '(':
sub = _parse(chars)
nextC = chars.pop(0)
if nextC.isdigit():
n = int(nextC)
sub = n * sub
output.extend(sub)
elif nextC == 's':
output.extend(sub)
output.extend(reversed(sub))
elif c == ')':
return output
else:
output.extend(c)
return output
if __name__ == "__main__":
import doctest
doctest.testmod()