如何将生成器或迭代器转换为递归列表 [英] How to convert generator or iterator to list recursively
问题描述
我想将生成器或迭代器转换为递归列表。
我在下面编写了一个代码，但它看起来很幼稚和丑陋，可能会在doctest中删除。
I want to convert generator or iterator to list recursively.
I wrote a code in below, but it looks naive and ugly, and may be dropped case in doctest.
Q1。帮帮我好版本。
Q2。如何指定对象是不可变的？
Q1. Help me good version.
Q2. How to specify object is immutable or not?
import itertools
def isiterable(datum):
return hasattr(datum, '__iter__')
def issubscriptable(datum):
return hasattr(datum, "__getitem__")
def eagerlize(obj):
""" Convert generator or iterator to list recursively.
return a eagalized object of given obj.
This works but, whether it return a new object, break given one.
test 1.0 iterator
>>> q = itertools.permutations('AB', 2)
>>> eagerlize(q)
[('A', 'B'), ('B', 'A')]
>>>
test 2.0 generator in list
>>> q = [(2**x for x in range(3))]
>>> eagerlize(q)
[[1, 2, 4]]
>>>
test 2.1 generator in tuple
>>> q = ((2**x for x in range(3)),)
>>> eagerlize(q)
([1, 2, 4],)
>>>
test 2.2 generator in tuple in generator
>>> q = (((x, (y for y in range(x, x+1))) for x in range(3)),)
>>> eagerlize(q)
([(0, [0]), (1, [1]), (2, [2])],)
>>>
test 3.0 complex test
>>> def test(r):
... for x in range(3):
... r.update({'k%s'%x:x})
... yield (n for n in range(1))
>>>
>>> def creator():
... r = {}
... t = test(r)
... return r, t
>>>
>>> a, b = creator()
>>> q = {'b' : a, 'a' : b}
>>> eagerlize(q)
{'a': [[0], [0], [0]], 'b': {'k2': 2, 'k1': 1, 'k0': 0}}
>>>
test 3.1 complex test (other dict order)
>>> a, b = creator()
>>> q = {'b' : b, 'a' : a}
>>> eagerlize(q)
{'a': {'k2': 2, 'k1': 1, 'k0': 0}, 'b': [[0], [0], [0]]}
>>>
test 4.0 complex test with tuple
>>> a, b = creator()
>>> q = {'b' : (b, 10), 'a' : (a, 10)}
>>> eagerlize(q)
{'a': ({'k2': 2, 'k1': 1, 'k0': 0}, 10), 'b': ([[0], [0], [0]], 10)}
>>>
test 4.1 complex test with tuple (other dict order)
>>> a, b = creator()
>>> q = {'b' : (b, 10), 'a' : (a, 10)}
>>> eagerlize(q)
{'a': ({'k2': 2, 'k1': 1, 'k0': 0}, 10), 'b': ([[0], [0], [0]], 10)}
>>>
"""
def loop(obj):
if isiterable(obj):
for k, v in obj.iteritems() if isinstance(obj, dict) \
else enumerate(obj):
if isinstance(v, tuple):
# immutable and iterable object must be recreate,
# but realy only tuple?
obj[k] = tuple(eagerlize(list(obj[k])))
elif issubscriptable(v):
loop(v)
elif isiterable(v):
obj[k] = list(v)
loop(obj[k])
b = [obj]
loop(b)
return b[0]
def _test():
import doctest
doctest.testmod()
if __name__=="__main__":
_test()
推荐答案
为避免严重影响原始对象，你基本上需要一个 copy.deepcopy ...巧妙地调整，因为你需要将生成器和迭代器转换为列表（深度复制不会对生成器进行深度复制）。请注意，遗憾的是，对原始对象的一些效果是不可避免的，因为生成器和迭代器耗尽作为迭代它们的副作用（无论是将它们转换为列表还是其他任何其他对象）目的） - 因此，根本不可能两者单独保留原始对象并且将该生成器或其他迭代器变为变体深度复制中的列表结果。
To avoid badly affecting the original object, you basically need a variant of copy.deepcopy... subtly tweaked because you need to turn generators and iterators into lists (deepcopy wouldn't deep-copy generators anyway). Note that some effect on the original object is unfortunately inevitable, because generators and iterators are "exhausted" as a side effect of iterating all the way on them (be it to turn them into lists or for any other purpose) -- therefore, there is simply no way you can both leave the original object alone and have that generator or other iterator turned into a list in the "variant-deepcopied" result.
遗憾的是，副本模块并未编写为自定义模块，因此替代方案是复制 - 粘贴编辑，或一个微妙的（叹气）猴子补丁，用于（双重叹息）私有模块变量 _deepcopy_dispatch （这意味着你的补丁版本可能无法在Python版本中存活升级，假设从2.6到2.7，假设）。另外，每次使用 eagerize 后都必须卸载monkey-patch（以避免影响 deepcopy的其他用途）。所以，我们假设我们选择了复制粘贴编辑路线。
The copy module is unfortunately not written to be customized, so the alternative ares, either copy-paste-edit, or a subtle (sigh) monkey-patch hinging on (double-sigh) the private module variable _deepcopy_dispatch (which means your patched version might not survive a Python version upgrade, say from 2.6 to 2.7, hypothetically). Plus, the monkey-patch would have to be uninstalled after each use of your eagerize (to avoid affecting other uses of deepcopy). So, let's assume we pick the copy-paste-edit route instead.
假设我们从最新版本开始，即在线版本此处。当然，您需要重命名模块;在145行将外部可见函数 deepcopy 重命名为 eagerize ;实质性变化是在第161-165行，在所述版本中，注释为：
Say we start with the most recent version, the one that's online here. You need to rename module, of course; rename the externally visible function deepcopy to eagerize at line 145; the substantial change is at lines 161-165, which in said version, annotated, are:
161 : copier = _deepcopy_dispatch.get(cls)
162 : if copier:
163 : y = copier(x, memo)
164 : else:
165 : tim_one 18729 try:
我们需要在第163行和第164行之间插入逻辑否则如果它可迭代将其扩展到列表（即使用函数） _deepcopy_list 作为复印机。所以这些行变为：
We need to insert between line 163 and 164 the logic "otherwise if it's iterable expand it to a list (i.e., use the function _deepcopy_list as the copier". So these lines become:
161 : copier = _deepcopy_dispatch.get(cls)
162 : if copier:
163 : y = copier(x, memo)
elif hasattr(cls, '__iter__'):
y = _deepcopy_list(x, memo)
164 : else:
165 : tim_one 18729 try:
这就是全部：只增加两行。注意我单独留下原始行号以使其完全清楚其中正好需要插入这两行，并且没有对两行进行编号。您还需要将标识符 deepcopy （间接递归调用）的其他实例重命名为 eagerize 。
That's all: just there two added lines. Note that I've left the original line numbers alone to make it perfectly clear where exactly these two lines need to be inserted, and not numbered the two new lines. You also need to rename other instances of identifier deepcopy (indirect recursive calls) to eagerize.
您还应该删除第66-144行（您不关心的浅拷贝功能）并适当调整第1-65行（文档字符串，导入， __ all__ 等。）
You should also remove lines 66-144 (the shallow-copy functionality that you don't care about) and appropriately tweak lines 1-65 (docstrings, imports, __all__, etc).
当然，您想要处理<$>明文版本的 copy.py ，这里，而不是我所指的带注释的版本（我使用带注释的版本只是为了明确需要更改的位置！ - ）。
Of course, you want to work off a copy of the plaintext version of copy.py, here, not the annotated version I've been referring to (I used the annotated version just to clarify exactly where the changes were needed!-).
这篇关于如何将生成器或迭代器转换为递归列表的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！
