参考链接：
https://blog.csdn.net/bitcarmanlee/article/details/52668477
https://blog.csdn.net/wangjian1204/article/details/52149199
python scipy中的sparse模块就是为存储和表示稀疏矩阵。
模块的导入以及查看模块的信息：

from scipy import sparse
help(sparse)

其中显示了可以表示的7种稀疏矩阵类型：

There are seven available sparse matrix types:

        1. csc_matrix: Compressed Sparse Column format
        2. csr_matrix: Compressed Sparse Row format
        3. bsr_matrix: Block Sparse Row format
        4. lil_matrix: List of Lists format
        5. dok_matrix: Dictionary of Keys format
        6. coo_matrix: COOrdinate format (aka IJV, triplet format)
        7. dia_matrix: DIAgonal format

对应的类：

bsr_matrix - Block Sparse Row matrix
coo_matrix - A sparse matrix in COOrdinate format
csc_matrix - Compressed Sparse Column matrix
csr_matrix - Compressed Sparse Row matrix
dia_matrix - Sparse matrix with DIAgonal storage
dok_matrix - Dictionary Of Keys based sparse matrix
lil_matrix - Row-based linked list sparse matrix
spmatrix - Sparse matrix base clas

为了有效地构建矩阵，使用dok_matrix或者lil_matrix，lil_matrix类支持基本的切片和索引操作，语法与NumPy的arrays相似。COO格式也能有效率地构建矩阵。尽管与NumPy有许多相似性，但是强烈不建议使用NumPy的函数直接对稀疏矩阵格式进行操作，因为可能导致不正确的结果。如果将NumPy的函数用在这些矩阵上，首先检查SciPy在对应的稀疏矩阵类上有没有已经实现的操作，或者使用toarray()方法将稀疏矩阵对象转为NumPy的array。
实现乘法与转置操作，实现转换矩阵维CSC或CSR格式，lil_matrix格式是基于行的，所以转为为CSR比CSC更有效率。所有的转换在CSR,CSC和COO格式之间都是有效的，线性时间操作。
下面介绍7种稀疏矩阵：

1.coo_matrix

coo_matrix是最简单的存储方式。采用三个数组row、col和data保存非零元素的行下标，列下标与值。这三个数组的长度相同一般来说，coo_matrix主要用来创建矩阵，因为coo_matrix无法对矩阵的元素进行增删改等操作，一旦创建之后，除了将之转换成其它格式的矩阵，几乎无法对其做任何操作和矩阵运算。

>>> row = [0, 1, 2, 2]
>>> col = [0, 1, 2, 3]
>>> data = [1, 2, 3, 4]
# 生成coo格式的矩阵
>>> coo_mat = sparse.coo_matrix((data, (row, col)), shape=(4, 4))
>>> coo_mat
<4x4 sparse matrix of type '<class 'numpy.int32'>'
    with 4 stored elements in COOrdinate format>
>>> coo_mat.toarray()
array([[1, 0, 0, 0],
       [0, 2, 0, 0],
       [0, 0, 3, 4],
       [0, 0, 0, 0]])
>>> type(coo_mat)
<class 'scipy.sparse.coo.coo_matrix'>
>>> type(coo_mat.toarray())
<class 'numpy.ndarray'>

优点：
- 转换成其它存储格式很快捷简便，转换成csr/csc很快
- 允许重复的索引（例如在1行1列处存了值2.0，又在1行1列处存了值3.0，则转换成其它矩阵时就是2.0+3.0=5.0）

缺点：
- 不支持切片和算术运算操作

2.dok_matrix与lil_matrix

dok_matrix和lil_matrix适用的场景是逐渐添加矩阵的元素。dok_matrix的策略是采用字典来记录矩阵中不为0的元素。所以字典的key存的是记录元素的位置信息的元祖，value是记录元素的具体值。

>>> S = sparse.dok_matrix((5, 5), dtype=np.float32)
>>> for i in range(5):
    for j in range(5):
        S[i,j] = i+j    # 更新元素


>>> S.toarray()
[[0. 1. 2. 3. 4.]
 [1. 2. 3. 4. 5.]
 [2. 3. 4. 5. 6.]
 [3. 4. 5. 6. 7.]
 [4. 5. 6. 7. 8.]]

优点：
- 对于递增的构建稀疏矩阵很高效，比如定义该矩阵后，想进行每行每列更新值，可用该矩阵。当访问某个单元，只需要O(1)
缺点：
不允许重复索引（coo中适用），但可以很高效的转换成coo后进行重复索引

lil_matrix则是使用两个列表存储非0元素。data保存每行中的非零元素,rows保存非零元素所在的列。这种格式也很适合逐个添加元素，并且能快速获取行相关的数据。

>>> l = sparse.lil_matrix((4, 4))
>>> l[1, 1] = 1
>>> l[1, 3] =2
>>> l[2, 3] = 3
>>> l.toarray()
array([[0., 0., 0., 0.],
       [0., 1., 0., 2.],
       [0., 0., 0., 3.],
       [0., 0., 0., 0.]])
>>> l.data
array([list([]), list([1.0, 2.0]), list([3.0]), list([])], dtype=object)
>>> l.rows
array([list([]), list([1, 3]), list([3]), list([])], dtype=object)

优点：

适合递增的构建成矩阵
转换成其它存储方式很高效
支持灵活的切片
缺点：
当矩阵很大时，考虑用coo
算术操作，列切片，矩阵向量内积操作慢

