对于那些零元素数目远远多于非零元素的数目,并且非零元素的分布没有规律的矩阵，称为稀疏矩阵。
由于稀疏矩阵中非零元素较少，零元素较多，因此可以采用只存储非零元素的方法进行压缩存储。
对于一个用二维数组存储的稀疏矩阵Amn，如果假设存储每个数组元素需要L个字节，那么存储整个矩阵需要m*n*L个字节。但是，这些存储空间的大部分存放的是0元素，从而造成大量的空间浪费。为了节省存储空间，可以只存储其中的非0元素。大大减少了空间的存储。
python不能自动创建稀疏矩阵，所以要用scipy中特殊的命令来得到稀疏矩阵。
Sparse Matrix Storage Formats稀疏矩阵的存储格式
1. 协调格式 (COO)
是一种坐标形式的稀疏矩阵。采用三个数组row、col和data保存非零元素的信息，这三个数组的长度相同，row保存元素的行，col保存元素的列，data保存元素的值。存储的主要优点是灵活、简单，仅存储非零元素以及每个非零元素的坐标。但是COO不支持元素的存取和增删，一旦创建之后，除了将之转换成其它格式的矩阵，几乎无法对其做任何操作和矩阵运算。
COO使用3个数组进行存储：values,rows, andcolumn。
数组values: 实数或复数数据，包括矩阵中的非零元素，顺序任意
数组rows: 数据所处的行
数组columns: 数据所处的列
参数：矩阵中非零元素的数量 nnz，3个数组的长度均为nnz.
2.对角线存储格式 (DIA)
如果稀疏矩阵有仅包含非0元素的对角线，则对角存储格式(DIA)可以减少非0元素定位的信息量。这种存储格式对有限元素或者有限差分离散化的矩阵尤其有效。
DIA通过两个数组确定： values、distance
其中values：对角线元素的值
distance：第i个distance是当前第i个对角线和主对角线的距离
如果稀疏矩阵具有仅包含零元素的对角线，则对角线存储格式可用于减少定位非零元素所需的信息量。这种存储格式在许多应用中特别有用，其中矩阵来自有限元或有限差分离散化。
英特尔MKL对角线存储格式由两个数组指定：值和距离，以及两个参数：ndiag，即非空对角线的数量，和lval，它是调用（子）程序中声明的前导维度。
值：真实或复杂的二维数组的尺寸为byliag。它的每一列都包含某个对角线的非零元素。存储的关键点是每个元素的值都保留了原始矩阵的行号。为了实现这一点，矩阵的下三角形部分中的对角线从顶部填充，而上三角形部分中的对角线从底部填充。注意，distance（i）的值是为diagonali填充的元素的数量。
距离：一个维度为ndiag的整数数组。arraydistance的元素是对角线和主对角线之间的距离。如果对角线在主对角线上方，则距离为正;如果对角线在主对角线下方，则距离为负。主对角线的距离等于零。
3、压缩稀疏行格式（CSR）
压缩稀疏行格式(CSR)通过四个数组确定： values,columns, pointerB, pointerE.
数组values：是一个实（复）数，包含矩阵A中的非0元，以行优先的形式保存；数组columns：第i个整型元素代表矩阵A中第i列；
数组pointerB ：第j个整型元素给出矩阵A行j中第一个非0元的位置，等价于pointerB(j) -pointerB(1)+1 ；
数组pointerE：第j个整型元素给出矩阵A第j行最后一个非0元的位置，等价于pointerE(j)-pointerB(1)。
英特尔MKL压缩稀疏行（CSR）格式由四个数组指定：值，列，指针B和指针E。下表根据稀疏矩阵A中非零元素的值，行和列位置描述了数组.
值:包含A的非零元素的实数或复数数组。使用上述行主存储映射将A的非零元素的值映射到值数组中。
列:整数数组列的元素i是包含值数组中第i个值的列中的数字
pointerB:此整数数组的元素j给出了值数组中元素的索引，该元素是a的rowj中的第一个非零元素。注意，该索引等于topointerB（j）-pointerB（1）+1
指针:包含行索引的整数数组，例如thepointerE（j）-pointerB（1）是值数组中元素的索引，该元素是A行j中的最后一个非零元素。
4.压缩稀疏列格式（CSC）:
压缩稀疏列格式(CSC)类似CSR格式，只是用的是列而不是行压缩。换句话说，矩阵A的CSC 格式和矩阵A的转置的CSR是一样的。
同样CSC也是由四个数组确定：values, columns, pointerB, and pointerE. 含义类同CSR。
压缩稀疏列格式（CSC）类似于CSR格式，但使用列代替行。换句话说，CSC格式与转置矩阵的CSR格式相同。CSR格式由四个数组指定：值，列，pointerB和pointerE。下表根据稀疏矩阵A中非零元素的值，行和列位置描述了数组。
值
包含A的非零元素的实数或复数数组。使用列主存储映射将A的非零元素的值映射到值数组中。
行
整数数组行的元素i是包含值数组中第i个值的行中的数字。
pointerB
此整数数组的元素j给出了值数组中元素的索引，该元素是a的columnj中的第一个非零元素。注意，该索引等于topointerB（j）-pointerB（1）+1。
指针
包含列索引的整数数组，例如thepointerE（j）-pointerB（1）是value数组中元素的索引，该元素是a的列j中的最后一个非零元素。
5.天际线存储格式
天际线存储格式对于直接稀疏求解器很重要，当不需要旋转时，它非常适合Cholesky或LU分解。
英特尔MKL中接受的天际线存储格式只能存储矩阵的三角矩阵或三角形部分。此格式由两个数组指定：值和指针。下表描述了这些数组：
值
标量数组。对于下三角矩阵，它包含从矩阵的每一行开始的元素集，从第一个非零元素开始到包括对角元素。对于上三角矩阵，它包含来自矩阵的每列的元素集，从第一个非零元素开始，一直到并包括对角元素。集合中包含遇到的零元素。
指针
一个具有维度（m + 1）的整数数组，其中m是下三角形的行数（上三角形的列）.pointers（i）-pointers（1）+1给出元素invalues的索引，这是第一个非三角形行（列）中的-zero元素i。pinters（m + 1）的值设置为tonnz + pointers（1），其中nnz是数组值中元素的数量。
6.块压缩稀疏行格式（BSR）
原矩阵A：
block_size为2时，分块表示的压缩矩阵E：
BSR的zero-based索引表示：
值=（1 02 1 6 7 8 2 1 4 5 1 4 3 0 0 7 2 0 0）
列=（0 1 1 1 2）
pointerB =（0 2 3）
pointerE =（2 3 5）
分块压缩稀疏行格式(BSR) 通过四个数组确定：values,columns,pointerB, pointerE.
其中数组values：是一个实（复）数，包含原始矩阵A中的非0元，以行优先的形式保存；
数组columns：第i个整型元素代表块压缩矩阵E中第i列；
数组pointerB ：第j个整型元素给出columns第j个非0块的起始位置；
数组pointerE：第j个整型元素给出columns数组中第j个非0块的终止位置。
用于稀疏矩阵的英特尔MKL块压缩稀疏行（BSR）格式由四个数组指定：值，列，指针B和指针E。下表描述了这些数组。
值
包含稀疏矩阵的非零块元素的实数组。元素以行主顺序逐块存储。非零块是包含至少一个非零元素的块。存储非零块的所有元素，即使它们中的一些等于零。在每个非零块内，元素在基于一个索引的情况下以列主顺序存储，并且在基于零的索引的情况下以行主顺序存储。
列
整数数组列的元素i是包含第i个非零块的块矩阵中的列的编号。
pointerB
此整数数组的元素j给出了列数组中元素的索引，该索引是块矩阵的rowj中的第一个非零块。
指针
此整数数组的元素j给出了列数组中元素的索引，该索引包含块矩阵的rowj中的最后一个非零块加1。
7. ELLPACK（ELL）
8.混合动力车（HYB）
由ELL+COO两种格式结合而成。
dok_matrix
基于keys的字典稀疏矩阵。
lil_matrix
基于行链接列表的稀疏矩阵，增量式创建稀疏矩阵的结构。
[ 稀疏矩阵存储格式 ]
[ NathanBell1-10-1000.pdf ]
[ 稀疏矩阵表示和迭代求解器，Nathan Bell的第1课 ]
[稀疏矩阵的存储格式（Sparse Matrix Storage Formats）]
[Intel MKL 库中使用的稀疏矩阵格式]
皮皮blog
不同稀疏矩阵的优缺点和使用经验
sparse matrix稀疏矩阵不同的存储形式在sparse模块中对应如下:
bsr_matrix（arg1 [，shape，dtype，copy，blocksize]）块稀疏行矩阵
coo_matrix（arg1 [，shape，dtype，copy]）COOrdinate格式的稀疏矩阵。
csc_matrix（arg1 [，shape，dtype，copy]）压缩稀疏列矩阵
csr_matrix（arg1 [，shape，dtype，copy]）压缩的稀疏行矩阵
dia_matrix（arg1 [，shape，dtype，copy]）具有DIAgonal存储的稀疏矩阵
dok_matrix（arg1 [，shape，dtype，copy]）基于密钥的字典稀疏矩阵。
lil_matrix（arg1 [，shape，dtype，copy]）基于行的链表稀疏矩阵
scipy不同稀疏矩阵的介绍和优缺点
scipy.sparse库中提供了多种表示稀疏矩阵的格式，每种格式都有不同的用处。同时稀疏矩阵可以支持加、减、乘、除和幂等算术操作。Sparse matrices can be used in arithmetic operations: they support addition, subtraction, multiplication, division,and matrix power.
分块压缩稀疏行格式(BSR)bsr_matrix(arg1, shape=None, dtype=None, copy=False, blocksize=None)Block Sparse Row matrix：
和压缩稀疏行格式(CSR)很相似，但是BSR更适合于有密集子矩阵的稀疏矩阵，分块矩阵通常出现在向量值有限的离散元中，在这种情景下，比CSR和CSC算术操作更有效。The Block Compressed Row (BSR) format is very similar to the Compressed Sparse Row (CSR) format. BSR is appropriate for sparse matrices with dense sub matrices. Block matrices often arise in vector-valued finite element discretizations. In such cases, BSR is considerably more efficient than CSR and CSC for many sparse arithmetic operations.
csc_matrix(arg1,shape=None, dtype=None, copy=False)压缩的列稀疏矩阵CSC ：
高效的CSC +CSC, CSC * CSC算术运算；高效的列切片操作。但是矩阵内积操作没有CSR, BSR快；行切片操作慢（相比CSR）；稀疏结构的变化代价高（相比LIL 或者 DOK）。
CSC格式的优点
•高效的算术运算CSC + CSC，CSC * CSC等
•高效的列切片
•快速矩阵矢量积（CSR，BSR可能更快！）
CSC格式的缺点
•慢行切片操作（考虑CSR） ）
•稀疏结构的变化是昂贵的（考虑LIL或DOK）
csr_matrix(arg1, shape=None, dtype=None, copy=False)Compressed Sparse Row matrix压缩稀疏行格式(CSR)：
高效的CSR + CSR, CSR *CSR算术运算；高效的行切片操作；高效的矩阵内积内积操作。但是列切片操作慢（相比CSC）；稀疏结构的变化代价高（相比LIL 或者 DOK）。CSR格式在存储稀疏矩阵时非零元素平均使用的字节数(Bytes per Nonzero Entry)最为稳定（float类型约为8.5，double类型约为12.5）。CSR格式常用于读入数据后进行稀疏矩阵计算。
CSR格式的优点
•高效的算术运算CSR + CSR，CSR * CSR等
•高效的行切片
•快速矩阵矢量产品
CSR格式的缺点
•慢速列切片操作（考虑CSC）
•稀疏结构的变化是昂贵的（考虑LIL或DOK）
coo_matrix(arg1,shape=None,dtype=None,copy=False)坐标格式(COO)：
坐标形式的一种稀疏矩阵。采用三个数组row、col和data保存非零元素的信息。这三个数组的长度相同，row保存元素的行，col保存元素的列，data保存元素的值。
coo_matrix不支持元素的存取和增删，一旦创建之后，除了将之转换成其它格式的矩阵，几乎无法对其做任何操作和矩阵运算。
COO格式的优点
•便于稀疏格式之间的快速转换
•允许重复条目（参见示例）
•与CSR / CSC格式的快速转换
优点：便利快捷的在不同稀疏格式间转换；允许重复录入，允许重复的元素；从CSR\CSC格式转换非常快速。
COO格式的缺点
•不直接支持：
-arithmetic operations
-slicing
缺点：不能直接进行科学计算和切片操作
COO格式常用于从文件中进行稀疏矩阵的读写，如matrix market即采用COO格式。
最常用的函数：
tocsc（）
以压缩稀疏列格式返回此矩阵的副本
tocsr（）
以压缩稀疏行格式返回此矩阵的副本
todense（[order，out]）
返回此矩阵的密集矩阵表示
许多稀疏矩阵的数据都是采用这种格式保存在文件中的，例如某个CSV文件中可能有这样三列：“用户ID，商品ID，评价值”。采用numpy.loadtxt或pandas.read_csv将数据读入之后，可以通过coo_matrix快速将其转换成稀疏矩阵：矩阵的每行对应一位用户，每列对应一件商品，而元素值为用户对商品的评价。
dia_matrix（arg1，shape = None，dtype = None，copy = False）具有DIAgonal存储的稀疏矩阵
对角存储格式(DIA)和ELL格式在进行稀疏矩阵-矢量乘积(sparse matrix-vector products)时效率最高，所以它们是应用迭代法(如共轭梯度法)解稀疏线性系统最快的格式；DIA格式存储数据的非零元素平均使用的字节数与矩阵类型有较大关系，适合于StructuredMesh结构的稀疏矩阵（float类型约为4.05，double类型约为8.10）。对于Unstructured Mesh以及Random Matrix，DIA格式使用的字节数是CSR格式的十几倍。
dok_matrix（arg1，shape = None，dtype = None，copy = False）基于密钥的字典稀疏矩阵。
dok_matrix从dict继承，它采用字典保存矩阵中不为0的元素：字典的键是一个保存元素(行,列)信息的元组，其对应的值为矩阵中位于(行,列)中的元素值。显然字典格式的稀疏矩阵很适合单个元素的添加、删除和存取操作。通常用来逐渐添加非零元素，然后转换成其它支持快速运算的格式。
基于字典存储的稀疏矩阵。
这是一种用于逐步构造稀疏矩阵的有效结构。允许对单个元素进行有效的O（1）访问。不允许重复。一旦构建，就可以有效地转换为coo_matrix。
lil_matrix（arg1，shape = None，dtype = None，copy = False）基于行的链表稀疏矩阵
这是一种用于逐步构造稀疏矩阵的有效结构。
基于行连接存储的稀疏矩阵。lil_matrix使用两个列表保存非零元素。data保存每行中的非零元素，rows保存非零元素所在的列。这种格式也很适合逐个添加元素，并且能快速获取行相关的数据。
LIL格式的优点
•支持灵活的切片
•矩阵稀疏结构的变化是有效
的LIL格式的缺点
•算术运算LIL + LIL很慢（考虑CSR或CSC）
•慢列切片（考虑CSC）
•慢矩阵矢量产品（考虑CSR或CSC）
预期用法
•LIL是构造稀疏矩阵的便捷格式
•一旦构造了矩阵，转换为CSR或CSC格式以进行快速算术和矩阵向量运算
•在构造大型矩阵时考虑使用COO格式
Note:{dok_matrix和lil_matrix适合逐渐添加元素}
综合
2. COO和CSR格式比起DIA和ELL来，更加灵活，易于操作；
3. ELL的优点是快速，而COO优点是灵活，二者结合后的HYB格式是一种不错的稀疏矩阵表示格式；
4. 根据Nathan Bell的工作：
CSR格式在存储稀疏矩阵时非零元素平均使用的字节数(Bytes per Nonzero Entry)最为稳定（float类型约为8.5，double类型约为12.5）
而DIA格式存储数据的非零元素平均使用的字节数与矩阵类型有较大关系，适合于StructuredMesh结构的稀疏矩阵（float类型约为4.05，double类型约为8.10）
对于Unstructured Mesh以及Random Matrix,DIA格式使用的字节数是CSR格式的十几倍；
5. 一些线性代数计算库：COO格式常用于从文件中进行稀疏矩阵的读写，如matrix market即采用COO格式，而CSR格式常用于读入数据后进行稀疏矩阵计算。
[scipy-ref-0.14.0 - 稀疏矩阵（scipy.sparse）]
[用Python做科学计算-第二版SciPy-数值计算库-稀疏矩阵-sparse]
皮皮blog
scipy.sparse稀疏矩阵的调用格式及参数、属性、方法说明
sparse matrix稀疏矩阵不同的存储形式在sparse模块中对应如下：
调用格式及参数说明：
arg1：密集矩阵或者另一个稀疏矩阵；
shape=(M, N)：创建的稀疏矩阵的shape为(M, N)未指定时从索引数组中推断；
dtype：稀疏矩阵元素类型，默认为’d’；
copy：bool类型，是否进行深拷贝，默认False。
其中BSR特有的参数blocksize：分块矩阵分块大小，而且必须被矩阵shape (M,N)整除。未指定时会自动使用启发式方法找到合适的分块大小。
坐标格式(COO) ：
coo_matrix（arg1 [，shape，dtype，copy]）
[ coo_matrix ]
对角存储格式(DIA) ：
dia_matrix（arg1 [，shape，dtype，copy]）
[ dia_matrix ]
压缩稀疏行格式(CSR) ：
csr_matrix（arg1 [，shape，dtype，copy]）
[ csr_matrix ]
压缩稀疏列格式(CSC) ：
csc_matrix（arg1 [，shape，dtype，copy]）
[ csc_matrix ]
分块压缩稀疏行格式(BSR) ：
bsr_matrix（arg1 [，shape，dtype，copy，blocksize]）
[ bsr_matrix ]
稀疏矩阵常用属性
dtype 矩阵数据类型
shape (2-tuple)矩阵形状
ndim (int)矩阵维数
nnz 非0元个数
data矩阵的数据数组
row COO特有的，矩阵行索引
col COO特有的，矩阵列索引
has_sorted_indices BSR有的，是否有排序索引
indices BSR特有的，BSR格式的索引数组
indptr BSR特有的，BSR格式的索引指针数组
blocksize BSR特有的，矩阵块大小
等等
稀疏矩阵常用方法
asformat(format) 返回给定格式的稀疏矩阵
astype(t) 返回给定元素格式的稀疏矩阵
diagonal() 返回矩阵主对角元素
dot(other) 坐标点积
getcol(j) 返回矩阵列j的一个拷贝，作为一个(mx 1) 稀疏矩阵 (列向量)
getrow(i) 返回矩阵行i的一个拷贝，作为一个(1 x n) 稀疏矩阵 (行向量)
max([axis]) 给定轴的矩阵最大元素
nonzero() 非0元索引
todense([order, out]) 返回当前稀疏矩阵的密集矩阵表示
sparse模块中用于创建稀疏矩阵的函数
眼睛（m [，n，k，dtype，格式]）
稀疏矩阵与对角线上的矩阵
身份（n [，dtype，格式]）
稀疏格式的身份矩阵
克朗（A，B [，格式]）
稀疏矩阵A和B的kronecker积
kronsum（A，B [，格式]）
稀疏矩阵A和B的kronecker和
diags（对角线[，偏移，形状，格式，dtype]）
从对角线构造稀疏矩阵。
spdiags（data，diags，m，n [，format]）
从对角线返回稀疏矩阵。
block_diag（mats [，format，dtype]）
从提供的矩阵构建块对角稀疏矩阵。
tril（A [，k，格式]）
以稀疏格式返回矩阵的下三角部分
选择（A [，k，格式]）
以稀疏格式返回矩阵的上三角部分
bmat（blocks [，format，dtype]）
从稀疏子块构建稀疏矩阵
hstack（blocks [，format，dtype]）
水平堆叠稀疏矩阵（列式）
vstack（blocks [，format，dtype]）
垂直堆栈稀疏矩阵（行式）
rand（m，n [，density，format，dtype，...]）
使用均匀分布的值生成给定形状和密度的稀疏矩阵。
random（m，n [，density，format，dtype，...]）
使用随机分布的值生成给定形状和密度的稀疏矩阵。
皮皮blog
sparse matrix稀疏矩阵的相关操作
创建和查看稀疏矩阵
以coo_matrix为例：
1 直接将dense矩阵转换成稀疏矩阵
甲= coo_matrix（[[ 1，2 ]，[ 3，4 ]]）
打印（A）
(0, 0) 1
(0, 1) 2
(1, 0) 3
(1, 1) 4
2 按照相应存储形式的要求构建矩阵：
行 =阵列（[ 0，0，0，0，1，3，1 ]）
COL =阵列（[ 0，0，0，2，1，3，1 ]）
数据=阵列（[ 1，1，1，8，1，1，1 ]）
矩阵 = coo_matrix（（数据，（行，列）），形状 =（4，4））
print（matrix）
print（matrix .todense（））
（0,0）1
（0,0）1
（0,0）1
（0,2）8
（1,1）1
（3,3）1
（1 ，1）1
[[3 0 8 0]
[0 2 0 0]
[0 0 0 0]
[0 0 0 1]]
Note:csr_matrix总是返回稀疏矩阵，而不会返回一维向量。即使csr_matrix([2,3])也返回矩阵。
稀疏矩阵大小
CSR = csr_matrix（[[ 1，5 ]，[ 4，0 ]，[ 1，3 ]]）
打印（csr.todense（））#todense（）之后是<类'numpy.matrixlib.defmatrix.matrix'>
print（csr.shape）
print（csr.shape [ 1 ]）
[[1 5]
[4 0]
[1 3]]
(3, 2)
2
稀疏矩阵下标存取slice
打印（csr）
(0, 0) 1
(0, 1) 5
(1, 0) 4
(2, 0) 1
（2,1）3
打印（csr [ 0 ]）＃<class'scipy.sparse.csr.csr_matrix'>
(0, 0) 1
(0, 1) 5
打印（CSR [ 1，1 ]）
1
打印（CSR [ 0，0 ]）
0
for c in csr: #每次读取csr中的一行 type(c) <class 'scipy.sparse.csr.csr_matrix'>
print(c)
break
(0, 0) 1
(0, 1) 5
csr_mat = csr_matrix（[ 1，5，0 ]）
打印（csr_mat.todense（））
＃打印（类型（csr_mat.nonzero（）））＃<类的元组“>
为行，列在 csr_mat.nonzero（） ：
print（row，col，csr_mat [row，col]）
[[1 5 0]]
0 0 1
0 1 5
将稀疏矩阵横向或者纵向合并
来自scipy.sparse导入coo_matrix，vstack
CSR = csr_matrix（[[ 1，5，5 ]，[ 4，0，6 ]，[ 1，3，7 ]]）
打印（csr.todense（））
[[1 5 5]
[4 0 6]
[1 3 7]]
CSR2 = csr_matrix（[[ 3，0，9 ]]）
打印（csr2.todense（））
[[3 0 9]]
print（vstack（[csr，csr2]）。todense（））
[[1 5 5]
[4 0 6]
[1 3 7]
[3 0 9]]
Note:如果合并数据形式不一样，不能合并。一个矩阵中的数据格式必须是相同的。
diags函数建立稀疏的对角矩阵
sparce矩阵的读取
可以像常规矩阵一样通过下标读取。也可以通过getrow(i)，gecol(i)读取特定的列或者特定的行，以及nonzero()读取非零元素的位置。
对于大多数（似乎只处了coo之外）稀疏矩阵的存储格式，都可以进行slice操作，比如对于csc，csr。也可以进行arithmeticoperations，矩阵的加减乘除，速度很快。
取矩阵的指定列数
sub = matrix.getcol（1）#'coo_matrix'对象不支持索引，不能使用matrix [1]
print（sub）
(1, 0) 2
sub = matrix.todense()[:,[1,2]] #常规矩阵取指定列print(sub)
[[0 8]
[2 0]
[0 0]
[0 0]]
稀疏矩阵点积计算
甲= csr_matrix（[[ 1，2，0 ]，[ 0，0，3 ]]）
打印（A.todense（））
[[1 2 0]
[0 0 3]]
v = AT
打印（v.todense（））
[[1 0]
[2 0]
[0 3]]
d = A.dot（v）
print（d）
(0, 0) 5
(1, 1) 9
甲= lil_matrix（[[ 1，2，0 ]，[ 0，0，3 ]，[ 4，0，5 ]]）
在=阵列（[ 1，0，- 1 ]）
s = datetime.datetime.now()
for i in range(100000):
d = A.dot(v) #这里v是一个ndarray
print(datetime.datetime.now() - s)
计算时间：
BSR：0：00：01.666072
COO：1.04
csc：0.93
csr：0.90
日：1.06
而：1.57
lil:11.37
故推荐用csr计算点积
csr_mat1 = csr_matrix（[ 1，2，0 ]）
csr_mat2 = csr_matrix（[ 1，0，- 1 ]）
similar = (csr_mat1.dot(csr_mat2.transpose())) #这里csr_mat2也是一个csr_matrix
print(type(similar))
print(similar)
print(similar[0, 0])
<class'spipy.sparse.csr.csr_matrix'>
(0, 0) 1
1
scipy稀疏矩阵在文件中的读取（读取和保存稀疏矩阵）
mmwrite（target，a [，comment，field，precision]）将稀疏或密集的数组a写入Matrix Market格式的文件。
mmread（source）将Matrix Market文件'filename'的内容读入矩阵。<class'scipy.sparse.coo.coo_matrix'>
mminfo（source）查询Matrix Market文件'filename'的内容以提取大小和存储空间。
def save_csr_mat（
item_item_sparse_mat_filename = r'。\ datasets \ lastfm-dataset-1K \ item_item_csr_mat.mtx'）：
random.seed（ 10）
raw_user_item_mat = random.randint（0，6，（3，2））
d = csr_matrix（raw_user_item_mat）
print（d.todense（））
print（d）
mmwrite（item_item_sparse_mat_filename，d）
print（“item_item_sparse_mat_file information：”）
print（mminfo（item_item_sparse_mat_filename））
k = mmread（item_item_sparse_mat_filename）
print（k.todense（））
[[1 5]
[4 0]
[1 3]]
(0, 0) 1
(0, 1) 5
(1, 0) 4
(2, 0) 1
(2, 1) 3
item_item_sparse_mat_file信息：
（3,2,5，'坐标'，'整数'，'一般'）
[[1 5]
[4 0]
[1 3]]
保存的文件中的内容：
%% MatrixMarket矩阵坐标整数一般
%
3 2 5
1 1 1
1 2 5
2 1 4
3 1 1
3 2 3
Note:保存的文件拓展名应为.mtx
[scipy-ref-0.14.0 - Matrix Market文件]
其它用户参考[scipy.sparse用法精要]
皮皮blog
一种比较省内存的稀疏矩阵Python存储方案
python字典模拟稀疏矩阵
{lz觉得这种主要用于稀疏检索和存储，而不适合应用于计算}
推荐系统中经常需要处理类似user_id, item_id, rating这样的数据，其实就是数学里面的稀疏矩阵，scipy中提供了sparse模块来解决这个问题。但scipy.sparse有很多问题不太合用：1、不能很好的同时支持data[i, ...]、data[..., j]、data[i, j]快速切片；2、由于数据保存在内存中，不能很好的支持海量数据处理。
要支持data[i, ...]、data[..., j]的快速切片，需要i或者j的数据集中存储；同时，为了保存海量的数据，也需要把数据的一部分放在硬盘上，用内存做buffer。
这里的解决方案比较简单，用一个类Dict的东西来存储数据，对于某个i（比如9527），它的数据保存在dict['i9527']里面，需要取出data[9527, ...]的时候，只要取出dict['i9527']即可，dict['i9527']原本是一个dict对象，储存某个j对应的值，为了节省内存空间，我们把这个dict以二进制字符串形式存储。采用类Dict来存储数据的另一个好处是你可以随便用内存Dict或者其他任何形式的DBM，甚至传说中的Tokyo Cabinet.
[http://blogread.cn/it/article/1229]
[How to Think Like a Computer Scientist 讲授了 dictionary 和如何使用 dictionary 模拟稀疏矩阵。]
sklearn特征提取中的稀疏情景
加载字典的中的特征：类 DictVectorizer 可以把特征向量转化成标准的Python字典对象的一个列表，同时也是被scikit-learn的估计器使用的一个NumPy/SciPy体现(ndarray)
即使处理时并不是特别快，python的字典有易于使用的优势，适用于稀疏情景(缺失特征不会被存储)，存储特征的名字和值。
特征哈希：类 FeatureHasher 是一个快速且低内存消耗的向量化方法，使用了 feature hashing 技术，或可称为”hashing trick”。没有像矢量化那样，为计算训练得到的特征建立哈西表，类 FeatureHasher 的实例使用了一个哈希函数来直接确定特征在样本矩阵中的列号。这样在可检查性上增加了速度减少了内存开销。这个类不会记住输入特征的形状，也没有 inverse_transform 方法。
[sklearn 特征提取]
来自：http：//blog.csdn.net/pipisorry/article/details/41762945
ref: [sparse模块的官方document]
http://blog.sina.com.cn/s/blog_6a90ae320101aavg.html