调整迭代器，使其行为类似于 Python 中的文件 object

Question

我有一个生成器生成字符串列表。 Python 中是否有一个实用程序/适配器可以使它看起来像一个文件？

例如，

>>> def str_fn():
...     for c in 'a', 'b', 'c':
...         yield c * 3
... 
>>> for s in str_fn():
...     print s
... 
aaa
bbb
ccc
>>> stream = some_magic_adaptor(str_fn())
>>> while True:
...    data = stream.read(4)
...    if not data:
...        break
...    print data
aaab
bbcc
c

因为数据可能很大并且需要流式传输（每个片段是几千字节，整个 stream 是几十兆字节），我不想在将整个生成器传递给 stream 适配器之前急切地评估整个生成器。

Answer 1

执行此操作的“正确”方法是从标准Python io抽象基类继承。 但是，似乎Python不允许您提供原始文本类，并使用任何类型的缓冲读取器包装它。

继承的最佳类是TextIOBase 。 这是一个实现，处理readline和read同时注意性能。 （ 要点 ）

import io

class StringIteratorIO(io.TextIOBase):

    def __init__(self, iter):
        self._iter = iter
        self._left = ''

    def readable(self):
        return True

    def _read1(self, n=None):
        while not self._left:
            try:
                self._left = next(self._iter)
            except StopIteration:
                break
        ret = self._left[:n]
        self._left = self._left[len(ret):]
        return ret

    def read(self, n=None):
        l = []
        if n is None or n < 0:
            while True:
                m = self._read1()
                if not m:
                    break
                l.append(m)
        else:
            while n > 0:
                m = self._read1(n)
                if not m:
                    break
                n -= len(m)
                l.append(m)
        return ''.join(l)

    def readline(self):
        l = []
        while True:
            i = self._left.find('\n')
            if i == -1:
                l.append(self._left)
                try:
                    self._left = next(self._iter)
                except StopIteration:
                    self._left = ''
                    break
            else:
                l.append(self._left[:i+1])
                self._left = self._left[i+1:]
                break
        return ''.join(l)

Answer 2

这是一个应该从块中读取迭代器的解决方案。

class some_magic_adaptor:
  def __init__( self, it ):
    self.it = it
    self.next_chunk = ""
  def growChunk( self ):
    self.next_chunk = self.next_chunk + self.it.next()
  def read( self, n ):
    if self.next_chunk == None:
      return None
    try:
      while len(self.next_chunk)<n:
        self.growChunk()
      rv = self.next_chunk[:n]
      self.next_chunk = self.next_chunk[n:]
      return rv
    except StopIteration:
      rv = self.next_chunk
      self.next_chunk = None
      return rv


def str_fn():
  for c in 'a', 'b', 'c':
    yield c * 3

ff = some_magic_adaptor( str_fn() )

while True:
  data = ff.read(4)
  if not data:
    break
  print data

Answer 3

StringIO的问题是您必须预先将所有内容加载到缓冲区中。 如果发电机是无限的，这可能是一个问题:)

from itertools import chain, islice
class some_magic_adaptor(object):
    def __init__(self, src):
        self.src = chain.from_iterable(src)
    def read(self, n):
        return "".join(islice(self.src, None, n))

Answer 4

有一个名为werkzeug.contrib.iterio.IterIO但请注意它将整个迭代器存储在其内存中（直到您将其作为文件读取），因此它可能不合适。

http://werkzeug.pocoo.org/docs/contrib/iterio/

资料来源： https ： //github.com/mitsuhiko/werkzeug/blob/master/werkzeug/contrib/iterio.py

readline / iter上的一个漏洞： https ： //github.com/mitsuhiko/werkzeug/pull/500

Answer 5

这是John和Matt的答案的修改版本，可以读取字符串的列表/生成器并输出字节数组

import itertools as it
from io import TextIOBase

class IterStringIO(TextIOBase):
    def __init__(self, iterable=None):
        iterable = iterable or []
        self.iter = it.chain.from_iterable(iterable)

    def not_newline(self, s):
        return s not in {'\n', '\r', '\r\n'}

    def write(self, iterable):
        to_chain = it.chain.from_iterable(iterable)
        self.iter = it.chain.from_iterable([self.iter, to_chain])

    def read(self, n=None):
        return bytearray(it.islice(self.iter, None, n))

    def readline(self, n=None):
        to_read = it.takewhile(self.not_newline, self.iter)
        return bytearray(it.islice(to_read, None, n))