3.dia_matrix

如果稀疏矩阵仅包含非0元素的对角线，则对角存储格式(DIA)可以减少非0元素定位的信息量。这种存储格式对有限元素或者有限差分离散化的矩阵尤其有效。dia_matrix通过两个数组确定： data和offsets。其中data对角线元素的值；offsets：第i个offsets是当前第i个对角线和主对角线的距离。data[k:]存储了offsets[k]对应的对角线的全部元素。
这里写图片描述
上述的代码实现：

>>> data = np.array([[1, 2, 3, 4], [5, 6, 0, 0], [0, 7, 8, 9]])
>>> offsets = np.array([0, -2, 1])
>>> sparse.dia_matrix((data, offsets), shape=(4, 4)).toarray()
array([[1, 7, 0, 0],
       [0, 2, 8, 0],
       [5, 0, 3, 9],
       [0, 6, 0, 4]])

offsets[0]=0表示第0个对角线与主对角线的距离为0，表示第0个对角线就是主对角线，data[0]就是第0个对角线的值。offsets[1]=-2表示第1个对角线与主对角线距离为-2，此时该对角线在主对角线的左下方，对角线上数值的数量为4-2=2，对应的值为data[1, :2+1]，此时data[1, 3:]为无效的值，在构造对角稀疏矩阵时不起作用。offsets[2]=1表示第2个对角线与主对角线距离为1，此时该对角线在主对角线的右上方，对角线上数值的数量为4-1=3，对应的值为data[2, 1:]，此时data[2, :1]为无效的值，在构造对角稀疏矩阵时不起作用。

4.csr_matrix与csc_matrix

csr_matrix是按行对矩阵进行压缩的,csc_matrix是按列对矩阵进行压缩的。通过row_offsets,column_indices，data来确定矩阵。column_indices，data与coo格式的列索引与数值的含义完全相同，row_offsets表示元素的行偏移量。
用如下例子说明：

>>> indptr = np.array([0, 2, 3, 6])
>>> indices = np.array([0, 2, 2, 0, 1, 2])
>>> data = np.array([1, 2, 3, 4, 5, 6])
>>> csr_matrix((data, indices, indptr), shape=(3, 3)).toarray()
array([[1, 0, 2],
       [0, 0, 3],
       [4, 5, 6]])

indices和data分别表示列索引和数据，第i行的列索引存储在indices[indptr[i]:indptr[i+1]]中,对应的值为data[indptr[i]:indptr[i+1]]。即第0行的列索引为indices[0:2]=[0,2],值为data[0:2]=[1,2];第1行的列索引为indices[2:3]=[2],值为data[2:3]=[3]…
CSR格式常用于读入数据后进行稀疏矩阵计算。

CSR：

优点：
- 高效的稀疏矩阵算术操作
- 高效的行切片
- 快速地矩阵向量内积操作
缺点：
- 缓慢地列切片操作（可以考虑csc）
- 转换到稀疏结构代价较高（可以考虑lil，dok）

CSC：

优点：
- 高效的稀疏矩阵算术操作
- 高效的列切片
- 快速地矩阵向量内积操作（不如csr，bsr块）
缺点：
- 缓慢地行切片操作（可以考虑csr）
- 转换到稀疏结构代价较高（可以考虑lil，dok）

5.bsr_matrix

基于行的块压缩,通过row_offsets,column_indices，data来确定矩阵。与csr相比，只是data中的元数据由0维的数变为了一个矩阵（块），其余完全相同。

>>> indptr = np.array([0,2,3,6])
>>> indices = np.array([0,2,2,0,1,2])
>>> data = np.array([1,2,3,4,5,6]).repeat(4).reshape(6,2,2)
>>> bsr_matrix((data,indices,indptr), shape=(6,6)).todense()
matrix([[1, 1, 0, 0, 2, 2],
        [1, 1, 0, 0, 2, 2],
        [0, 0, 0, 0, 3, 3],
        [0, 0, 0, 0, 3, 3],
        [4, 4, 5, 5, 6, 6],
        [4, 4, 5, 5, 6, 6]])

优点：

很类似于csr，更适合于矩阵的某些子矩阵很多值，在某些情况下比csr和csc计算更高效。

稀疏矩阵的存取

用save_npz保存单个稀疏矩阵

>>> scipy.sparse.save_npz('sparse_matrix.npz', sparse_matrix)
>>> sparse_matrix = scipy.sparse.load_npz('sparse_matrix.npz')

稀疏矩阵存储大小比较：

a = np.arange(100000).reshape(1000,100)
a[10: 300] = 0
b = sparse.csr_matrix(a)
# 稀疏矩阵压缩存储到npz文件
sparse.save_npz('b_compressed.npz', b, True)  # 文件大小：100KB
# 稀疏矩阵不压缩存储到npz文件
sparse.save_npz('b_uncompressed.npz', b, False)  # 文件大小：560KB
# 存储到普通的npy文件
np.save('a.npy', a)  # 文件大小：391KB
# 存储到压缩的npz文件
np.savez_compressed('a_compressed.npz', a=a)  # 文件大小：97KB

对于存储到npz文件中的CSR格式的稀疏矩阵，内容为：

data.npy
format.npy
indices.npy
indptr.npy
shape.npy

python稀疏矩阵的存储与表示