Question

所有

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

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

现在我想要一个缓冲区可以存储固定大小的* general iter尖端数据* 切片，使用上面的列表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记录表，它可能无法将所有这些读入列表 - 我没有那么多的物理记忆。以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 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()

Answer 2

我要切片的原始数据是非常大，例如8Giga文本文件...我可能无法阅读全部内容他们列入清单 - 我没有那么多物理内存。在那种情况下，是吗？可能只获得我想要的行/记录这个班级？

不，就目前而言，下面最初提出的类将迭代器转换为列表，它使你的情况100％无用。

只需使用石斑鱼成语（也在下面提到）。你必须要聪明地记住以前的小组。要节省内存，只存储您需要的以前的组。例如，如果您只需要最新的上一组，则可以将其存储在中单个变量previous_group。

如果您需要5个最新的上一组，则可以使用最大为5的collections.deque。

或者，您可以使用window惯用法来获取n组的滑动窗口......

鉴于你到目前为止告诉我们的内容，我不会为此定义一个类，因为我没有看到解决方案中有许多可重用的元素。

主要是，你想要的是grouper idiom：

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)

现在获取上一组只是跟踪列表索引。

python：如何在固定的缓冲区类中分割/存储iter指向的数据？

2 个答案: