Python 创建三维numpy.ndarray，无固定的第二个维度

有时，诸如语音数据之类的数据具有已知的观察次数（n）、未知的持续时间和已知的测量次数（k）

在NumPy中的2D情况下，很明显，具有已知观察次数（n）和未知持续时间的数据是如何用形状的数据阵列表示的

（n，）

。例如：

将numpy导入为np
x=np.array（[[1,2]，
[ 1, 2, 3 ]
])
打印（x.shape）###返回：（2，）

在NumPy的3D案例中，是否有一个形状为

（n，k）

的

ndarray

？我能想到的最好的替代方法是使用一个2D

ndarray

的形状

（n，）

，并且使每个元素也具有2D的（转置）形状

（k，）

。比如说,

将numpy导入为np
x=np.数组（[[1,2]，[1,2]]，
[ [1,2], [1,2], [1,2] ]
])
打印（x.shape）###返回：（2，）；期望：（2，2）

---

理想情况下，解决方案能够告诉我们

ndarray

的维度属性，而无需递归调用（可能有

shape

？）的替代方案）。

仅回顾1d情况：

In [33]: x = np.array([[1,2],[1,2,3]])                                          
In [34]: x.shape                                                                
Out[34]: (2,)
In [35]: x                                                                      
Out[35]: array([list([1, 2]), list([1, 2, 3])], dtype=object)

结果是一个由两个元素组成的列表数组，我们从列表列表开始。差别不大

但请注意，如果列表大小相同，

np.array

将创建一个数字2d数组：

In [36]: x = np.array([[1,2,4],[1,2,3]])                                        
In [37]: x                                                                      
Out[37]: 
array([[1, 2, 4],
       [1, 2, 3]])

因此，不要指望我们在[33]中看到的行为

我可以创建二维对象阵列：

In [59]: x = np.empty((2,2),object)                                             
In [60]: x                                                                      
Out[60]: 
array([[None, None],                  # in this case filled with None
       [None, None]], dtype=object)

我可以为每个元素指定不同类型和大小的对象：

In [61]: x[0,0] = np.arange(3)                                                  
In [62]: x[0,0] = [1,2,3]                                                       
In [63]: x[1,0] = 'abc'                                                         
In [64]: x[1,1] = np.arange(6).reshape(2,3)                                     
In [65]: x                                                                      
Out[65]: 
array([[list([1, 2, 3]), None],
       ['abc', array([[0, 1, 2],
       [3, 4, 5]])]], dtype=object)

它仍然是2d。在大多数情况下，它类似于一个或多个列表，包含对象。databuffer实际上有指向存储在内存中其他位置的对象的指针（就像list buffer一样）

实际上，没有一个3d数组具有可变的最后维度。我们最多只能得到一个包含各种大小的列表或数组的2d数组

---

列出2个二维阵列：

In [69]: alist = [np.arange(6).reshape(2,3), np.arange(4.).reshape(2,2)]        
In [70]: alist                                                                  
Out[70]: 
[array([[0, 1, 2],
        [3, 4, 5]]), array([[0., 1.],
        [2., 3.]])]

在这种情况下，将其提供给

np.array

会引发错误： [71]中的np.数组（alist）
--------------------------------------------------------------------------- ValueError:无法将输入数组从形状（2,3）广播到形状（2）

我们可以使用以下列表中的元素填充对象数组：

In [72]: x = np.empty((4,),object)                                              
In [73]: x[0]=alist[0][0]                                                       
In [74]: x[1]=alist[0][1]                                                       
In [75]: x[2]=alist[1][0]                                                       
In [76]: x[3]=alist[1][1]                                                       
In [77]: x                                                                      
Out[77]: 
array([array([0, 1, 2]), array([3, 4, 5]), array([0., 1.]),
       array([2., 3.])], dtype=object)

并将其重塑为2d

In [78]: x.reshape(2,2)                                                         
Out[78]: 
array([[array([0, 1, 2]), array([3, 4, 5])],
       [array([0., 1.]), array([2., 3.])]], dtype=object)

结果是一个包含一维数组的二维数组。要获得元素的形状，我必须执行以下操作：

In [87]: np.frompyfunc(lambda i:i.shape, 1,1)(Out[78])                          
Out[87]: 
array([[(3,), (3,)],
       [(2,), (2,)]], dtype=object)

---

仅回顾1d案例：

In [33]: x = np.array([[1,2],[1,2,3]])                                          
In [34]: x.shape                                                                
Out[34]: (2,)
In [35]: x                                                                      
Out[35]: array([list([1, 2]), list([1, 2, 3])], dtype=object)

