Question

有许多用于展平嵌套列表的方法。我将复制解决方案仅供参考：

def flatten(x):
    result = []
    for el in x:
      if hasattr(el, "__iter__") and not isinstance(el, basestring):
        result.extend(flatten(el))
      else:
        result.append(el)
    return result

我感兴趣的是逆操作，它将列表重建为其原始格式。例如：

L = [[array([[  24, -134],[ -67, -207]])], 
     [array([[ 204,  -45],[  99, -118]])], 
     [array([[  43, -154],[-122,  168]]), array([[  33, -110],[ 147,  -26],[ -49, -122]])]]

# flattened version

L_flat = [24, -134, -67, -207, 204, -45, 99, -118, 43, -154, -122, 168, 33, -110, 147, -26, -49, -122]

是否有一种有效的扁平化方法，保存指数并重建为原始格式？

请注意，列表可以是任意深度，并且可能没有规则形状，并且将包含不同尺寸的数组。

当然，扁平化功能也应该更改为存储列表的结构和numpy数组的形状。

Answer 1

我一直在寻找一个解决扁平和不平坦的numpy数组嵌套列表的解决方案，但只找到了这个未解决的问题，所以我想出了这个：

def _flatten(values):
    if isinstance(values, np.ndarray):
        yield values.flatten()
    else:
        for value in values:
            yield from _flatten(value)

def flatten(values):
    # flatten nested lists of np.ndarray to np.ndarray
    return np.concatenate(list(_flatten(values)))

def _unflatten(flat_values, prototype, offset):
    if isinstance(prototype, np.ndarray):
        shape = prototype.shape
        new_offset = offset + np.product(shape)
        value = flat_values[offset:new_offset].reshape(shape)
        return value, new_offset
    else:
        result = []
        for value in prototype:
            value, offset = _unflatten(flat_values, value, offset)
            result.append(value)
        return result, offset

def unflatten(flat_values, prototype):
    # unflatten np.ndarray to nested lists with structure of prototype
    result, offset = _unflatten(flat_values, prototype, 0)
    assert(offset == len(flat_values))
    return result

示例：

a = [
    np.random.rand(1),
    [
        np.random.rand(2, 1),
        np.random.rand(1, 2, 1),
    ],
    [[]],
]

b = flatten(a)

# 'c' will have values of 'b' and structure of 'a'
c = unflatten(b, a)

输出：

a:
[array([ 0.26453544]), [array([[ 0.88273824],
       [ 0.63458643]]), array([[[ 0.84252894],
        [ 0.91414218]]])], [[]]]
b:
[ 0.26453544  0.88273824  0.63458643  0.84252894  0.91414218]
c:
[array([ 0.26453544]), [array([[ 0.88273824],
       [ 0.63458643]]), array([[[ 0.84252894],
        [ 0.91414218]]])], [[]]]

许可证：WTFPL

Answer 2

你构建了一个悖论：你想要展平对象，但你不想展平对象，在对象的某处保留其结构信息。

所以这样做的pythonic方法是而不是来展平对象，而是编写一个具有__iter__的类，它允许你按顺序（即以平面的方式）浏览底层对象的元素。这将与转换为扁平物体的速度一样快（如果每个元素仅应用一次），并且您不会复制或更改原始的非扁平容器。

Answer 3

以下是我提出的结果，它比迭代嵌套列表并单独加载快〜30倍。

def flatten(nl):
    l1 = [len(s) for s in itertools.chain.from_iterable(nl)]
    l2 = [len(s) for s in nl]

    nl = list(itertools.chain.from_iterable(
        itertools.chain.from_iterable(nl)))

    return nl,l1,l2

def reconstruct(nl,l1,l2):
    return np.split(np.split(nl,np.cumsum(l1)),np.cumsum(l2))[:-1]

L_flat,l1,l2 = flatten(L)
L_reconstructed = reconstruct(L_flat,l1,l2)

更好的解决方案解决方案可以迭代地处理任意数量的嵌套级别。

展平和取消平坦的numpy数组列表

3 个答案: