将numpy数组切片以使其达到所需的形状

Question

令人惊讶的是，我在互联网上找不到答案。 我有一个 n 维的 numpy 数组。 例如：2-D np 数组：

array([['34.5500000', '36.9000000', '37.3200000', '37.6700000'],
       ['41.7900000', '44.8000000', '48.2600000', '46.1800000'],
       ['36.1200000', '37.1500000', '39.3100000', '38.1000000'],
       ['82.1000000', '82.0900000', '76.0200000', '77.7000000'],
       ['48.0100000', '51.2500000', '51.1700000', '52.5000000', '55.2500000'],
       ['39.7500000', '39.5000000', '36.8100000', '37.2500000']], dtype=object)

如您所见，第5行由5个元素组成，我想让第五行消失，可以使用类似以下的内容：

np.slice(MyArray, [6,4]) 

[6,4] 是一种形状。我真的不想遍历维度并削减它们。我尝试了 resize 方法，但它没有返回任何内容！

- user6557479

---

实际上，你的数组只是一个列表的向量。 - wim

@wim 但是所有的np n维数组都是向量的向量...n-1次....的列表，不是吗？ - user6557479

这个数组的形状是什么？MyArray.shape？ - hpaulj

np.array 并没有被实现为列表的列表。显示效果看起来是这样的，但在内部 numpy 并不是这样工作的。但在这种情况下，您确实有一个列表数组。 - hpaulj

Answer 1

这不是一个二维数组。它是一个一维数组，其元素是对象，在这种情况下是一些包含4个元素的列表和一个包含5个元素的列表。而这些列表包含字符串。

In [577]: np.array([['34.5500000', '36.9000000', '37.3200000', '37.6700000'],
     ...:        ['41.7900000', '44.8000000', '48.2600000', '46.1800000'],
     ...:        ['36.1200000', '37.1500000', '39.3100000', '38.1000000'],
     ...:        ['82.1000000', '82.0900000', '76.0200000', '77.7000000'],
     ...:        ['48.0100000', '51.2500000', '51.1700000', '52.5000000', '55.25
     ...: 00000'],
     ...:        ['39.7500000', '39.5000000', '36.8100000', '37.2500000']], dtyp
     ...: e=object)
Out[577]: 
array([['34.5500000', '36.9000000', '37.3200000', '37.6700000'],
       ['41.7900000', '44.8000000', '48.2600000', '46.1800000'],
       ['36.1200000', '37.1500000', '39.3100000', '38.1000000'],
       ['82.1000000', '82.0900000', '76.0200000', '77.7000000'],
       ['48.0100000', '51.2500000', '51.1700000', '52.5000000', '55.2500000'],
       ['39.7500000', '39.5000000', '36.8100000', '37.2500000']], dtype=object)
In [578]: MyArray=_
In [579]: MyArray.shape
Out[579]: (6,)
In [580]: MyArray[0]
Out[580]: ['34.5500000', '36.9000000', '37.3200000', '37.6700000']
In [581]: MyArray[5]
Out[581]: ['39.7500000', '39.5000000', '36.8100000', '37.2500000']
In [582]: MyArray[4]
Out[582]: ['48.0100000', '51.2500000', '51.1700000', '52.5000000', '55.2500000']
In [583]: 

为了对其进行切片，您需要遍历数组的元素。

In [584]: [d[:4] for d in MyArray]
Out[584]: 
[['34.5500000', '36.9000000', '37.3200000', '37.6700000'],
 ['41.7900000', '44.8000000', '48.2600000', '46.1800000'],
 ['36.1200000', '37.1500000', '39.3100000', '38.1000000'],
 ['82.1000000', '82.0900000', '76.0200000', '77.7000000'],
 ['48.0100000', '51.2500000', '51.1700000', '52.5000000'],
 ['39.7500000', '39.5000000', '36.8100000', '37.2500000']]

现在，由于所有子列表长度相同，np.array 将创建一个二维数组：

In [585]: np.array(_)
Out[585]: 
array([['34.5500000', '36.9000000', '37.3200000', '37.6700000'],
       ['41.7900000', '44.8000000', '48.2600000', '46.1800000'],
       ['36.1200000', '37.1500000', '39.3100000', '38.1000000'],
       ['82.1000000', '82.0900000', '76.0200000', '77.7000000'],
       ['48.0100000', '51.2500000', '51.1700000', '52.5000000'],
       ['39.7500000', '39.5000000', '36.8100000', '37.2500000']], 
      dtype='<U10')

还是字符串，不过

In [586]: np.array(__,dtype=float)
Out[586]: 
array([[ 34.55,  36.9 ,  37.32,  37.67],
       [ 41.79,  44.8 ,  48.26,  46.18],
       [ 36.12,  37.15,  39.31,  38.1 ],
       [ 82.1 ,  82.09,  76.02,  77.7 ],
       [ 48.01,  51.25,  51.17,  52.5 ],
       [ 39.75,  39.5 ,  36.81,  37.25]])

- hpaulj

---

这不是我想要看到的，但还是很好，谢谢。 最后输出的元素是字符串吗？这个事实会限制我使用numpy功能吗？ - user6557479

最后一个表达式生成了一个二维浮点数数组。 - hpaulj

抱歉，我的错，之前被你的评论搞混了。 - user6557479

Answer 2

这里是一种几乎*向量化的方法 -

def slice_2Dobject_arr(arr,out_shape):
    lens = np.array(map(len,arr))
    id_arr = np.ones(lens.sum(),dtype=int)
    id_arr[lens[:-1].cumsum()] = -lens[:-1]+1
    mask = id_arr.cumsum()<=out_shape[1]
    vals = np.concatenate(arr)
    return vals[mask].reshape(-1,out_shape[1])[:out_shape[0]]

*：几乎是因为在开始使用map来获取输入数组中列表的长度，这似乎不是矢量化操作。但是，计算上应该相对可忽略。

示例运行 -

In [92]: arr
Out[92]: array([[3, 4, 5, 3], [3, 7, 8], [4, 9, 6, 4, 2], [3, 9, 4]], dtype=object)

In [93]: slice_2Dobject_arr(arr,(4,3))
Out[93]: 
array([[3, 4, 5],
       [3, 7, 8],
       [4, 9, 6],
       [3, 9, 4]])

In [94]: slice_2Dobject_arr(arr,(3,3))
Out[94]: 
array([[3, 4, 5],
       [3, 7, 8],
       [4, 9, 6]])

In [95]: slice_2Dobject_arr(arr,(3,2))
Out[95]: 
array([[3, 4],
       [3, 7],
       [4, 9]])

- Divakar

---

太酷了，我现在就试试看。与之前的答案相比，有什么好处吗？ - user6557479

@VladislavLadenkov 好吧，看起来另一个答案使用了“循环推导”（loop comprehension） 。因此，当您在输入数组中有大量列表时，可能会看到性能方面的好处。 - Divakar

这个解决方案将数组展平，并使用掩码来切片不需要的内容，最后进行重塑。如果速度（相对于可读性）很重要，您需要在一个真实大小的数组上进行速度测试。 - hpaulj

@hpaulj 确实存在一些设置开销，所以正如我所说，我们需要在该数组中有大量的列表才能看到任何潜在的好处。 - Divakar