用法：

ff = IterStringIO(c * 3 for c in ['a', 'b', 'c'])

while True:
    data = ff.read(4)

    if not data:
        break

    print data

aaab
bbcc
c

替代用法：

ff = IterStringIO()
ff.write('ddd')
ff.write(c * 3 for c in ['a', 'b', 'c'])

while True:
    data = ff.read(4)

    if not data:
        break

    print data

ddda
aabb
bccc

Answer 6

看看马特的答案，我可以看到并不总是需要实现所有的读取方法。 read1可能就足够了，其描述如下：

读取并返回大小字节，最多一次调用底层原始流的read（）...

然后它可以用io.TextIOWrapper包装，例如，它具有readline实现。 作为一个例子，这里是从S3（亚马逊简单存储服务） boto.s3.key.Key流式传输CSV文件，它实现了读取的迭代器。

import io
import csv

from boto import s3


class StringIteratorIO(io.TextIOBase):

    def __init__(self, iter):
        self._iterator = iter
        self._buffer = ''

    def readable(self):
        return True

    def read1(self, n=None):
        while not self._buffer:
            try:
                self._buffer = next(self._iterator)
            except StopIteration:
                break
        result = self._buffer[:n]
        self._buffer = self._buffer[len(result):]
        return result


conn = s3.connect_to_region('some_aws_region')
bucket = conn.get_bucket('some_bucket')
key = bucket.get_key('some.csv')    

fp = io.TextIOWrapper(StringIteratorIO(key))
reader = csv.DictReader(fp, delimiter = ';')
for row in reader:
    print(row)

更新

这是相关问题的答案 ，看起来好一点。 它继承了io.RawIOBase并覆盖了readinto 。 在Python 3中它已经足够了，所以不是在io.BufferedReader中包装IterStream ， io.BufferedReader可以将它包装在io.TextIOWrapper 。 在Python 2中需要read1 ，但它可以通过readinto简单地表达。

Answer 7

这正是stringIO的用途。

>>> import StringIO
>>> some_var = StringIO.StringIO("Hello World!")
>>> some_var.read(4)
'Hell'
>>> some_var.read(4)
'o Wo'
>>> some_var.read(4)
'rld!'
>>>

或者，如果你想做它听起来像

Class MyString(StringIO.StringIO):
     def __init__(self,*args):
         StringIO.StringIO.__init__(self,"".join(args))

那么你可以简单

xx = MyString(*list_of_strings)

Answer 8

如果你只需要一个read方法，那么这就足够了

def to_file_like_obj(iterable, base):
    chunk = base()
    offset = 0
    it = iter(iterable)

    def up_to_iter(size):
        nonlocal chunk, offset

        while size:
            if offset == len(chunk):
                try:
                    chunk = next(it)
                except StopIteration:
                    break
                else:
                    offset = 0
            to_yield = min(size, len(chunk) - offset)
            offset = offset + to_yield
            size -= to_yield
            yield chunk[offset - to_yield:offset]

    class FileLikeObj:
        def read(self, size=-1):
            return base().join(up_to_iter(float('inf') if size is None or size < 0 else size))

    return FileLikeObj()

可用于可迭代的产生str

my_file = to_file_like_object(str_fn, str)

或者，如果您有一个可迭代的产生bytes而不是str ，并且您想要一个类似文件的对象，其 read 方法返回bytes

my_file = to_file_like_object(bytes_fn, bytes)

我认为这种模式有一些不错的特性：

• 代码不多， str和bytes都可以用
• 在可迭代生成小块和大块的两种情况下（在可迭代的末尾除外），准确返回长度要求的内容
• 不append str / bytes - 所以避免复制
• 利用切片——因此也避免了复制，因为应该是整个实例的str / bytes切片将返回完全相同的实例

Answer 9

首先，您的生成器必须生成字节对象。 虽然没有内置任何内容，但您可以使用http://docs.python.org/library/stringio.html和itertools.chain的组合。