Python不规则循环

Question

我正在寻找一种优雅的“Pythonic”方式来循环遍历特定大小的组中的输入。但是组的大小会有所不同，并且在开始解析之前您不知道特定组的大小。

实际上我只关心两种尺寸的组。我有一个很大的输入序列，它们的大小大多是 X，但偶尔大小为 Y。对于这个例子，假设 X=3 和 Y=4（我的实际问题是 X=7 和 Y=8）。直到元素组的中途，我才知道它是一组大小为 X 还是大小为 Y 的元素。

在我的问题中，我正在处理输入行，但为简化起见，我将用字符进行说明。

因此，如果它是一组特定大小的组，我知道我将始终以相同的顺序获得输入。因此，例如，如果它是一个大小 X 组，我将获得类型为 [a,a,b] 的元素，但如果它是一个大小为 Y 组，我将获得类型为 [a,a,c,b] 的元素。如果它是 'a' 类型的东西，我会想以某种方式处理它，而 'b' 另一个等等。

显然，我必须在某个时候测试一个元素，以确定它是属于一类还是另一类。如上所示，我不能只检查每个元素的类型，因为可能有两个相同的序列。此外，这些组在开始时可能是相同的模式，并且仅在接近结束时不同。在这个例子中，我最早可以通过测试第三个元素来检查我是否属于 X 号或 Y 号组（查看它是“c”类型还是“b”类型）。

我有一个带有暴露索引和两个额外变量的 for 循环的解决方案，但我想知道是否有更优雅的解决方案。

这是我的代码。我已将 pass 语句放在我将根据它的类型进行实际解析的位置：

counter = 0
group = 3
for index, x in enumerate("aabaabaacbaabaacbaabaab"):
    column = index - counter;
    print(str(index) + ", " + x + ", " + str(column))

    if column == 0:
        pass
    elif column == 1:
        pass
    elif column == 2:
        if x == 'c':
            pass
        elif x == 'd':
            group = 4
    elif column == 3:
        pass

    if column + 1 == group:
        counter += group 
        group = 3

在代码示例中，输入流是aabaabaacbaabaacbaabaab，因此是以下组：

1. aab (3)
2. aab (3)
3. aacb (4)
4. aab (3)
5. aacb (4)
6. aab (3)
7. aab (3)

Answer 1

我会使用一个生成器来收集这些组并确定每个组的大小，然后最终生成每个组：

def getGroups (iterable):
    group = []
    for item in iterable:
        group.append(item)
        if len(group) == 3 and group[2] == 'c':
            yield group
            group = []
        elif len(group) == 4 and group[2] == 'd':
            yield group
            group = []

for group in getGroups('abcabcabdcabcabdcabcabc'):
    print(group)

['a', 'b', 'c']
['a', 'b', 'c']
['a', 'b', 'd', 'c']
['a', 'b', 'c']
['a', 'b', 'd', 'c']
['a', 'b', 'c']
['a', 'b', 'c']

Answer 2

看起来你需要一个带回溯的简单自动机，例如：

def parse(tokens, patterns):

    backtrack = False
    i = 0

    while tokens:

        head, tail = tokens[:i+1], tokens[i+1:]
        candidates = [p for p in patterns if p.startswith(head)]
        match = any(p == head for p in candidates)

        if match and (backtrack or len(candidates) == 1 or not tail):
            yield head
            tokens = tail
            backtrack = False
            i = 0

        elif not candidates:
            if not i or backtrack:
                raise SyntaxError, head
            else:
                backtrack = True
                i -= 1

        elif tail:
            i += 1

        else:
            raise SyntaxError, head

tokens = 'aabaabcaabaabcxaabxxyzaabx'
patterns = ['aab', 'aabc', 'aabcx', 'x', 'xyz']

for p in parse(tokens, patterns):
    print p

Answer 3

对于您的特定示例，您可以使用正则表达式：

>>> s="aabaabaacbaabaacbaabaab"
>>> re.findall(r'aac?b', s)
['aab', 'aab', 'aacb', 'aab', 'aacb', 'aab', 'aab']

如果你想要一个做同样事情的解析器，你可以这样做：

def parser(string, patterns):
    patterns=sorted(patterns, key=len, reverse=True)
    i=0
    error=False
    while i<len(string) and not error:
        for pat in patterns:
            j=len(pat)
            if string[i:i+j]==pat:
                i+=j
                yield pat
                break
        else:
            error=True

    if error or i<len(string):
        raise SyntaxWarning, "Did not match the entire string"

>>> list(parser(s, ['aab', 'aacb']))
['aab', 'aab', 'aacb', 'aab', 'aacb', 'aab', 'aab']