Python 为什么挤压不适用于稀疏阵列？

我有以下代码：

将numpy导入为np
从scipy导入稀疏
x=np.眼（3）
打印（x.sum（轴=1.shape）
x=稀疏。眼睛（3）
打印（x.sum（轴=1.shape）
打印（x.sum（轴=1.squence（）.shape）

我得到了以下输出：

(3,)
(3, 1)
(1, 3)

看起来

挤压

没有按预期工作。我做错了什么

In [1]: from scipy import sparse                                                                 
In [2]: x = np.eye(3)                                                                            
In [3]: x                                                                                        
Out[3]: 
array([[1., 0., 0.],
       [0., 1., 0.],
       [0., 0., 1.]])
In [4]: x.shape                                                                                  
Out[4]: (3, 3)

In [5]: xs = sparse.eye(3)                                                                       
In [6]: xs                                                                                       
Out[6]: 
<3x3 sparse matrix of type '<class 'numpy.float64'>'
    with 3 stored elements (1 diagonals) in DIAgonal format>
In [7]: print(xs)                                                                                
  (0, 0)    1.0
  (1, 1)    1.0
  (2, 2)    1.0
In [8]: xs.shape                                                                                 
Out[8]: (3, 3)

稀疏和生成一个

np.matrix

对象

In [10]: xs.sum(axis=1)                                                                          
Out[10]: 
matrix([[1.],
        [1.],
        [1.]])
In [11]: _.shape                                                                                 
Out[11]: (3, 1)

根据定义，矩阵总是二维的。但是它确实有一个

A1

属性，该属性转换为

ndarray

，并应用压缩

In [12]: xs.sum(axis=1).A1                                                                       
Out[12]: array([1., 1., 1.])

---

稀疏实际上通过矩阵乘法执行行或列求和：

In [21]: xs*np.matrix(np.ones((3,1)))                                                            
Out[21]: 
matrix([[1.],
        [1.],
        [1.]])

稀疏矩阵*np.matrix生成np.matrix

如果使用

sum

，

ndarray

，结果将是

ndarray

，并且可以压缩

In [22]: xs*np.ones((3,1))                                                                       
Out[22]: 
array([[1.],
       [1.],
       [1.]])

请注意，我使用了

*

（我本可以使用@）；乘法的稀疏定义（例如点）具有优先权

In [23]: np.matrix(np.ones((1,3)))*xs                                                            
Out[23]: matrix([[1., 1., 1.]])

---

我没有使用scipy.sparse，但我很确定它处理的是矩阵而不是数组，它们是固定的2d对象。尝试使用numpy矩阵而不是数组进行比较。@AndrasDeak我需要使用稀疏矩阵来解决我的问题，因为它们太大了。这里的代码只是一个简单的例子。我不知道

A1

，谢谢！因此，挤压不起作用，因为np.matrix始终是2D？此处

挤压

应用于

np.matrix

，而不是稀疏矩阵。但根据定义，稀疏矩阵也是二维的<矩阵是

ndarray

的一个子类；稀疏矩阵是一个单独的类，但编写时的行为非常类似于

np.matrix

<代码>np。矩阵即将退出，但将稀疏矩阵切换为类似于ndarray的行为还有很长的路要走。稀疏和实际上是通过矩阵乘法执行的-请参阅我的编辑。

In [23]: np.matrix(np.ones((1,3)))*xs                                                            
Out[23]: matrix([[1., 1., 1.]])