Python 从多个较小的二维阵列形成一个较大的二维阵列

这个问题与之相反。我正在寻找一种从原始的大数组到小数组的通用方法：

array([[[ 0,  1,  2],
        [ 6,  7,  8]],    
       [[ 3,  4,  5],
        [ 9, 10, 11]], 
       [[12, 13, 14],
        [18, 19, 20]],    
       [[15, 16, 17],
        [21, 22, 23]]])

->

array([[ 0,  1,  2,  3,  4,  5],
       [ 6,  7,  8,  9, 10, 11],
       [12, 13, 14, 15, 16, 17],
       [18, 19, 20, 21, 22, 23]])

---

我目前正在开发一个解决方案，将在完成后发布，但希望看到其他（更好的）方法。

我希望我能正确地回答您的问题，假设我们有

a，b

：

>>> a = np.array([[1,2] ,[3,4]])
>>> b = np.array([[5,6] ,[7,8]])
    >>> a
    array([[1, 2],
           [3, 4]])
    >>> b
    array([[5, 6],
           [7, 8]])

为了使其成为一个大的2d阵列，请使用：

比如说,

c = np.arange(24).reshape((4,6))
print(c)
# [[ 0  1  2  3  4  5]
#  [ 6  7  8  9 10 11]
#  [12 13 14 15 16 17]
#  [18 19 20 21 22 23]]

print(blockshaped(c, 2, 3))
# [[[ 0  1  2]
#   [ 6  7  8]]

#  [[ 3  4  5]
#   [ 9 10 11]]

#  [[12 13 14]
#   [18 19 20]]

#  [[15 16 17]
#   [21 22 23]]]

print(unblockshaped(blockshaped(c, 2, 3), 4, 6))
# [[ 0  1  2  3  4  5]
#  [ 6  7  8  9 10 11]
#  [12 13 14 15 16 17]
#  [18 19 20 21 22 23]]

---

请注意，还有一个问题。它安排了 不同格式的块（使用更多轴），但它具有（1）的优点 始终返回视图，并且（2）能够处理任何

---

维度。

它适用于我目前测试的图像。如果进行进一步的测试，我们将进行测试。然而，这是一个不考虑速度和内存使用的解决方案

def unblockshaped(blocks, h, w):
    n, nrows, ncols = blocks.shape
    bpc = w/ncols
    bpr = h/nrows

    reconstructed = zeros((h,w))
    t = 0
    for i in arange(bpr):
        for j in arange(bpc):
            reconstructed[i*nrows:i*nrows+nrows,j*ncols:j*ncols+ncols] = blocks[t]
            t = t+1
    return reconstructed

另一种（简单）方法：

threedarray = ...
twodarray = np.array(map(lambda x: x.flatten(), threedarray))
print(twodarray.shape)

---

如果有人希望创建矩阵的平铺，可以使用以下解决方案：

from itertools import product
import numpy as np
def tiles(arr, nrows, ncols):
    """
    If arr is a 2D array, the returned list contains nrowsXncols numpy arrays
    with each array preserving the "physical" layout of arr.

    When the array shape (rows, cols) are not divisible by (nrows, ncols) then
    some of the array dimensions can change according to numpy.array_split.

    """
    rows, cols = arr.shape
    col_arr = np.array_split(range(cols), ncols)
    row_arr = np.array_split(range(rows), nrows)
    return [arr[r[0]: r[-1]+1, c[0]: c[-1]+1]
                     for r, c in product(row_arr, col_arr)]

---

它不适用于

c=np.arange（24）。重塑（（6,4））

print（unblockshaped（blockshaped（a，3，2），6，4））

块形

按预期返回。问题出在

unboshaped

是的，我把

重塑的参数顺序搞错了。现在试试。主要问题是
n*nrows*ncols=arr.size
不起作用。例如，对于像
size=17
或
size=47
这样的素数，您不能使用此方法。@SudiptaBasak:这不是问题，因为没有2D数组，
arr
，且
arr.size
等于素数。我正在搜索的是一种可以从较小数组重建大数组（图像）的方法。我需要它是通用的，以便它可以应用于不同大小的图像。就像jpeg中的切片一样。将图像切片为8×8块，对每个块执行操作，从块重建原始图像。感谢您的简洁+1.
threedarray = ...
twodarray = np.array(map(lambda x: x.flatten(), threedarray))
print(twodarray.shape)

from itertools import product
import numpy as np
def tiles(arr, nrows, ncols):
    """
    If arr is a 2D array, the returned list contains nrowsXncols numpy arrays
    with each array preserving the "physical" layout of arr.

    When the array shape (rows, cols) are not divisible by (nrows, ncols) then
    some of the array dimensions can change according to numpy.array_split.

    """
    rows, cols = arr.shape
    col_arr = np.array_split(range(cols), ncols)
    row_arr = np.array_split(range(rows), nrows)
    return [arr[r[0]: r[-1]+1, c[0]: c[-1]+1]
                     for r, c in product(row_arr, col_arr)]