结果是一个由两个元素组成的列表数组，我们从列表列表开始。差别不大

但请注意，如果列表大小相同，

np.array

将创建一个数字2d数组：

In [36]: x = np.array([[1,2,4],[1,2,3]])                                        
In [37]: x                                                                      
Out[37]: 
array([[1, 2, 4],
       [1, 2, 3]])

因此，不要指望我们在[33]中看到的行为

我可以创建二维对象阵列：

In [59]: x = np.empty((2,2),object)                                             
In [60]: x                                                                      
Out[60]: 
array([[None, None],                  # in this case filled with None
       [None, None]], dtype=object)

我可以为每个元素指定不同类型和大小的对象：

In [61]: x[0,0] = np.arange(3)                                                  
In [62]: x[0,0] = [1,2,3]                                                       
In [63]: x[1,0] = 'abc'                                                         
In [64]: x[1,1] = np.arange(6).reshape(2,3)                                     
In [65]: x                                                                      
Out[65]: 
array([[list([1, 2, 3]), None],
       ['abc', array([[0, 1, 2],
       [3, 4, 5]])]], dtype=object)

它仍然是2d。在大多数情况下，它类似于一个或多个列表，包含对象。databuffer实际上有指向存储在内存中其他位置的对象的指针（就像list buffer一样）

实际上，没有一个3d数组具有可变的最后维度。我们最多只能得到一个包含各种大小的列表或数组的2d数组

---

列出2个二维阵列：

In [69]: alist = [np.arange(6).reshape(2,3), np.arange(4.).reshape(2,2)]        
In [70]: alist                                                                  
Out[70]: 
[array([[0, 1, 2],
        [3, 4, 5]]), array([[0., 1.],
        [2., 3.]])]

在这种情况下，将其提供给

np.array

会引发错误： [71]中的np.数组（alist）
--------------------------------------------------------------------------- ValueError:无法将输入数组从形状（2,3）广播到形状（2）

我们可以使用以下列表中的元素填充对象数组：

In [72]: x = np.empty((4,),object)                                              
In [73]: x[0]=alist[0][0]                                                       
In [74]: x[1]=alist[0][1]                                                       
In [75]: x[2]=alist[1][0]                                                       
In [76]: x[3]=alist[1][1]                                                       
In [77]: x                                                                      
Out[77]: 
array([array([0, 1, 2]), array([3, 4, 5]), array([0., 1.]),
       array([2., 3.])], dtype=object)

并将其重塑为2d

In [78]: x.reshape(2,2)                                                         
Out[78]: 
array([[array([0, 1, 2]), array([3, 4, 5])],
       [array([0., 1.]), array([2., 3.])]], dtype=object)

结果是一个包含一维数组的二维数组。要获得元素的形状，我必须执行以下操作：

In [87]: np.frompyfunc(lambda i:i.shape, 1,1)(Out[78])                          
Out[87]: 
array([[(3,), (3,)],
       [(2,), (2,)]], dtype=object)

---

您似乎误解了

（2，）

的形状的含义。这并不意味着

（2，）

；逗号不是

2

和某种空白维度之间的分隔符

（2，）

是一个元素为

2

的单元素元组的Python语法。Python使用这种语法是因为

（2）

表示整数

2

，而不是元组

您没有创建具有任意长度的二维数组。您正在创建对象数据类型的一维数组。它的元素是普通的Python列表。这样的数组与NumPy中几乎所有有用的东西都不兼容

---

无论是在您认为有效的2D情况下，还是在您试图发挥作用的3D情况下，都无法创建具有可变长度尺寸的NumPy数组。

您似乎误解了

（2，）

形状的含义。这并不意味着

（2，）

；逗号不是

2

和某种空白维度之间的分隔符

（2，）

是一个元素为

2

的单元素元组的Python语法。Python使用这种语法是因为

（2）

表示整数

2

，而不是元组

您没有创建具有任意长度的二维数组。您正在创建对象数据类型的一维数组。它的元素是普通的Python列表。这样的数组与NumPy中几乎所有有用的东西都不兼容

---

无论是在您认为有效的2D情况下，还是在您试图发挥作用的3D情况下，都无法创建具有可变长度尺寸的NumPy数组。

您的第一个代码片段并没有达到我认为您所认为的效果。当我打印它的结果时，我得到

数组（[array（[1,2,3]），数组（[1,2]），dtype=object）

。这意味着您将获得一个一维对象数组，在本例中是np.ndarray对象。就我所知，在任何方向上都不可能分配没有固定维度的数组。将

x

定义为（2,2）对象数据类型，并设置

x1

a中的元素