Forkable iterator在Python中有它的实现吗？

Question

我所说的“forkable iterator”是一个常规迭代器，它使用fork()方法创建一个新的迭代器，它从原始迭代器的当前迭代点开始迭代。即使原始迭代器被进一步迭代，fork也会停留在它被分叉的地方，直到它本身不会被迭代为止。在

我的实际用例： 我有一个套接字连接，和一些通过它发送的“包”。连接可以在“接收器”之间共享，每个“包”都可以寻址到某个“接收器”“包”可以无序地来，所以每个“接收者”都可能接收不同“接收者”的包。更重要的是，如果一个“接收者”接收到不同“接收者”的“数据包”，那么这个“不同的接收者”必须仍然能够读取该数据包。在

为此，我想实现这样一个可分叉迭代器，它将表示连接，每个接收器将创建自己的fork，读取它并搜索为其寻址的“包”。在

有人知道我所说的任何实现吗？在

Answer 1

您正在查找^{} function：

Return n independent iterators from a single iterable.

请注意，实现将缓冲数据以服务于所有子迭代器：

This itertool may require significant auxiliary storage (depending on how much temporary data needs to be stored).

另外，您应该只使用返回的子迭代器；迭代源迭代器不会将数据传播到tee()iterables。在

Answer 2

这是我当前实现的forkable迭代器：

#!/usr/bin/env python
# coding=utf-8
from collections import Iterator, deque
import threading


class ForkableIterator(Iterator):
    def __init__(self, iterator, buffer=None, *args, **kwargs):
        self.iterator = iter(iterator)
        if buffer is None:
            self.buffer = deque()
        else:
            self.buffer = buffer

        args = iter(args)

        self.refs = kwargs.get('refs', next(args, {}))
        self.refs.setdefault('base', 0)
        self.pointer = kwargs.get('pointer', next(args, 0))
        self.lock = kwargs.get('lock', next(args, threading.Lock()))

    @property
    def pointer(self):
        return self.refs[self] + self.refs['base']

    @pointer.setter
    def pointer(self, value):
        self.refs[self] = value

    def __del__(self):
        del self.refs[self]

    def __iter__(self):
        return self

    def next(self):
        with self.lock:
            if len(self.buffer) - self.pointer == 0:
                elem = next(self.iterator)
                self.buffer.append(elem)
            else:
                if self.pointer == min(self.refs.itervalues()):
                    elem = self.buffer.popleft()
                    self.refs['base'] -= 1
                else:
                    elem = self.buffer[self.pointer]

            self.pointer += 1

            return elem

    def fork(self):
        return self.__class__(self.iterator, self.buffer,
                              refs=self.refs, pointer=self.pointer,
                              lock=self.lock)