Python：如何在固定缓冲区类中切片/存储迭代指向的数据？

Question

大家好，

如你所知，在Python中，我们可以通过iter来使用iter.next()来获取下一个数据项。举个例子，假设我们有一个列表：

l =  [x for x in range(100)]
itl = iter(l)
itl.next()            # 0
itl.next()            # 1

现在我想要一个缓冲区，可以存储*一般的迭代器指向的数据*，并且这个缓冲区的大小是固定的，接下来用上面的列表迭代器来演示我的问题。

class IterPage(iter, size):
      # class code here

itp = IterPage(itl, 5)

我想要的是

print itp.first()   # [0,1,2,3,4]
print itp.next()    # [5,6,7,8,9]
print itp.prev()    # [0,1,2,3,4]
len(itp)            # 20   # 100 item / 5 fixed size = 20    
print itp.last()   # [96,97,98,99,100]


for y in itp:           # iter may not support "for" and len(iter) then something alike code also needed here  
    print y
[0,1,2,3,4]
[5,6,7,8,9]
...
[96,97,98,99,100]

这不是作业，但作为一个Python初学者，我对如何设计一个迭代器类了解不多，能不能有人分享一下如何在这里编写“IterPage”这个类的代码？

另外，通过下面的回答我发现，如果我想要切片的原始数据非常大，比如一个8G的文本文件或者一个有10^100条记录的数据库表，可能无法将它们全部读入一个列表中——因为我没有那么多的物理内存。举个例子，看看Python文档中的代码片段：

http://docs.python.org/library/sqlite3.html#

>>> c = conn.cursor()
>>> c.execute('select * from stocks order by price')
>>> for row in c:
...    print row
...
(u'2006-01-05', u'BUY', u'RHAT', 100, 35.14)
(u'2006-03-28', u'BUY', u'IBM', 1000, 45.0)
(u'2006-04-06', u'SELL', u'IBM', 500, 53.0)
(u'2006-04-05', u'BUY', u'MSOFT', 1000, 72.0)

如果这里有大约10^100条记录，那么在这种情况下，我是否可以通过这个类只存储我想要的行/记录，使用itp = IterPage(c, 5)？如果我调用itp.next()，它能否只从数据库中获取接下来的5条记录？

谢谢！

附注：我在下面的链接中找到了一种方法：
http://code.activestate.com/recipes/577196-windowing-an-iterable-with-itertools/

我还发现有人想要制作一个itertools.iwindow()函数，但这个提议被拒绝了。
http://mail.python.org/pipermail/python-dev/2006-May/065304.html

Answer 1

我想处理的原始数据非常大，比如一个8GB的文本文件……我可能无法把所有数据都读入一个列表，因为我的物理内存不够。在这种情况下，能不能只通过这个类获取我想要的行或记录呢？

不行，下面提到的这个类现在的设计是把迭代器转换成一个列表，这样在你的情况下就完全没用了。

你可以使用“grouper”这个方法（下面也提到过）。你需要聪明地记住之前的组。为了节省内存，只存储那些你需要的之前的组。例如，如果你只需要最近的一个组，可以把它存储在一个变量里，叫做previous_group。

如果你需要最近的5个组，可以使用一个最大大小为5的collections.deque。

或者，你可以使用window这个方法来获取一个包含n个组的滑动窗口……

根据你目前告诉我们的情况，我不建议为此定义一个类，因为我觉得这个解决方案没有很多可以重复使用的部分。

---

主要是，你想要的功能可以通过grouper方法来实现：

In [22]: l =  xrange(100)    
In [23]: itl=iter(l)    
In [24]: import itertools    
In [25]: for y in itertools.izip(*[itl]*5):
   ....:     print(y)
(0, 1, 2, 3, 4)
(5, 6, 7, 8, 9)
(10, 11, 12, 13, 14)
...
(95, 96, 97, 98, 99)

调用next没有问题：

In [28]: l =  xrange(100)

In [29]: itl=itertools.izip(*[iter(l)]*5)

In [30]: next(itl)
Out[30]: (0, 1, 2, 3, 4)

In [31]: next(itl)
Out[31]: (5, 6, 7, 8, 9)

但要做一个previous方法就比较麻烦，因为迭代器不是这样工作的。迭代器的设计是生成值而不记住过去的值。如果你需要所有过去的值，那你需要一个列表，而不是迭代器：

In [32]: l =  xrange(100)
In [33]: ll=list(itertools.izip(*[iter(l)]*5))

In [34]: ll[0]
Out[34]: (0, 1, 2, 3, 4)

In [35]: ll[1]
Out[35]: (5, 6, 7, 8, 9)

# Get the last group
In [36]: ll[-1]
Out[36]: (95, 96, 97, 98, 99)

现在获取之前的组只需要跟踪列表的索引就可以了。

Answer 2

既然你问到了设计，我就简单说说你想要的东西——这不是一个迭代器。

迭代器的一个重要特点是它只支持迭代，而不支持随机访问。但是像 .first 和 .last 这样的函数是随机访问，所以你想要的东西并不是一个迭代器。

当然，有一些容器可以做到这一点。它们被称为序列，最简单的就是 list（列表）。它的 .first 方法用 [0] 表示，而 .last 用 [-1] 表示。

这里有一个对象可以对给定的序列进行切片。它存储了一系列 slice 对象，这就是 Python 用来从列表中切出部分内容的工具。一个类要成为序列，必须实现一些方法，这些方法由 抽象基类 Sequence 定义。继承这个类是很不错的选择，因为如果你忘记实现某个必要的方法，它会抛出错误。

from collections import Sequence

class SlicedList(Sequence):
    def __init__(self, iterable, size):
        self.seq = list(iterable)
        self.slices = [slice(i,i+size) for i in range(0,len(self.seq), size)]

    def __contains__(self, item):
        # checks if a item is in this sequence
        return item in self.seq

    def __iter__(self):
        """ iterates over all slices """
        return (self.seq[slice] for slice in self.slices)

    def __len__(self):
        """ implements len( .. ) """
        return len(self.slices)

    def __getitem__(self, n):
        # two forms of getitem ..
        if isinstance(n, slice):
            # implements sliced[a:b]
            return [self.seq[x] for x in self.slices[n]]
        else:
            # implements sliced[a]
            return self.seq[self.slices[n]]

s = SlicedList(range(100), 5)

# length
print len(s) # 20

#iteration
print list(s) # [[0, 1, 2, 3, 4], [5, 6, 7, 8, 9], ... , [95, 96, 97, 98, 99]]
# explicit iteration:
it = iter(s)
print next(it) # [0, 1, 2, 3, 4]

# we can slice it too
print s[0], s[-1] # [0, 1, 2, 3, 4] [95, 96, 97, 98, 99]
# get the first two
print s[0:2] # [[0, 1, 2, 3, 4], [5, 6, 7, 8, 9]]
# every other item
print s[::2] # [[0, 1, 2, 3, 4], [10, 11, 12, 13, 14], [20, 21, 22, 23, 24], ... ]

如果你真的想要像 .start 这样的函数（不过这有什么用呢，实际上只是 [0] 的一种冗长写法），你可以像这样写一个类：

class Navigator(object):    
    def __init__(self, seq):
        self.c = 0
        self.seq = seq

    def next(self):
        self.c +=1
        return self.seq[self.c]

    def prev(self):
        self.c -=1
        return self.seq[self.c]

    def start(self):
        self.c = 0
        return self.seq[self.c]

    def end(self):
        self.c = len(self.seq)-1
        return self.seq[self.c]

n = Navigator(SlicedList(range(100), 5))

print n.start(), n.next(), n.prev(), n.end()