在 Python 中为字符串实现前瞻迭代器

Question

我正在做一些需要一个前瞻标记的解析。我想要的是一个快速函数（或类？），它会接受一个迭代器并将其转换为表单中的元组列表（令牌，前瞻），这样：

>>> a = ['a', 'b', 'c', 'd']
>>> list(lookahead(a))
[('a', 'b'), ('b', 'c'), ('c', 'd'), ('d', None)]

基本上，这对于在迭代器中向前看会很方便：

for (token, lookahead_1) in lookahead(a):
  pass

不过，我不确定在 itertools 中是否有该技术或函数的名称已经可以做到这一点。有什么想法吗？

谢谢！

Answer 1

如果您只使用列表，还有更简单的方法 - 请参阅 Sven 的回答。这是通用迭代器的一种方法

>>> from itertools import tee, izip_longest
>>> a = ['a', 'b', 'c', 'd']
>>> it1, it2 = tee(iter(a))
>>> next(it2)  # discard this first value
'a'
>>> [(x,y) for x,y in izip_longest(it1, it2)]
    # or just list(izip_longest(it1, it2))
[('a', 'b'), ('b', 'c'), ('c', 'd'), ('d', None)]

这是在你的问题中的 for 循环中使用它的方法。

>>> it1,it2 = tee(iter(a))
>>> next(it2)
'a'
>>> for (token, lookahead_1) in izip_longest(it1,it2):
...     print token, lookahead_1
... 
a b
b c
c d
d None

最后，这是您正在寻找的功能

>>> def lookahead(it):
...     it1, it2 = tee(iter(it))
...     next(it2)
...     return izip_longest(it1, it2)
... 
>>> for (token, lookahead_1) in lookahead(a):
...     print token, lookahead_1
... 
a b
b c
c d
d None

Answer 2

我喜欢 Sven's 和 gnibbler's 的答案，但出于某种原因，我很高兴自己推出了生成器。

def lookahead(iterable, null_item=None):
    iterator = iter(iterable) # in case a list is passed
    prev = iterator.next()
    for item in iterator:
        yield prev, item
        prev = item
    yield prev, null_item

测试：

>>> for i in lookahead(x for x in []):
...     print i
... 
>>> for i in lookahead(x for x in [0]):
...     print i
... 
(0, None)
>>> for i in lookahead(x for x in [0, 1, 2]):
...     print i
... 
(0, 1)
(1, 2)
(2, None)

编辑：Karl 和 ninjagecko 提出了一个很好的观点——传入的序列可能包含None，因此使用None 作为最终的前瞻值可能会导致歧义。但是没有显而易见的替代方案；在许多情况下，模块级常量可能是最好的方法，但对于像这样的一次性函数来说可能是矫枉过正——更不用说bool(object()) == True 的事实，这可能导致意外行为。相反，我添加了一个默认为 None 的 null_item 参数——这样用户可以传入任何对他们的需求有意义的参数，无论是简单的 object() 哨兵，还是他们自己创建的常量，或者甚至是具有特殊行为的类实例。因为大多数时候None 是显而易见的，甚至可能是预期的行为，所以我将None 作为默认设置。

Answer 3

对a 列表执行此操作的常用方法是

from itertools import izip_longest
for token, lookahead in izip_longest(a, a[1:]):
    pass

对于最后一个令牌，您将获得 None 作为前瞻令牌。

如果要避免复制a[1:]引入的列表，可以使用islice(a, 1, None)代替。有关适用于任意迭代的轻微修改，请参阅answer by gnibbler。对于一个简单、易于掌握的生成器函数也适用于任意迭代，请参阅the answer by senderle。

Answer 4

您可以在这里找到问题的答案：Using lookahead with generators。

Answer 5

我认为所有这些答案都不正确，因为如果您的列表包含 None，它们会导致无法预料的错误。这是我的看法：

SEQUENCE_END = object()

def lookahead(iterable):
    iter = iter(iterable)
    current = next(iter)
    for ahead in iter:
        yield current,ahead
        current = ahead
    yield current,SEQUENCE_END

例子：

>>> for x,ahead in lookahead(range(3)):
>>>     print(x,ahead)
0, 1
1, 2
2, <object SEQUENCE_END>

这个答案更好的例子：

def containsDoubleElements(seq):
    """
        Returns whether seq contains double elements, e.g. [1,2,2,3]
    """
    return any(val==nextVal for val,nextVal in lookahead(seq))

>>> containsDoubleElements([None])
False  # correct!

def containsDoubleElements_BAD(seq):
    """
        Returns whether seq contains double elements, e.g. [1,2,2,3]
    """
    return any(val==nextVal for val,nextVal in lookahead_OTHERANSWERS(seq))

>>> containsDoubleElements([None])
True  # incorrect!