如何防止numpy折叠行？答案

【问题标题】：How to prevent numpy from collapsing rows?如何防止numpy折叠行？
【发布时间】：2019-12-31 03:35:59
【问题描述】：

我有一个函数，它接受一个 numpy 数组并输出一个 numpy 数组。但是，当输出数组包含一个常量值时，使用 numpy 数组调用函数会导致所述值被“折叠”。

我正在尝试使用 numpy 编写向量微积分库，并且希望将向量传递给向量值函数，而不是依赖迭代。

r1 = lambda t: np.array([2*t, 1])
r2 = lambda t: np.array([2*t, 1+0*t])
t = np.linspace(0, 1)
print(r1(t).shape)
print(r2(t).shape)

人们会期望r1(t) 和r2(t) 具有相同的形状，但事实并非如此。 r1(t) 生成的对象看起来像 array([ array([...]), 1, dtype=object) 和 r2(t) 的结果类似于 array([ [...], [...])（其中 [...] 表示有效的浮点数组）。我猜r2(t) 可以正常工作，因为浮点错误不同，但我可能是错的。有没有办法防止 numpy 折叠第二行，或者“展开”它？

【问题讨论】：

标签： python numpy numpy-ndarray numpy-ufunc

【解决方案1】：

In [183]: r1 = lambda t: np.array([2*t, 1]) 
     ...: r2 = lambda t: np.array([2*t, 1+0*t]) 
     ...: t = np.linspace(0, 1)                                                                              
In [184]: r1(t)                                                                                              
Out[184]: 
array([array([0.        , 0.04081633, 0.08163265, 0.12244898, 0.16326531,
       0.20408163, 0.24489796, 0.28571429, 0.32653061, 0.36734694,
       0.40816327, 0.44897959, 0.48979592, 0.53061224, 0.57142857,
       0.6122449 , 0.65306122, 0.69387755, 0.73469388, 0.7755102 ,
       0.81632653, 0.85714286, 0.89795918, 0.93877551, 0.97959184,
       1.02040816, 1.06122449, 1.10204082, 1.14285714, 1.18367347,
       1.2244898 , 1.26530612, 1.30612245, 1.34693878, 1.3877551 ,
       1.42857143, 1.46938776, 1.51020408, 1.55102041, 1.59183673,
       1.63265306, 1.67346939, 1.71428571, 1.75510204, 1.79591837,
       1.83673469, 1.87755102, 1.91836735, 1.95918367, 2.        ]),
       1], dtype=object)
In [185]: r2(t)                                                                                              
Out[185]: 
array([[0.        , 0.04081633, 0.08163265, 0.12244898, 0.16326531,
        0.20408163, 0.24489796, 0.28571429, 0.32653061, 0.36734694,
        0.40816327, 0.44897959, 0.48979592, 0.53061224, 0.57142857,
        0.6122449 , 0.65306122, 0.69387755, 0.73469388, 0.7755102 ,
        0.81632653, 0.85714286, 0.89795918, 0.93877551, 0.97959184,
        1.02040816, 1.06122449, 1.10204082, 1.14285714, 1.18367347,
        1.2244898 , 1.26530612, 1.30612245, 1.34693878, 1.3877551 ,
        1.42857143, 1.46938776, 1.51020408, 1.55102041, 1.59183673,
        1.63265306, 1.67346939, 1.71428571, 1.75510204, 1.79591837,
        1.83673469, 1.87755102, 1.91836735, 1.95918367, 2.        ],
       [1.        , 1.        , 1.        , 1.        , 1.        ,
        1.        , 1.        , 1.        , 1.        , 1.        ,
        1.        , 1.        , 1.        , 1.        , 1.        ,
        1.        , 1.        , 1.        , 1.        , 1.        ,
        1.        , 1.        , 1.        , 1.        , 1.        ,
        1.        , 1.        , 1.        , 1.        , 1.        ,
        1.        , 1.        , 1.        , 1.        , 1.        ,
        1.        , 1.        , 1.        , 1.        , 1.        ,
        1.        , 1.        , 1.        , 1.        , 1.        ,
        1.        , 1.        , 1.        , 1.        , 1.        ]])
In [186]: r1(t).shape                                                                                        
Out[186]: (2,)
In [187]: r2(t).shape                                                                                        
Out[187]: (2, 50)

r2 组合了两个与 t 形状 (50,) 匹配的数组，因此结果是一个 (2,50) 形状的数值数组。

r1 将 (50,) 数组与标量 1 组合在一起。结果是一个 2 元素数组 object dtype。看到r1 显示末尾的悬空1 了吗？混合不同大小的元素会产生一个类似数组的列表，因为它不能像r2那样制作多维数组

【讨论】：

我明白了，有没有一种简单的方法来扩展 r1 末尾的悬空 1，所以它可以很好地与其他 numpy 例程一起使用，或者我应该改变我将向量值函数定义为 np 的方法.array 包裹在 lambda 中？
r2 是一种合理的方法。 np.ones_like(t) 是另一个。