Question

假设我有一个非常大的整数列表，占用了大量的内存。如果列表的整数是偶数增量，那么我可以很容易地将列表表示为占用相对没有内存的迭代器。但是对于更复杂的模式，将此列表表示为迭代器将变得更加困难。

是否有一个Python包可以分析整数列表并返回＆＃34;优化的＆＃34;迭代器？或者我可以研究的方法来实现这个目标吗？

Answer 1

我的概念证明，使用lzma库（backport for python 2）压缩内存。您可以使用磁盘上的文件代替内存缓冲区：

import io
import random
import struct
import sys

from backports import lzma

# Create array of integers with some duplicates
data = []
for i in xrange(0, 2000):
    data += [random.randint(-sys.maxint, sys.maxint)] * random.randint(0, 500)

print('Uncompressed: {}'.format(len(data)))
buff = io.BytesIO()

fmt = 'i'  # check https://docs.python.org/3/library/struct.html#format-characters
lzma_writer = lzma.LZMAFile(buff, 'wb')
for i in data:
    lzma_writer.write(struct.pack(fmt, i))
lzma_writer.close()
print('Compressed: {}'.format(len(buff.getvalue())))

buff.seek(0)
lzma_reader = lzma.LZMAFile(buff, 'rb')

size_of = struct.calcsize(fmt)


def generate():
    r = lzma_reader.read(size_of)
    while len(r) != 0:
        yield struct.unpack(fmt, r)[0]
        r = lzma_reader.read(size_of)


# Test if it is same array
res = list(generate())
print res == data

结果：

Uncompressed: 496225
Compressed: 11568
True

Answer 2

我同意Efron Licht的观点：它完全取决于特定列表的复杂性（不是说＆＃39; compress＆＃39;）。除非您的列表简单地表达为生成器，否则您唯一的选择是使用Bartek Jablonski的答案。

Answer 3

您正在寻找发电机。您可以封装所有自定义逻辑。问题有点模糊，所以可能有助于了解这是否有助于你

def moreDataExists(index):
    # Your stop condition
    return True

def getNextIndex(index):
    # Your complicated pattern of going from one index to the next.
    return index

def generator(yourData):
    index = None
    while moreDataExists(index):
        index = getNextIndex(index)
        yield yourData[index]


for d in generator(data):
    doSomethingWith(d)

Answer 4

这非常简单 - 只需使用生成器包装过滤后的迭代器，例如：

for i in (_ for _ in range(int(1e7)) if str(_)==str(_)[::-1]):
    if str(i**2)==str(i**2)[::-1]:
        print(i)

如何为一长串整数创建优化的迭代器？

4 个答案: