python:如何在固定缓冲区类中切片/存储 iter 指向的数据？

Question

全部，

如您所知，通过 python iter 我们可以使用 iter.next() 来获取下一项数据。以列表为例:

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

现在我想要一个缓冲区可以存储 *general iter pointed data * slice in fixed size，使用上面的列表 iter 来演示我的问题。

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 的初学者，对设计 iter 类知之甚少，有人可以在这里分享我如何编写“IterPage”类的代码吗？

此外，通过下面的答案我发现如果我想要切片的原始数据非常大，例如 8Giga 文本文件或数据库中的 10^100 记录表，它可能无法将它们全部读入一份 list ——我没有那么多 body 内存。以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() itp 只能从数据库中获取接下来的 5 条记录？

谢谢!

PS:我在下面的链接中找到了一个方法: 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

既然你问的是设计，我会写一些关于你想要的东西——它不是迭代器。

迭代器的定义属性是它仅支持迭代，不支持随机访问。但是像 .first 和 .last 这样的方法进行随机访问，所以你要求的不是迭代器。

当然有容器允许这样做。它们被称为序列，其中最简单的是 list。它的.first方法写成[0]，它的.last是[-1]。

所以这是一个切片给定序列的对象。它存储一个 slice 对象的列表，这是 Python 用来切出列表部分的对象。 abstact base class 给出了类必须实现的方法才能成为序列。 序列。从它继承很好，因为如果您忘记实现所需的方法，它会抛出错误。

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()