SciPy-1-12-中文文档-十五-
SciPy 1.12 中文文档（十五）
scipy.sparse.bsr_array
class scipy.sparse.bsr_array(arg1, shape=None, dtype=None, copy=False, blocksize=None)
块稀疏行格式稀疏数组。
可以通过几种方式实例化：
bsr_array(D, [blocksize=(R,C)])
其中 D 是一个二维数组。
bsr_array(S, [blocksize=(R,C)])
与另一个稀疏数组或矩阵 S 进行比较（等效于 S.tobsr()）。
bsr_array((M, N), [blocksize=(R,C), dtype])
用于构建形状为(M, N)的空稀疏数组，数据类型是可选的，默认为 dtype='d'。
bsr_array((data, ij), [blocksize=(R,C), shape=(M, N)])
其中data和ij满足a[ij[0, k], ij[1, k]] = data[k]
bsr_array((data, indices, indptr), [shape=(M, N)])
是标准的 BSR 表示，其中第 i 行的块列索引存储在indices[indptr[i]:indptr[i+1]]中，它们对应的块值存储在data[indptr[i]:indptr[i+1]]中。如果未提供 shape 参数，则从索引数组中推断数组的尺寸。
注意事项
稀疏数组可以用于算术运算：它们支持加法、减法、乘法、除法和矩阵幂运算。
BSR 格式摘要
块稀疏行（BSR）格式与压缩稀疏行（CSR）格式非常相似。对于具有稠密子矩阵的稀疏矩阵，例如下面的最后一个示例，BSR 格式非常适合。这种稀疏块矩阵经常出现在向量值有限元离散化中。在这种情况下，BSR 比 CSR 和 CSC 在许多稀疏算术操作中要高效得多。
块大小
块大小(R,C)必须均匀地划分稀疏数组的形状(M,N)。也就是说，R 和 C 必须满足关系M % R = 0和N % C = 0。
如果未指定块大小，则将应用简单的启发式方法来确定合适的块大小。
规范格式
在规范格式中，没有重复的块，并且索引按行排序。
示例
>>> import numpy as np
>>> from scipy.sparse import bsr_array
>>> bsr_array((3, 4), dtype=np.int8).toarray()
array([[0, 0, 0, 0],
[0, 0, 0, 0],
[0, 0, 0, 0]], dtype=int8)
>>> row = np.array([0, 0, 1, 2, 2, 2])
>>> col = np.array([0, 2, 2, 0, 1, 2])
>>> data = np.array([1, 2, 3 ,4, 5, 6])
>>> bsr_array((data, (row, col)), shape=(3, 3)).toarray()
array([[1, 0, 2],
[0, 0, 3],
[4, 5, 6]])
>>> 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_array((data,indices,indptr), shape=(6, 6)).toarray()
array([[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]])
属性：
dtype数据类型
数组的数据类型
shape二元组
数组的形状。
ndim整数
维度的数量（始终为 2）
存储的值的数量，包括显式的零值。
存储值的数量。
数据
BSR 格式数组的数据数组
indices
BSR 格式数组的索引数组
indptr
BSR 格式数组的索引指针数组
矩阵的块大小。
Whether the indices are sorted
has_canonical_formatbool
Whether the array/matrix has sorted indices and no duplicates
T
转置。
Methods
__len__() |
|
|---|---|
arcsin() |
逐元素的反正弦。 |
arcsinh() |
逐元素的反双曲正弦。 |
arctan() |
逐元素的反正切。 |
arctanh() |
逐元素的反双曲正切。 |
argmax([axis, out]) |
返回沿轴的最大元素的索引。 |
argmin([axis, out]) |
返回沿轴的最小元素的索引。 |
asformat(format[, copy]) |
返回以指定格式表示的数组/矩阵。 |
asfptype() |
将数组/矩阵转换为浮点数格式（如有必要）。 |
astype(dtype[, casting, copy]) |
将数组/矩阵元素转换为指定类型。 |
ceil() |
逐元素的向上取整。 |
check_format([full_check]) |
检查数组/矩阵是否符合 BSR 格式。 |
conj([copy]) |
逐元素的复共轭。 |
conjugate([copy]) |
逐元素的复共轭。 |
copy() |
返回该数组/矩阵的副本。 |
count_nonzero() |
非零条目的数量，等同于 |
deg2rad() |
元素级的 deg2rad。 |
diagonal([k]) |
返回数组/矩阵的第 k 条对角线。 |
dot(other) |
普通的点积。 |
eliminate_zeros() |
去除原地的零元素。 |
expm1() |
元素级的 expm1。 |
floor() |
元素级的 floor。 |
getH() |
返回该数组/矩阵的共轭转置。 |
get_shape() |
获取稀疏数组/矩阵的形状。 |
getcol(j) |
返回数组/矩阵的第 j 列的副本，作为 (m x 1) 稀疏数组/矩阵（列向量）。 |
getformat() |
稀疏数组/矩阵的存储格式。 |
getmaxprint() |
打印时显示的最大元素数量。 |
getnnz([axis]) |
存储值的数量，包括显式的零值。 |
getrow(i) |
返回数组/矩阵的第 i 行的副本，作为 (1 x n) 稀疏数组/矩阵（行向量）。 |
log1p() |
元素级的 log1p。 |
max([axis, out]) |
返回数组/矩阵或指定轴向的最大值。 |
maximum(other) |
该数组/矩阵与另一个数组/矩阵之间的元素级最大值。 |
mean([axis, dtype, out]) |
计算沿指定轴的算术平均值。 |
min([axis, out]) |
返回数组/矩阵或沿轴的最小值或最大值 |
minimum(other) |
与另一个数组/矩阵的逐元素最小值 |
multiply(other) |
与另一个数组/矩阵、向量或标量的逐点乘法 |
nanmax([axis, out]) |
返回数组/矩阵或沿轴的最大值，忽略任何 NaN 值 |
nanmin([axis, out]) |
返回数组/矩阵或沿轴的最小值，忽略任何 NaN 值 |
nonzero() |
数组/矩阵的非零索引 |
power(n[, dtype]) |
逐元素的幂运算 |
prune() |
移除所有非零元素后的空间 |
rad2deg() |
逐元素的弧度转角度 |
reshape(self, shape[, order, copy]) |
为稀疏数组/矩阵给出新的形状，不更改数据 |
resize(*shape) |
将数组/矩阵就地调整为给定的shape维度 |
rint() |
逐元素的四舍五入 |
set_shape(shape) |
参见reshape |
setdiag(values[, k]) |
设置数组/矩阵的对角线或非对角线元素 |
sign() |
逐元素的符号函数 |
sin() |
逐元素的正弦函数 |
sinh() |
逐元素的双曲正弦函数 |
sort_indices() |
对该数组/矩阵的索引进行排序，原地修改 |
sorted_indices() |
返回该数组/矩阵索引已排序的副本。 |
sqrt() |
逐元素的平方根函数。 |
sum([axis, dtype, out]) |
沿给定轴对数组/矩阵元素求和。 |
sum_duplicates() |
通过将重复的数组/矩阵条目相加来消除重复项。 |
tan() |
逐元素的正切函数。 |
tanh() |
逐元素的双曲正切函数。 |
toarray([order, out]) |
返回该稀疏数组/矩阵的稠密 ndarray 表示。 |
tobsr([blocksize, copy]) |
将该数组/矩阵转换为块稀疏行格式。 |
tocoo([copy]) |
将该数组/矩阵转换为坐标格式。 |
tocsc([copy]) |
将该数组/矩阵转换为压缩稀疏列格式。 |
tocsr([copy]) |
将该数组/矩阵转换为压缩稀疏行格式。 |
todense([order, out]) |
返回该稀疏数组/矩阵的稠密表示。 |
todia([copy]) |
将该数组/矩阵转换为稀疏对角线格式。 |
todok([copy]) |
将该数组/矩阵转换为键的字典格式。 |
tolil([copy]) |
将该数组/矩阵转换为列表列表格式。 |
trace([offset]) |
返回稀疏数组/矩阵对角线上元素的和。 |
transpose([axes, copy]) |
反转稀疏数组/矩阵的维度。 |
trunc() |
逐元素截断。 |
| getitem | |
| mul |
scipy.sparse.coo_array
class scipy.sparse.coo_array(arg1, shape=None, dtype=None, copy=False)
COO 格式的稀疏数组。
也称为‘ijv’或‘三元组’格式。
可以通过多种方式实例化：
coo_array(D)
其中 D 是一个二维 ndarray
coo_array(S)
使用另一个稀疏数组或矩阵 S（等同于 S.tocoo()）
coo_array((M, N), [dtype])
构造一个形状为(M, N)的空数组，dtype 是可选的，默认为 dtype='d'。
coo_array((data, (i, j)), [shape=(M, N)])
通过三个数组构造：
-
data[:] 数组条目，任意顺序
-
i[:] 数组条目的行索引
-
j[:] 数组条目的列索引
其中A[i[k], j[k]] = data[k]。当未指定形状时，将从索引数组中推断出形状
注意事项
稀疏数组可用于算术运算：它们支持加法、减法、乘法、除法和矩阵幂。
COO 格式的优势
-
有助于在稀疏格式之间快速转换
-
允许重复条目（见示例）
-
非常快速地转换为 CSR/CSC 格式
COO 格式的缺点
-
不直接支持：
-
算术运算
-
切片
-
预期用法
-
COO 是一种快速构建稀疏数组的格式
-
一旦构造了 COO 数组，可以转换为 CSR 或 CSC 格式进行快速算术和矩阵向量操作
-
默认情况下，转换为 CSR 或 CSC 格式时，重复的(i, j)条目将被合并在一起。这有助于高效构建有限元矩阵等。（见示例）
规范格式
-
条目和索引按行、然后列排序。
-
没有重复条目（即没有重复的(i, j)位置）
-
数据数组可能包含显式零值。
示例
>>> # Constructing an empty array
>>> import numpy as np
>>> from scipy.sparse import coo_array
>>> coo_array((3, 4), dtype=np.int8).toarray()
array([[0, 0, 0, 0],
[0, 0, 0, 0],
[0, 0, 0, 0]], dtype=int8)
>>> # Constructing an array using ijv format
>>> row = np.array([0, 3, 1, 0])
>>> col = np.array([0, 3, 1, 2])
>>> data = np.array([4, 5, 7, 9])
>>> coo_array((data, (row, col)), shape=(4, 4)).toarray()
array([[4, 0, 9, 0],
[0, 7, 0, 0],
[0, 0, 0, 0],
[0, 0, 0, 5]])
>>> # Constructing an array with duplicate indices
>>> row = np.array([0, 0, 1, 3, 1, 0, 0])
>>> col = np.array([0, 2, 1, 3, 1, 0, 0])
>>> data = np.array([1, 1, 1, 1, 1, 1, 1])
>>> coo = coo_array((data, (row, col)), shape=(4, 4))
>>> # Duplicate indices are maintained until implicitly or explicitly summed
>>> np.max(coo.data)
1
>>> coo.toarray()
array([[3, 0, 1, 0],
[0, 2, 0, 0],
[0, 0, 0, 0],
[0, 0, 0, 1]])
属性：
数据类型dtype
数组的数据类型
shape2 元组
数组的形状。
维度整数
维度数量（始终为 2）
存储值的数量，包括显式零值。
存储值的数量。
数据
数组的 COO 格式数据数组
行
COO 格式数组的行索引数组
列
数组的 COO 格式列索引数组
具有规范格式布尔值
矩阵是否具有排序索引且无重复
矩阵的格式字符串。
转置。
方法
__len__() |
|
|---|---|
arcsin() |
逐元素的反正弦。 |
arcsinh() |
逐元素的反双曲正弦。 |
arctan() |
逐元素的反正切函数。 |
arctanh() |
逐元素的反双曲正切。 |
argmax([axis, out]) |
返回沿轴的最大元素的索引。 |
argmin([axis, out]) |
返回沿轴的最小元素的索引。 |
asformat(format[, copy]) |
返回以指定格式的数组/矩阵。 |
asfptype() |
将数组/矩阵提升到浮点数格式（如有必要）。 |
astype(dtype[, casting, copy]) |
将数组/矩阵元素转换为指定类型。 |
ceil() |
逐元素的向上取整。 |
conj([copy]) |
逐元素的复共轭。 |
conjugate([copy]) |
逐元素的复共轭。 |
copy() |
返回此数组/矩阵的副本。 |
count_nonzero() |
非零元素的数量，等同于 |
deg2rad() |
逐元素的角度转弧度。 |
diagonal([k]) |
返回数组/矩阵的第 k 条对角线。 |
dot(other) |
普通的点积。 |
eliminate_zeros() |
移除数组/矩阵中的零元素。 |
expm1() |
按元素计算 expm1。 |
floor() |
按元素向下取整。 |
getH() |
返回此数组/矩阵的共轭转置。 |
get_shape() |
获取稀疏数组/矩阵的形状。 |
getcol(j) |
返回数组/矩阵的第 j 列的副本，作为一个 (m x 1) 的稀疏数组/矩阵（列向量）。 |
getformat() |
稀疏数组/矩阵的存储格式。 |
getmaxprint() |
打印时显示的最大元素数量。 |
getnnz([axis]) |
存储值的数量，包括显式的零。 |
getrow(i) |
返回数组/矩阵的第 i 行的副本，作为一个 (1 x n) 的稀疏数组/矩阵（行向量）。 |
log1p() |
按元素计算 log1p。 |
max([axis, out]) |
返回数组/矩阵的最大值或沿轴的最大值。 |
maximum(other) |
在此数组/矩阵与另一个数组/矩阵之间按元素取最大值。 |
mean([axis, dtype, out]) |
沿指定轴计算算术平均值。 |
min([axis, out]) |
返回数组/矩阵的最小值或沿轴的最小值。 |
minimum(other) |
在此数组/矩阵与另一个数组/矩阵之间按元素取最小值。 |
multiply(other) |
与另一个数组/矩阵的逐点乘积。 |
nanmax([axis, out]) |
返回数组/矩阵的最大值或沿轴的最大值，忽略任何 NaN。 |
nanmin([axis, out]) |
返回数组/矩阵的最小值，忽略 NaN 值。可以沿着某个轴计算最小值。 |
nonzero() |
返回数组/矩阵中非零元素的索引。 |
power(n[, dtype]) |
对数组元素进行逐元素求幂运算。 |
rad2deg() |
逐元素将弧度转换为角度。 |
reshape(self, shape[, order, copy]) |
在不改变数据的情况下为稀疏数组/矩阵赋予新的形状。 |
resize(*shape) |
将数组/矩阵原地调整为给定shape的维度。 |
rint() |
逐元素四舍五入。 |
set_shape(shape) |
参见 reshape。 |
setdiag(values[, k]) |
设置数组/矩阵的对角线或非对角线元素。 |
sign() |
逐元素的符号函数。 |
sin() |
逐元素的正弦函数。 |
sinh() |
逐元素的双曲正弦函数。 |
sqrt() |
逐元素的平方根函数。 |
sum([axis, dtype, out]) |
沿着给定轴对数组/矩阵元素进行求和。 |
sum_duplicates() |
通过将重复条目相加来消除重复条目。 |
tan() |
逐元素的正切函数。 |
tanh() |
逐元素的双曲正切函数。 |
toarray([order, out]) |
返回该稀疏数组/矩阵的稠密 ndarray 表示。 |
tobsr([blocksize, copy]) |
将此数组/矩阵转换为块稀疏行格式。 |
tocoo([copy]) |
将此数组/矩阵转换为坐标格式。 |
tocsc([copy]) |
将此数组/矩阵转换为压缩稀疏列格式。 |
tocsr([copy]) |
将此数组/矩阵转换为压缩稀疏行格式。 |
todense([order, out]) |
返回此稀疏数组/矩阵的密集表示。 |
todia([copy]) |
将此数组/矩阵转换为稀疏的对角线格式。 |
todok([copy]) |
将此数组/矩阵转换为键值字典格式。 |
tolil([copy]) |
将此数组/矩阵转换为列表列表格式。 |
trace([offset]) |
返回稀疏数组/矩阵对角线上元素之和。 |
transpose([axes, copy]) |
反转稀疏数组/矩阵的维度。 |
trunc() |
逐元素截断。 |
| mul |
scipy.sparse.csc_array
class scipy.sparse.csc_array(arg1, shape=None, dtype=None, copy=False)
压缩稀疏列数组。
可以通过几种方式实例化：
csc_array(D)
其中 D 是一个 2-D ndarray
csc_array(S)
with another sparse array or matrix S (equivalent to S.tocsc())
csc_array((M, N), [dtype])
以形状 (M, N) 构造一个空数组，dtype 是可选的，默认为 dtype='d'。
csc_array((data, (row_ind, col_ind)), [shape=(M, N)])
其中 data、row_ind 和 col_ind 满足关系 a[row_ind[k], col_ind[k]] = data[k]。
csc_array((data, indices, indptr), [shape=(M, N)])
标准的 CSC 表示，其中列 i 的行索引存储在 indices[indptr[i]:indptr[i+1]] 中，相应的值存储在 data[indptr[i]:indptr[i+1]] 中。如果未提供形状参数，则从索引数组中推断数组的维度。
注意事项
稀疏数组可用于算术运算：支持加法、减法、乘法、除法和矩阵幂运算。
CSC 格式的优点
-
高效的算术运算 CSC + CSC、CSC * CSC 等。
-
高效的列切片
-
快速矩阵向量乘积（CSR、BSR 可能更快）
CSC 格式的缺点
-
slow row slicing operations (consider CSR)
-
更改稀疏结构的代价昂贵（考虑 LIL 或 DOK）
规范格式
-
在每列中，索引按行排序。
-
没有重复条目。
示例
>>> import numpy as np
>>> from scipy.sparse import csc_array
>>> csc_array((3, 4), dtype=np.int8).toarray()
array([[0, 0, 0, 0],
[0, 0, 0, 0],
[0, 0, 0, 0]], dtype=int8)
>>> row = np.array([0, 2, 2, 0, 1, 2])
>>> col = np.array([0, 0, 1, 2, 2, 2])
>>> data = np.array([1, 2, 3, 4, 5, 6])
>>> csc_array((data, (row, col)), shape=(3, 3)).toarray()
array([[1, 0, 4],
[0, 0, 5],
[2, 3, 6]])
>>> 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])
>>> csc_array((data, indices, indptr), shape=(3, 3)).toarray()
array([[1, 0, 4],
[0, 0, 5],
[2, 3, 6]])
属性：
dtypedtype
数组的数据类型
shape2-元组
数组的形状。
ndimint
维度数（始终为 2）
nnz
存储值的数量，包括显式的零。
size
存储值的数量。
data
数组的 CSC 格式数据数组
indices
CSC 格式的索引数组
indptr
CSC 格式的索引指针数组
has_sorted_indices
索引是否已排序
has_canonical_format
数组/矩阵是否具有排序的索引且没有重复
T
转置。
方法：
__len__() |
|
|---|---|
arcsin() |
逐元素的反正弦函数。 |
arcsinh() |
逐元素的反双曲正弦函数。 |
arctan() |
逐元素的反正切函数。 |
arctanh() |
逐元素的反双曲正切函数。 |
argmax([axis, out]) |
返回沿轴的最大元素的索引。 |
argmin([axis, out]) |
返回沿轴的最小元素的索引。 |
asformat(format[, copy]) |
以指定格式返回此数组/矩阵。 |
asfptype() |
将数组/矩阵升级为浮点格式（如果需要）。 |
astype(dtype[, casting, copy]) |
将数组/矩阵元素转换为指定类型。 |
ceil() |
逐元素向上取整。 |
check_format([full_check]) |
检查数组/矩阵是否符合 CSR 或 CSC 格式。 |
conj([copy]) |
逐元素的复共轭。 |
conjugate([copy]) |
逐元素的复共轭。 |
copy() |
返回此数组/矩阵的副本。 |
count_nonzero() |
非零条目的数量，等同于。 |
deg2rad() |
逐元素的角度转弧度。 |
diagonal([k]) |
返回数组/矩阵的第 k 条对角线。 |
dot(other) |
普通点乘。 |
eliminate_zeros() |
从数组/矩阵中删除零条目。 |
expm1() |
逐元素的 expm1。 |
floor() |
逐元素的 floor。 |
getH() |
返回该数组/矩阵的共轭转置。 |
get_shape() |
获取稀疏数组/矩阵的形状。 |
getcol(j) |
返回数组/矩阵的第 j 列的副本，作为一个(m x 1)的稀疏数组/矩阵（列向量）。 |
getformat() |
稀疏数组/矩阵的存储格式。 |
getmaxprint() |
打印时显示的最大元素数量。 |
getnnz([axis]) |
存储值的数量，包括显式零值。 |
getrow(i) |
返回数组/矩阵的第 i 行的副本，作为一个(1 x n)的稀疏数组/矩阵（行向量）。 |
log1p() |
逐元素的 log1p。 |
max([axis, out]) |
返回数组/矩阵的最大值或沿轴的最大值。 |
maximum(other) |
该数组/矩阵与另一个数组/矩阵之间的逐元素最大值。 |
mean([axis, dtype, out]) |
沿指定轴计算算术平均值。 |
min([axis, out]) |
返回数组/矩阵的最小值或沿轴的最大值。 |
minimum(other) |
该数组/矩阵与另一个数组/矩阵之间的逐元素最小值。 |
multiply(other) |
与另一个数组/矩阵、向量或标量进行逐点乘法。 |
nanmax([axis, out]) |
返回数组/矩阵或沿轴的最大值，忽略任何 NaN 值。 |
nanmin([axis, out]) |
返回数组/矩阵或沿轴的最小值，忽略任何 NaN 值。 |
nonzero() |
数组/矩阵的非零索引。 |
power(n[, dtype]) |
此函数执行按元素的幂运算。 |
prune() |
移除所有非零元素后的空白空间。 |
rad2deg() |
按元素进行弧度转角度。 |
reshape(self, shape[, order, copy]) |
为稀疏数组/矩阵提供新的形状，而不更改其数据。 |
resize(*shape) |
就地调整数组/矩阵的尺寸为给定的 shape。 |
rint() |
按元素四舍五入。 |
set_shape(shape) |
参见 reshape。 |
setdiag(values[, k]) |
设置数组/矩阵的对角线或非对角线元素。 |
sign() |
按元素求符号。 |
sin() |
按元素求正弦。 |
sinh() |
按元素求双曲正弦。 |
sort_indices() |
原地 对此数组/矩阵的索引进行排序。 |
sorted_indices() |
返回此数组/矩阵的索引排序后的副本。 |
sqrt() |
按元素求平方根。 |
sum([axis, dtype, out]) |
沿给定轴对数组/矩阵元素求和。 |
sum_duplicates() |
通过将重复条目相加来消除重复条目。 |
tan() |
逐元素正切。 |
tanh() |
逐元素双曲正切。 |
toarray([order, out]) |
返回此稀疏数组/矩阵的稠密 ndarray 表示。 |
tobsr([blocksize, copy]) |
将此数组/矩阵转换为块稀疏行格式。 |
tocoo([copy]) |
将此数组/矩阵转换为坐标格式。 |
tocsc([copy]) |
将此数组/矩阵转换为压缩稀疏列格式。 |
tocsr([copy]) |
将此数组/矩阵转换为压缩稀疏行格式。 |
todense([order, out]) |
返回此稀疏数组/矩阵的稠密表示。 |
todia([copy]) |
将此数组/矩阵转换为稀疏对角线格式。 |
todok([copy]) |
将此数组/矩阵转换为字典键格式。 |
tolil([copy]) |
将此数组/矩阵转换为列表列表格式。 |
trace([offset]) |
返回稀疏数组/矩阵对角线上的和。 |
transpose([axes, copy]) |
反转稀疏数组/矩阵的维度。 |
trunc() |
逐元素截断。 |
| getitem | |
| mul |
scipy.sparse.csr_array
class scipy.sparse.csr_array(arg1, shape=None, dtype=None, copy=False)
压缩稀疏行数组。
可以通过几种方式实例化：
csr_array(D)
其中 D 是一个 2-D ndarray
csr_array(S)
与另一个稀疏数组或矩阵 S 一起（等同于 S.tocsr()）
csr_array((M, N), [dtype])
构造一个空数组的形状为(M, N)，dtype 是可选的，默认为 dtype='d'。
csr_array((data, (row_ind, col_ind)), [shape=(M, N)])
其中data、row_ind和col_ind满足关系a[row_ind[k], col_ind[k]] = data[k]。
csr_array((data, indices, indptr), [shape=(M, N)])
是标准的 CSR 表示，其中第 i 行的列索引存储在indices[indptr[i]:indptr[i+1]]中，它们对应的值存储在data[indptr[i]:indptr[i+1]]中。如果未提供形状参数，则从索引数组推断数组维度。
注意事项
稀疏数组可用于算术操作：它们支持加法、减法、乘法、除法和矩阵幂。
CSR 格式的优点
-
高效的算术操作 CSR + CSR，CSR * CSR 等。
-
高效的行切片
-
快速矩阵向量乘积
CSR 格式的缺点
-
缓慢的列切片操作（考虑 CSC）
-
更改稀疏结构是昂贵的（考虑 LIL 或 DOK）
规范格式
-
在每行内，索引按列排序。
-
没有重复条目。
示例
>>> import numpy as np
>>> from scipy.sparse import csr_array
>>> csr_array((3, 4), dtype=np.int8).toarray()
array([[0, 0, 0, 0],
[0, 0, 0, 0],
[0, 0, 0, 0]], dtype=int8)
>>> row = np.array([0, 0, 1, 2, 2, 2])
>>> col = np.array([0, 2, 2, 0, 1, 2])
>>> data = np.array([1, 2, 3, 4, 5, 6])
>>> csr_array((data, (row, col)), shape=(3, 3)).toarray()
array([[1, 0, 2],
[0, 0, 3],
[4, 5, 6]])
>>> 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_array((data, indices, indptr), shape=(3, 3)).toarray()
array([[1, 0, 2],
[0, 0, 3],
[4, 5, 6]])
重复条目被合并在一起：
>>> row = np.array([0, 1, 2, 0])
>>> col = np.array([0, 1, 1, 0])
>>> data = np.array([1, 2, 4, 8])
>>> csr_array((data, (row, col)), shape=(3, 3)).toarray()
array([[9, 0, 0],
[0, 2, 0],
[0, 4, 0]])
作为逐步构建 CSR 数组的示例，以下代码段从文本构建术语-文档数组：
>>> docs = [["hello", "world", "hello"], ["goodbye", "cruel", "world"]]
>>> indptr = [0]
>>> indices = []
>>> data = []
>>> vocabulary = {}
>>> for d in docs:
... for term in d:
... index = vocabulary.setdefault(term, len(vocabulary))
... indices.append(index)
... data.append(1)
... indptr.append(len(indices))
...
>>> csr_array((data, indices, indptr), dtype=int).toarray()
array([[2, 1, 0, 0],
[0, 1, 1, 1]])
属性：
dtypedtype
数组的数据类型
shape2-tuple
数组的形状。
ndimint
维数的数量（这总是 2）
nnz
存储的值的数量，包括显式零。
size
存储的值的数量。
data
CSR 格式数据数组的索引数组
indices
CSR 格式数组的索引数组
indptr
CSR 格式数组的索引指针数组
has_sorted_indices
索引是否已排序
has_canonical_format
数组/矩阵是否具有排序索引且无重复项
T
转置。
方法
__len__() |
返回数组/矩阵的长度。 |
|---|---|
arcsin() |
元素级的反正弦。 |
arcsinh() |
元素级的反双曲正弦。 |
arctan() |
元素级的反正切。 |
arctanh() |
元素级的反双曲正切。 |
argmax([axis, out]) |
返回沿着轴的最大元素的索引。 |
argmin([axis, out]) |
返回沿着轴的最小元素的索引。 |
asformat(format[, copy]) |
以指定格式返回此数组/矩阵。 |
asfptype() |
将数组/矩阵提升为浮点格式（如果需要）。 |
astype(dtype[, casting, copy]) |
将数组/矩阵元素转换为指定类型。 |
ceil() |
元素级的向上取整。 |
check_format([full_check]) |
检查数组/矩阵是否符合 CSR 或 CSC 格式。 |
conj([copy]) |
元素级的复数共轭。 |
conjugate([copy]) |
元素级的复数共轭。 |
copy() |
返回此数组/矩阵的副本。 |
count_nonzero() |
非零条目的数量，等同于。 |
deg2rad() |
元素级的角度转弧度。 |
diagonal([k]) |
返回数组/矩阵的第 k 条对角线。 |
dot(other) |
普通点积 |
eliminate_zeros() |
从数组/矩阵中删除零条目。 |
expm1() |
逐元素的 expm1。 |
floor() |
逐元素向下取整。 |
getH() |
返回该数组/矩阵的共轭转置。 |
get_shape() |
获取稀疏数组/矩阵的形状。 |
getcol(j) |
返回数组/矩阵的第 j 列的副本，作为(m x 1)稀疏数组/矩阵（列向量）。 |
getformat() |
稀疏数组/矩阵的存储格式。 |
getmaxprint() |
打印时显示的最大元素数。 |
getnnz([axis]) |
存储值的数量，包括显式零值。 |
getrow(i) |
返回数组/矩阵的第 i 行的副本，作为(1 x n)稀疏数组/矩阵（行向量）。 |
log1p() |
逐元素的 log1p。 |
max([axis, out]) |
返回数组/矩阵或沿轴的最大值。 |
maximum(other) |
该数组/矩阵与另一个数组/矩阵之间的逐元素最大值。 |
mean([axis, dtype, out]) |
计算沿指定轴的算术平均值。 |
min([axis, out]) |
返回数组/矩阵或沿轴的最小值。 |
minimum(other) |
该数组/矩阵与另一个数组/矩阵之间的逐元素最小值。 |
multiply(other) |
与另一个数组/矩阵、向量或标量进行逐点乘法运算。 |
nanmax([axis, out]) |
返回数组/矩阵的最大值或沿轴的最大值，忽略任何 NaN。 |
nanmin([axis, out]) |
返回数组/矩阵的最小值或沿轴的最小值，忽略任何 NaN。 |
nonzero() |
数组/矩阵的非零元素索引。 |
power(n[, dtype]) |
此函数执行逐元素的幂运算。 |
prune() |
删除所有非零元素后的空白空间。 |
rad2deg() |
逐元素的弧度转为角度。 |
reshape(self, shape[, order, copy]) |
在不改变数据的情况下给稀疏数组/矩阵赋予新的形状。 |
resize(*shape) |
在原地将数组/矩阵调整到给定的形状。 |
rint() |
逐元素的四舍五入。 |
set_shape(shape) |
参见 reshape. |
setdiag(values[, k]) |
设置数组/矩阵的对角线或非对角线元素。 |
sign() |
逐元素的符号函数。 |
sin() |
逐元素的正弦函数。 |
sinh() |
逐元素的双曲正弦函数。 |
sort_indices() |
就地 对此数组/矩阵的索引进行排序 |
sorted_indices() |
返回此数组/矩阵索引排序后的副本 |
sqrt() |
逐元素求平方根。 |
sum([axis, dtype, out]) |
沿指定轴对数组/矩阵元素求和。 |
sum_duplicates() |
通过将重复条目相加消除重复条目。 |
tan() |
逐元素求正切。 |
tanh() |
逐元素双曲正切。 |
toarray([order, out]) |
返回此稀疏数组/矩阵的密集 ndarray 表示。 |
tobsr([blocksize, copy]) |
将此数组/矩阵转换为块压缩稀疏行格式。 |
tocoo([copy]) |
将此数组/矩阵转换为 COO 格式。 |
tocsc([copy]) |
将此数组/矩阵转换为压缩稀疏列格式。 |
tocsr([copy]) |
将此数组/矩阵转换为压缩稀疏行格式。 |
todense([order, out]) |
返回此稀疏数组/矩阵的密集表示。 |
todia([copy]) |
将此数组/矩阵转换为稀疏 DIAgonal 格式。 |
todok([copy]) |
将此数组/矩阵转换为键值字典格式。 |
tolil([copy]) |
将此数组/矩阵转换为列表列表格式。 |
trace([offset]) |
返回稀疏数组/矩阵对角线上的元素和。 |
transpose([axes, copy]) |
反转稀疏数组/矩阵的维度。 |
trunc() |
逐元素截断。 |
| getitem | |
| mul |
scipy.sparse.dia_array
class scipy.sparse.dia_array(arg1, shape=None, dtype=None, copy=False)
带有 DIAgonal 存储的稀疏数组。
可以通过多种方式实例化：
dia_array(D)
其中 D 是一个 2-D ndarray
dia_array(S)
与另一个稀疏数组或矩阵 S 相同（等同于 S.todia()）
dia_array((M, N), [dtype])
用形状为(M, N)构造一个空数组，dtype 是可选的，默认为 dtype='d'。
dia_array((data, offsets), shape=(M, N))
其中data[k,:]存储对角线offsets[k]的对角线条目（参见下面的示例）
注释
稀疏数组可以用于算术运算：它们支持加法、减法、乘法、除法和矩阵幂。
示例
>>> import numpy as np
>>> from scipy.sparse import dia_array
>>> dia_array((3, 4), dtype=np.int8).toarray()
array([[0, 0, 0, 0],
[0, 0, 0, 0],
[0, 0, 0, 0]], dtype=int8)
>>> data = np.array([[1, 2, 3, 4]]).repeat(3, axis=0)
>>> offsets = np.array([0, -1, 2])
>>> dia_array((data, offsets), shape=(4, 4)).toarray()
array([[1, 0, 3, 0],
[1, 2, 0, 4],
[0, 2, 3, 0],
[0, 0, 3, 4]])
>>> from scipy.sparse import dia_array
>>> n = 10
>>> ex = np.ones(n)
>>> data = np.array([ex, 2 * ex, ex])
>>> offsets = np.array([-1, 0, 1])
>>> dia_array((data, offsets), shape=(n, n)).toarray()
array([[2., 1., 0., ..., 0., 0., 0.],
[1., 2., 1., ..., 0., 0., 0.],
[0., 1., 2., ..., 0., 0., 0.],
...,
[0., 0., 0., ..., 2., 1., 0.],
[0., 0., 0., ..., 1., 2., 1.],
[0., 0., 0., ..., 0., 1., 2.]])
属性：
dtypedtype
数组的数据类型
shape2 元组
数组的形状。
ndimint
数组的维数（始终为 2）
包括显式零的存储值的数量。
存储的值的数量。
data
DIA 格式数组的数据数组
offsets
DIA 格式数组的偏移数组
转置。
方法
__len__() |
|
|---|---|
arcsin() |
逐元素的反正弦函数。 |
arcsinh() |
逐元素的反双曲正弦函数。 |
arctan() |
逐元素的反正切函数。 |
arctanh() |
逐元素的反双曲正切函数。 |
asformat(format[, copy]) |
以传递的格式返回此数组/矩阵。 |
asfptype() |
将数组/矩阵升级到浮点格式（如果必要） |
astype(dtype[, casting, copy]) |
将数组/矩阵元素转换为指定类型。 |
ceil() |
逐元素向上取整。 |
conj([copy]) |
逐元素复数共轭。 |
conjugate([copy]) |
逐元素复数共轭。 |
copy() |
返回此数组/矩阵的副本。 |
count_nonzero() |
非零条目的数量，相当于 |
deg2rad() |
逐元素 deg2rad。 |
diagonal([k]) |
返回数组/矩阵的第 k 条对角线。 |
dot(other) |
普通的点积。 |
expm1() |
逐元素 expm1。 |
floor() |
逐元素向下取整。 |
getH() |
返回此数组/矩阵的共轭转置。 |
get_shape() |
获取稀疏数组/矩阵的形状。 |
getcol(j) |
返回数组/矩阵的第 j 列的副本，作为(m x 1)稀疏数组/矩阵（列向量）。 |
getformat() |
稀疏数组/矩阵的存储格式。 |
getmaxprint() |
打印时显示的最大元素数量。 |
getnnz([axis]) |
存储值的数量，包括显式零值。 |
getrow(i) |
返回数组/矩阵的第 i 行的副本，作为(1 x n)稀疏数组/矩阵（行向量）。 |
log1p() |
逐元素 log1p。 |
maximum(other) |
该数组/矩阵与另一个数组/矩阵之间的逐元素最大值。 |
mean([axis, dtype, out]) |
沿指定轴计算算术平均值。 |
minimum(other) |
此数组/矩阵与另一个数组/矩阵之间的逐元素最小值。 |
multiply(other) |
与另一个数组/矩阵逐点相乘。 |
nonzero() |
数组/矩阵的非零索引。 |
power(n[, dtype]) |
此函数执行逐元素的幂运算。 |
rad2deg() |
逐元素 rad2deg 函数。 |
reshape(self, shape[, order, copy]) |
给稀疏数组/矩阵赋予新的形状，但不改变其数据。 |
resize(*shape) |
原地将数组/矩阵调整为给定形状。 |
rint() |
逐元素取整函数。 |
set_shape(shape) |
参见 reshape。 |
setdiag(values[, k]) |
设置数组/矩阵的对角线或非对角线元素。 |
sign() |
逐元素符号函数。 |
sin() |
逐元素 sin 函数。 |
sinh() |
逐元素 sinh 函数。 |
sqrt() |
逐元素平方根函数。 |
sum([axis, dtype, out]) |
沿指定轴对数组/矩阵元素求和。 |
tan() |
逐元素 tan 函数。 |
tanh() |
逐元素 tanh 函数。 |
toarray([order, out]) |
返回该稀疏数组/矩阵的密集 ndarray 表示。 |
tobsr([blocksize, copy]) |
将该数组/矩阵转换为块稀疏行格式。 |
tocoo([copy]) |
将该数组/矩阵转换为坐标格式。 |
tocsc([copy]) |
将该数组/矩阵转换为压缩稀疏列格式。 |
tocsr([copy]) |
将该数组/矩阵转换为压缩稀疏行格式。 |
todense([order, out]) |
返回该稀疏数组/矩阵的密集表示。 |
todia([copy]) |
将该数组/矩阵转换为稀疏对角格式。 |
todok([copy]) |
将该数组/矩阵转换为键值对字典格式。 |
tolil([copy]) |
将该数组/矩阵转换为列表列表格式。 |
trace([offset]) |
返回稀疏数组/矩阵对角线上的元素之和。 |
transpose([axes, copy]) |
反转稀疏数组/矩阵的维度。 |
trunc() |
逐元素截断。 |
| mul |
scipy.sparse.dok_array
class scipy.sparse.dok_array(arg1, shape=None, dtype=None, copy=False)
基于键的字典稀疏数组。
这是一种有效的结构，用于逐步构建稀疏数组。
可以通过几种方式实例化：
dok_array(D)
其中 D 是一个二维 ndarray
dok_array(S)
与另一个稀疏数组或矩阵 S（等效于 S.todok()）。
dok_array((M,N), [dtype])
使用初始形状 (M,N) 和 dtype（可选，默认为 dtype='d'） 创建数组
注意事项
稀疏数组可用于算术运算：支持加法、减法、乘法、除法和矩阵乘方。
-
允许高效地 O(1) 访问单个元素。
-
不允许重复。
-
构建后可有效地转换为 coo_array。
示例
>>> import numpy as np
>>> from scipy.sparse import dok_array
>>> S = dok_array((5, 5), dtype=np.float32)
>>> for i in range(5):
... for j in range(5):
... S[i, j] = i + j # Update element
属性：
dtypedtype
数组的数据类型
shape2-元组
数组的形状。
ndimint
维数的数量（这始终是 2）
nnz
存储的值的数量，包括显式零。
size
存储值的数量。
T
转置。
方法
asformat(format[, copy]) |
返回用指定格式表示的数组/矩阵。 |
|---|---|
asfptype() |
将数组/矩阵提升为浮点格式（如有必要） |
astype(dtype[, casting, copy]) |
将数组/矩阵元素转换为指定类型。 |
conj([copy]) |
逐元素复数共轭。 |
conjtransp() |
返回共轭转置。 |
conjugate([copy]) |
逐元素复数共轭。 |
copy() |
返回此数组/矩阵的副本。 |
count_nonzero() |
非零条目的数量，相当于 |
diagonal([k]) |
返回数组/矩阵的第 k 个对角线。 |
dot(other) |
普通的点积。 |
get(key[, default]) |
这覆盖了 dict.get 方法，提供了类型检查但功能上是等效的。 |
getH() |
返回该数组/矩阵的共轭转置。 |
get_shape() |
获取稀疏数组/矩阵的形状。 |
getcol(j) |
返回数组/矩阵的第 j 列的副本，作为(m x 1)稀疏数组/矩阵（列向量）。 |
getformat() |
稀疏数组/矩阵的存储格式。 |
getmaxprint() |
打印时显示的最大元素数。 |
getnnz([axis]) |
存储值的数量，包括显式零值。 |
getrow(i) |
返回数组/矩阵的第 i 行的副本，作为(1 x n)稀疏数组/矩阵（行向量）。 |
maximum(other) |
该数组/矩阵与另一个数组/矩阵之间的逐元素最大值。 |
mean([axis, dtype, out]) |
计算沿指定轴的算术平均值。 |
minimum(other) |
该数组/矩阵与另一个数组/矩阵之间的逐元素最小值。 |
multiply(other) |
与另一个数组/矩阵的逐点乘法。 |
nonzero() |
数组/矩阵的非零索引。 |
power(n[, dtype]) |
逐元素的幂。 |
reshape(self, shape[, order, copy]) |
给稀疏数组/矩阵赋予新的形状，但不改变其数据。 |
resize(*shape) |
将数组/矩阵就地调整到由shape给定的尺寸。 |
set_shape(shape) |
查看reshape。 |
setdiag(values[, k]) |
设置数组/矩阵的对角线或非对角线元素。 |
sum([axis, dtype, out]) |
对给定轴上的数组/矩阵元素求和。 |
toarray([order, out]) |
返回此稀疏数组/矩阵的稠密 ndarray 表示。 |
tobsr([blocksize, copy]) |
将此数组/矩阵转换为块稀疏行格式。 |
tocoo([copy]) |
将此数组/矩阵转换为坐标格式。 |
tocsc([copy]) |
将此数组/矩阵转换为压缩稀疏列格式。 |
tocsr([copy]) |
将此数组/矩阵转换为压缩稀疏行格式。 |
todense([order, out]) |
返回此稀疏数组/矩阵的稠密表示。 |
todia([copy]) |
将此数组/矩阵转换为稀疏 DIAgonal 格式。 |
todok([copy]) |
将此数组/矩阵转换为键字典格式。 |
tolil([copy]) |
将此数组/矩阵转换为列表列表格式。 |
trace([offset]) |
返回稀疏数组/矩阵对角线上的元素之和。 |
transpose([axes, copy]) |
反转稀疏数组/矩阵的维度。 |
| getitem | |
| len | |
| mul | |
| clear | |
| items | |
| keys | |
| popitem | |
| setdefault | |
| update | |
| values |
scipy.sparse.lil_array
class scipy.sparse.lil_array(arg1, shape=None, dtype=None, copy=False)
基于行的列表列表稀疏数组。
这是逐步构建稀疏数组的结构。请注意，在最坏的情况下，插入单个项目可能需要线性时间；为了有效地构建数组，请确保按索引对行进行预排序。
可以通过几种方式实例化：
lil_array(D)
其中 D 是一个 2-D ndarray
lil_array(S)
使用另一个稀疏数组或矩阵 S（等同于 S.tolil()）
lil_array((M, N), [dtype])
构造一个形状为(M, N)的空数组，数据类型为可选，默认为 dtype=’d’。
注意事项
稀疏数组可用于算术运算：它们支持加法、减法、乘法、除法和矩阵幂。
LIL 格式的优点
-
支持灵活的切片
-
更改数组稀疏结构是高效的
LIL 格式的缺点
-
算术运算 LIL + LIL 很慢（考虑 CSR 或 CSC）
-
缓慢的列切片（考虑 CSC）
-
缓慢的矩阵向量乘积（考虑 CSR 或 CSC）
预期用途
-
LIL 是构造稀疏数组的便利格式
-
一旦构造了数组，将其转换为 CSR 或 CSC 格式以进行快速的算术和矩阵向量操作
-
在构造大型数组时考虑使用 COO 格式
数据结构
-
一个数组（
self.rows），每个都是非零元素的列索引的排序列表的行。 -
相应的非零值以类似的方式存储在
self.data中。
属性：
dtype数据类型
数组的数据类型
shape2-元组
数组的形状。
ndim整数
维度数量（这始终是 2）
存储的值的数量，包括显式零。
存储的值的数量。
data
LIL 格式的数据数组
rows
LIL 格式的行索引数组
转置。
方法
__len__() |
|
|---|---|
asformat(format[, copy]) |
将该数组/矩阵以指定格式返回。 |
asfptype() |
将数组/矩阵向浮点格式转换（如果需要） |
astype(dtype[, casting, copy]) |
将数组/矩阵元素转换为指定类型。 |
conj([copy]) |
按元素复数共轭。 |
conjugate([copy]) |
按元素复数共轭。 |
copy() |
返回此数组/矩阵的副本。 |
count_nonzero() |
非零条目的数量，相当于。 |
diagonal([k]) |
返回数组/矩阵的第 k 个对角线。 |
dot(other) |
普通点积。 |
getH() |
返回此数组/矩阵的共轭转置。 |
get_shape() |
获取稀疏数组/矩阵的形状。 |
getcol(j) |
返回数组/矩阵的第 j 列的副本，作为(m x 1)稀疏数组/矩阵（列向量）。 |
getformat() |
稀疏数组/矩阵的存储格式。 |
getmaxprint() |
打印时显示的最大元素数。 |
getnnz([axis]) |
存储值的数量，包括显式零值。 |
getrow(i) |
返回第'i'行的副本。 |
getrowview(i) |
返回第'i'行的视图（不复制）。 |
maximum(other) |
数组/矩阵与另一个数组/矩阵之间的按元素最大值。 |
mean([axis, dtype, out]) |
沿指定轴计算算术平均值。 |
minimum(other) |
该数组/矩阵与另一个数组/矩阵逐元素取最小值 |
multiply(other) |
与另一个数组/矩阵进行逐元素相乘 |
nonzero() |
返回数组/矩阵中非零元素的索引位置 |
power(n[, dtype]) |
逐元素求幂 |
reshape(self, shape[, order, copy]) |
为稀疏数组/矩阵提供新的形状，不改变其数据 |
resize(*shape) |
调整数组/矩阵到给定shape的尺寸 |
set_shape(shape) |
参见reshape |
setdiag(values[, k]) |
设置数组/矩阵的对角线或非对角线元素 |
sum([axis, dtype, out]) |
沿指定轴对数组/矩阵元素求和 |
toarray([order, out]) |
返回该稀疏数组/矩阵的密集 ndarray 表示 |
tobsr([blocksize, copy]) |
将该数组/矩阵转换为块稀疏行格式 |
tocoo([copy]) |
将该数组/矩阵转换为 COO 格式 |
tocsc([copy]) |
将该数组/矩阵转换为压缩稀疏列格式 |
tocsr([copy]) |
将该数组/矩阵转换为压缩稀疏行格式 |
todense([order, out]) |
返回该稀疏数组/矩阵的密集表示 |
todia([copy]) |
将该数组/矩阵转换为稀疏对角格式 |
todok([copy]) |
将此数组/矩阵转换为键字典格式。 |
tolil([copy]) |
将此数组/矩阵转换为列表列表格式。 |
trace([offset]) |
返回稀疏数组/矩阵沿对角线的和。 |
transpose([axes, copy]) |
反转稀疏数组/矩阵的维度。 |
| getitem | |
| mul |
scipy.sparse.sparray
原文：
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.sparse.sparray.html#scipy.sparse.sparray
class scipy.sparse.sparray
This class provides a base class for all sparse arrays. It cannot be instantiated. Most of the work is provided by subclasses.
scipy.sparse.bsr_matrix
class scipy.sparse.bsr_matrix(arg1, shape=None, dtype=None, copy=False, blocksize=None)
块稀疏行格式稀疏矩阵。
这可以通过几种方式实现：
bsr_matrix(D, [blocksize=(R,C)])
其中 D 是 2D ndarray。
bsr_matrix(S, [blocksize=(R,C)])
与另一个稀疏数组或矩阵 S（等同于 S.tobsr()）
bsr_matrix((M, N), [blocksize=(R,C), dtype])
用于构造形状为（M，N）的空稀疏矩阵，dtype 是可选的，默认为 dtype='d'。
bsr_matrix((data, ij), [blocksize=(R,C), shape=(M, N)])
当data和ij满足a[ij[0, k], ij[1, k]] = data[k]
bsr_matrix((data, indices, indptr), [shape=(M, N)])
是标准的 BSR 表示，其中第 i 行的块列索引存储在indices[indptr[i]:indptr[i+1]]中，并且它们对应的块值存储在data[indptr[i]:indptr[i+1]]中。如果未提供形状参数，则从索引数组中推断出矩阵的维度。
注意事项
稀疏矩阵可以用于算术运算：支持加法、减法、乘法、除法和矩阵幂运算。
BSR 格式总结
块稀疏行（BSR）格式与压缩稀疏行（CSR）格式非常相似。BSR 适用于具有稠密子矩阵的稀疏矩阵，例如下面的最后一个示例。这种稀疏块矩阵经常出现在向量值有限元离散化中。在这些情况下，对于许多稀疏算术运算，BSR 比 CSR 和 CSC 更有效率。
块大小
块大小（R，C）必须均匀地划分稀疏矩阵的形状（M，N）。也就是说，R 和 C 必须满足关系M % R = 0和N % C = 0。
如果未指定块大小，则将应用简单的启发式方法来确定适当的块大小。
规范格式
在规范格式中，没有重复的块，并且每行的索引都是排序的。
示例
>>> import numpy as np
>>> from scipy.sparse import bsr_matrix
>>> bsr_matrix((3, 4), dtype=np.int8).toarray()
array([[0, 0, 0, 0],
[0, 0, 0, 0],
[0, 0, 0, 0]], dtype=int8)
>>> row = np.array([0, 0, 1, 2, 2, 2])
>>> col = np.array([0, 2, 2, 0, 1, 2])
>>> data = np.array([1, 2, 3 ,4, 5, 6])
>>> bsr_matrix((data, (row, col)), shape=(3, 3)).toarray()
array([[1, 0, 2],
[0, 0, 3],
[4, 5, 6]])
>>> 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)).toarray()
array([[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]])
属性：
dtype数据类型
矩阵的数据类型
shape2 元组
矩阵的形状
ndim整型
维度数量（始终为 2）
存储的值数量，包括显式的零值。
存储的值数量。
data
BSR 格式矩阵的数据数组
indices
BSR 格式矩阵的索引数组
indptr
BSR 格式矩阵的索引指针数组
矩阵的块大小。
has_sorted_indicesbool
索引是否已排序
has_canonical_formatbool
数组/矩阵是否具有排序的索引且无重复
T
转置。
方法
__len__() |
|
|---|---|
__mul__(other) |
|
arcsin() |
逐元素反正弦函数。 |
arcsinh() |
逐元素反双曲正弦函数。 |
arctan() |
逐元素反正切函数。 |
arctanh() |
逐元素反双曲正切函数。 |
argmax([axis, out]) |
返回沿轴的最大元素的索引。 |
argmin([axis, out]) |
返回沿轴的最小元素的索引。 |
asformat(format[, copy]) |
以指定格式返回此数组/矩阵。 |
asfptype() |
将矩阵提升为浮点数格式（如有必要）。 |
astype(dtype[, casting, copy]) |
将数组/矩阵元素转换为指定类型。 |
ceil() |
逐元素向上取整。 |
check_format([full_check]) |
检查数组/矩阵是否符合 BSR 格式。 |
conj([copy]) |
逐元素复数共轭。 |
conjugate([copy]) |
逐元素复数共轭。 |
copy() |
返回该数组/矩阵的副本。 |
count_nonzero() |
非零条目的数量，等同于。 |
deg2rad() |
逐元素的角度转弧度。 |
diagonal([k]) |
返回数组/矩阵的第 k 条对角线。 |
dot(other) |
普通的点积。 |
eliminate_zeros() |
去除矩阵中的零元素（就地操作）。 |
expm1() |
逐元素的 expm1。 |
floor() |
逐元素的 floor。 |
getH() |
返回该矩阵的共轭转置。 |
get_shape() |
获取矩阵的形状。 |
getcol(j) |
返回矩阵的第 j 列的副本，作为一个 (m x 1) 稀疏矩阵（列向量）。 |
getformat() |
矩阵存储格式。 |
getmaxprint() |
打印时显示的最大元素数。 |
getnnz([axis]) |
存储的值的数量，包括显式的零。 |
getrow(i) |
返回矩阵的第 i 行的副本，作为 (1 x n) 稀疏矩阵（行向量）。 |
log1p() |
逐元素的 log1p。 |
max([axis, out]) |
返回数组/矩阵的最大值或沿轴的最大值。 |
maximum(other) |
此矩阵和另一个数组/矩阵之间的逐元素最大值。 |
mean([axis, dtype, out]) |
沿指定轴计算算术平均值。 |
min([axis, out]) |
返回数组/矩阵或指定轴向的最小值。 |
minimum(other) |
此矩阵和另一个数组/矩阵之间的逐元素最小值。 |
multiply(other) |
逐点乘以另一个数组/矩阵、向量或标量。 |
nanmax([axis, out]) |
返回数组/矩阵或指定轴向的最大值，忽略任何 NaN 值。 |
nanmin([axis, out]) |
返回数组/矩阵或指定轴向的最小值，忽略任何 NaN 值。 |
nonzero() |
数组/矩阵的非零索引。 |
power(n[, dtype]) |
此函数执行逐元素的幂运算。 |
prune() |
移除所有非零元素后的空白空间。 |
rad2deg() |
逐元素将弧度转换为角度。 |
reshape(self, shape[, order, copy]) |
将稀疏数组/矩阵重新整形为新的形状，但不改变其数据。 |
resize(*shape) |
原地调整数组/矩阵的维度为给定的 shape。 |
rint() |
逐元素四舍五入。 |
set_shape(shape) |
在原地设置矩阵的形状。 |
setdiag(values[, k]) |
设置数组/矩阵的对角线或非对角线元素。 |
sign() |
逐元素求符号。 |
sin() |
逐元素求正弦。 |
sinh() |
逐元素求双曲正弦。 |
sort_indices() |
原地 对此数组/矩阵的索引进行排序。 |
sorted_indices() |
返回按排序索引的此数组/矩阵的副本。 |
sqrt() |
逐元素求平方根。 |
sum([axis, dtype, out]) |
沿给定轴对数组/矩阵元素求和。 |
sum_duplicates() |
通过将重复的数组/矩阵条目相加来消除重复项。 |
tan() |
逐元素求正切。 |
tanh() |
逐元素求双曲正切。 |
toarray([order, out]) |
返回此稀疏数组/矩阵的密集 ndarray 表示。 |
tobsr([blocksize, copy]) |
将此数组/矩阵转换为块稀疏行格式。 |
tocoo([copy]) |
将此数组/矩阵转换为 COO 格式。 |
tocsc([copy]) |
将此数组/矩阵转换为压缩稀疏列格式。 |
tocsr([copy]) |
将此数组/矩阵转换为压缩稀疏行格式。 |
todense([order, out]) |
返回此稀疏数组/矩阵的密集表示。 |
todia([copy]) |
将此数组/矩阵转换为稀疏对角格式。 |
todok([copy]) |
将此数组/矩阵转换为字典键格式。 |
tolil([copy]) |
将此数组/矩阵转换为列表列表格式。 |
trace([offset]) |
返回稀疏数组/矩阵沿对角线的和。 |
transpose([axes, copy]) |
反转稀疏数组/矩阵的维度。 |
trunc() |
逐元素截断。 |
| getitem |
scipy.sparse.coo_matrix
class scipy.sparse.coo_matrix(arg1, shape=None, dtype=None, copy=False)
COO 格式中的稀疏矩阵。
也称为 'ijv' 或 'triplet' 格式。
这可以通过几种方式实例化：
coo_matrix(D)
其中 D 是 2-D 数组
coo_matrix(S)
与另一个稀疏数组或矩阵 S 进行操作（等同于 S.tocoo()）
coo_matrix((M, N), [dtype])
用于构造形状为 (M, N) 的空矩阵，数据类型是可选的，默认为 dtype='d'。
coo_matrix((data, (i, j)), [shape=(M, N)])
从三个数组构造：
-
data[:] 矩阵的条目，按任意顺序排列
-
i[:] 矩阵条目的行索引
-
j[:] 矩阵条目的列索引
当未指定形状时，从索引数组推断。
注意事项
稀疏矩阵可用于算术操作：它们支持加法、减法、乘法、除法和矩阵幂。
COO 格式的优点
-
促进稀疏格式之间的快速转换
-
允许重复条目（见示例）
-
非常快速地转换为 CSR/CSC 格式和从中转换
COO 格式的缺点
-
不直接支持：
-
算术操作
-
切片
-
预期用途
-
COO 是构造稀疏矩阵的快速格式
-
一旦构造了 COO 矩阵，将其转换为 CSR 或 CSC 格式以进行快速算术和矩阵向量操作
-
默认情况下，在转换为 CSR 或 CSC 格式时，重复的 (i,j) 条目将被汇总在一起。这有助于高效地构造有限元矩阵等（见示例）
规范格式
-
条目和索引按行、列排序。
-
没有重复条目（即重复的 (i,j) 位置）
-
数据数组可以具有显式的零。
示例
>>> # Constructing an empty matrix
>>> import numpy as np
>>> from scipy.sparse import coo_matrix
>>> coo_matrix((3, 4), dtype=np.int8).toarray()
array([[0, 0, 0, 0],
[0, 0, 0, 0],
[0, 0, 0, 0]], dtype=int8)
>>> # Constructing a matrix using ijv format
>>> row = np.array([0, 3, 1, 0])
>>> col = np.array([0, 3, 1, 2])
>>> data = np.array([4, 5, 7, 9])
>>> coo_matrix((data, (row, col)), shape=(4, 4)).toarray()
array([[4, 0, 9, 0],
[0, 7, 0, 0],
[0, 0, 0, 0],
[0, 0, 0, 5]])
>>> # Constructing a matrix with duplicate indices
>>> row = np.array([0, 0, 1, 3, 1, 0, 0])
>>> col = np.array([0, 2, 1, 3, 1, 0, 0])
>>> data = np.array([1, 1, 1, 1, 1, 1, 1])
>>> coo = coo_matrix((data, (row, col)), shape=(4, 4))
>>> # Duplicate indices are maintained until implicitly or explicitly summed
>>> np.max(coo.data)
1
>>> coo.toarray()
array([[3, 0, 1, 0],
[0, 2, 0, 0],
[0, 0, 0, 0],
[0, 0, 0, 1]])
属性：
dtype数据类型
矩阵的数据类型
shape2-元组
矩阵的形状
ndim整数
维度的数量（这总是 2）
存储的值的数量，包括显式的零。
存储值的数量。
数据
COO 格式矩阵的数据数组
行
COO 格式矩阵的行索引数组
列
COO 格式矩阵的列索引数组
has_canonical_format布尔值
矩阵是否具有排序的索引且无重复项
矩阵的格式化字符串。
转置。
方法
__len__() |
|
|---|---|
__mul__(other) |
|
arcsin() |
逐元素反正弦函数。 |
arcsinh() |
逐元素反双曲正弦函数。 |
arctan() |
逐元素反正切函数。 |
arctanh() |
逐元素反双曲正切函数。 |
argmax([axis, out]) |
返回沿轴的最大元素的索引。 |
argmin([axis, out]) |
返回沿轴的最小元素的索引。 |
asformat(format[, copy]) |
以指定格式返回此数组/矩阵。 |
asfptype() |
将矩阵升级为浮点数格式（如有必要）。 |
astype(dtype[, casting, copy]) |
将数组/矩阵元素转换为指定类型。 |
ceil() |
逐元素向上取整。 |
conj([copy]) |
逐元素复共轭。 |
conjugate([copy]) |
逐元素复共轭。 |
copy() |
返回此数组/矩阵的副本。 |
count_nonzero() |
非零元素的数量，相当于 |
deg2rad() |
逐元素角度转弧度。 |
diagonal([k]) |
返回数组/矩阵的第 k 条对角线。 |
dot(other) |
普通的点积。 |
eliminate_zeros() |
从数组/矩阵中删除零条目。 |
expm1() |
逐元素的 expm1。 |
floor() |
逐元素向下取整。 |
getH() |
返回该矩阵的共轭转置。 |
get_shape() |
获取矩阵的形状。 |
getcol(j) |
返回矩阵的第 j 列的副本，作为（m x 1）稀疏矩阵（列向量）。 |
getformat() |
矩阵存储格式。 |
getmaxprint() |
打印时显示的最大元素数。 |
getnnz([axis]) |
存储的值的数量，包括显式的零。 |
getrow(i) |
返回矩阵的第 i 行的副本，作为（1 x n）稀疏矩阵（行向量）。 |
log1p() |
逐元素的 log1p。 |
max([axis, out]) |
返回数组/矩阵的最大值或沿轴的最大值。 |
maximum(other) |
该矩阵与另一个数组/矩阵之间的逐元素最大值。 |
mean([axis, dtype, out]) |
沿指定轴计算算术平均值。 |
min([axis, out]) |
返回数组/矩阵的最小值或沿轴的最小值。 |
minimum(other) |
该矩阵与另一个数组/矩阵之间的逐元素最小值。 |
multiply(other) |
与另一个数组/矩阵进行逐点乘法。 |
nanmax([axis, out]) |
返回数组/矩阵或沿轴的最大值，忽略任何 NaN。 |
nanmin([axis, out]) |
返回数组/矩阵或沿轴的最小值，忽略任何 NaN。 |
nonzero() |
数组/矩阵的非零索引。 |
power(n[, dtype]) |
对数组/矩阵进行逐点幂运算。 |
rad2deg() |
元素逐个将弧度转换为角度。 |
reshape(self, shape[, order, copy]) |
为稀疏数组/矩阵赋予新的形状，但不改变其数据。 |
resize(*shape) |
原地调整数组/矩阵的形状为给定的 shape。 |
rint() |
元素逐个四舍五入。 |
set_shape(shape) |
原地设置矩阵的形状。 |
setdiag(values[, k]) |
设置数组/矩阵的对角线或非对角线元素。 |
sign() |
元素逐个取符号。 |
sin() |
元素逐个求正弦。 |
sinh() |
元素逐个求双曲正弦。 |
sqrt() |
元素逐个求平方根。 |
sum([axis, dtype, out]) |
沿给定轴对数组/矩阵元素求和。 |
sum_duplicates() |
通过将重复的条目相加来消除重复条目。 |
tan() |
逐元素的正切函数。 |
tanh() |
逐元素的双曲正切函数。 |
toarray([order, out]) |
返回此稀疏数组/矩阵的密集 ndarray 表示。 |
tobsr([blocksize, copy]) |
将此数组/矩阵转换为块稀疏行格式。 |
tocoo([copy]) |
将此数组/矩阵转换为坐标格式。 |
tocsc([copy]) |
将此数组/矩阵转换为压缩稀疏列格式。 |
tocsr([copy]) |
将此数组/矩阵转换为压缩稀疏行格式。 |
todense([order, out]) |
返回此稀疏数组/矩阵的密集表示。 |
todia([copy]) |
将此数组/矩阵转换为稀疏对角格式。 |
todok([copy]) |
将此数组/矩阵转换为键值对字典格式。 |
tolil([copy]) |
将此数组/矩阵转换为列表列表格式。 |
trace([offset]) |
返回稀疏数组/矩阵沿对角线的总和。 |
transpose([axes, copy]) |
反转稀疏数组/矩阵的维度。 |
trunc() |
逐元素的截断函数。 |
scipy.sparse.csc_matrix
class scipy.sparse.csc_matrix(arg1, shape=None, dtype=None, copy=False)
压缩稀疏列矩阵。
可以通过几种方式实例化：
csc_matrix(D)
其中 D 是一个二维 ndarray
csc_matrix(S)
与另一个稀疏数组或矩阵 S（等同于 S.tocsc()）
csc_matrix((M, N), [dtype])
用于构建形状为 (M, N) 的空矩阵，dtype 可选，默认为 dtype='d'。
csc_matrix((data, (row_ind, col_ind)), [shape=(M, N)])
其中 data、row_ind 和 col_ind 满足关系 a[row_ind[k], col_ind[k]] = data[k]。
csc_matrix((data, indices, indptr), [shape=(M, N)])
是标准的 CSC 表示，其中第 i 列的行索引存储在 indices[indptr[i]:indptr[i+1]]，它们对应的值存储在 data[indptr[i]:indptr[i+1]]。如果未提供 shape 参数，则从索引数组推断出矩阵的维度。
注释
稀疏矩阵可以用于算术运算：支持加法、减法、乘法、除法和矩阵乘方。
CSC 格式的优点
-
高效的算术运算 CSC + CSC，CSC * CSC 等。
-
高效的列切片
-
快速的矩阵向量乘法（CSR，BSR 可能更快）
CSC 格式的缺点
-
缓慢的行切片操作（考虑 CSR）
-
对稀疏结构的更改代价高昂（考虑 LIL 或 DOK）
规范格式
-
每列内的索引按行排序。
-
没有重复的条目。
示例
>>> import numpy as np
>>> from scipy.sparse import csc_matrix
>>> csc_matrix((3, 4), dtype=np.int8).toarray()
array([[0, 0, 0, 0],
[0, 0, 0, 0],
[0, 0, 0, 0]], dtype=int8)
>>> row = np.array([0, 2, 2, 0, 1, 2])
>>> col = np.array([0, 0, 1, 2, 2, 2])
>>> data = np.array([1, 2, 3, 4, 5, 6])
>>> csc_matrix((data, (row, col)), shape=(3, 3)).toarray()
array([[1, 0, 4],
[0, 0, 5],
[2, 3, 6]])
>>> 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])
>>> csc_matrix((data, indices, indptr), shape=(3, 3)).toarray()
array([[1, 0, 4],
[0, 0, 5],
[2, 3, 6]])
属性：
dtype数据类型
矩阵的数据类型
shape的二元组
矩阵的形状
ndim整数
维度数量（始终为 2）
nnz
存储的值的数量，包括显式的零值。
size
存储值的数量
data
CSC 格式矩阵的数据数组
indices
CSC 格式矩阵的索引数组
indptr
CSC 格式矩阵的索引指针数组
has_sorted_indices
索引是否已排序
has_canonical_format
数组/矩阵是否具有排序的索引且无重复
T
转置。
方法
__len__() |
|
|---|---|
__mul__ |
|
arcsin() |
逐元素反正弦。 |
arcsinh() |
逐元素反双曲正弦。 |
arctan() |
逐元素反正切。 |
arctanh() |
逐元素反双曲正切。 |
argmax([axis, out]) |
返回沿轴的最大元素的索引。 |
argmin([axis, out]) |
返回沿轴的最小元素的索引。 |
asformat(format[, copy]) |
以指定格式返回此数组/矩阵。 |
asfptype() |
将矩阵提升为浮点格式（如有必要） |
astype(dtype[, casting, copy]) |
将数组/矩阵元素转换为指定类型。 |
ceil() |
逐元素向上取整。 |
check_format([full_check]) |
检查数组/矩阵是否符合 CSR 或 CSC 格式。 |
conj([copy]) |
逐元素复数共轭。 |
conjugate([copy]) |
逐元素复数共轭。 |
copy() |
返回此数组/矩阵的副本。 |
count_nonzero() |
非零条目的数量，等效于 |
deg2rad() |
逐元素角度转弧度。 |
diagonal([k]) |
返回数组/矩阵的第 k 个对角线。 |
dot(other) |
普通的点积。 |
eliminate_zeros() |
从数组/矩阵中删除零条目。 |
expm1() |
逐元素的 expm1。 |
floor() |
逐元素向下取整。 |
getH() |
返回该矩阵的共轭转置。 |
get_shape() |
获取矩阵的形状。 |
getcol(j) |
返回矩阵的第 j 列副本，作为（m x 1）稀疏矩阵（列向量）。 |
getformat() |
矩阵存储格式。 |
getmaxprint() |
打印时显示的最大元素数量。 |
getnnz([axis]) |
存储的值的数量，包括显式的零值。 |
getrow(i) |
返回矩阵的第 i 行副本，作为（1 x n）稀疏矩阵（行向量）。 |
log1p() |
逐元素的 log1p。 |
max([axis, out]) |
返回数组/矩阵的最大值或沿轴的最大值。 |
maximum(other) |
该数组/矩阵与另一个数组/矩阵的逐元素最大值。 |
mean([axis, dtype, out]) |
沿指定轴计算算术平均值。 |
min([axis, out]) |
返回数组/矩阵的最小值或沿轴的最小值。 |
minimum(other) |
该数组/矩阵与另一个数组/矩阵的逐元素最小值。 |
multiply(other) |
与另一个数组/矩阵、向量或标量进行逐点乘法。 |
nanmax（[axis, out]） |
返回数组/矩阵的最大值或沿轴的最大值，忽略任何 NaN 值。 |
nanmin（[axis, out]） |
返回数组/矩阵的最小值或沿轴的最小值，忽略任何 NaN 值。 |
nonzero() |
返回数组/矩阵的非零索引。 |
power(n[, dtype]) |
此函数执行逐元素的幂运算。 |
prune() |
删除所有非零元素后的空白空间。 |
rad2deg() |
逐元素弧度转角度。 |
reshape(self, shape[, order, copy]) |
在不改变数据的情况下，为稀疏数组/矩阵提供新的形状。 |
resize（*shape） |
将数组/矩阵原地调整大小为给定的shape维度。 |
rint() |
逐元素四舍五入。 |
set_shape(shape) |
原地设置矩阵的形状。 |
setdiag(values[, k]) |
设置数组/矩阵的对角线或非对角线元素。 |
sign() |
逐元素取符号。 |
sin() |
逐元素求正弦值。 |
sinh() |
逐元素求双曲正弦值。 |
sort_indices() |
原地对此数组/矩阵的索引进行排序。 |
sorted_indices() |
返回此数组/矩阵的带有排序索引的副本。 |
sqrt() |
元素级的平方根函数。 |
sum([axis, dtype, out]) |
沿指定轴对数组/矩阵元素求和。 |
sum_duplicates() |
通过将重复条目相加来消除重复条目。 |
tan() |
元素级的正切函数。 |
tanh() |
元素级的双曲正切函数。 |
toarray([order, out]) |
返回此稀疏数组/矩阵的密集 ndarray 表示。 |
tobsr([blocksize, copy]) |
将此数组/矩阵转换为块稀疏行格式。 |
tocoo([copy]) |
将此数组/矩阵转换为坐标格式。 |
tocsc([copy]) |
将此数组/矩阵转换为压缩稀疏列格式。 |
tocsr([copy]) |
将此数组/矩阵转换为压缩稀疏行格式。 |
todense([order, out]) |
返回此稀疏数组/矩阵的密集表示。 |
todia([copy]) |
将此数组/矩阵转换为稀疏对角线格式。 |
todok([copy]) |
将此数组/矩阵转换为键字典格式。 |
tolil([copy]) |
将此数组/矩阵转换为列表列表格式。 |
trace([offset]) |
返回稀疏数组/矩阵沿对角线的总和。 |
transpose([axes, copy]) |
反转稀疏数组/矩阵的维度。 |
trunc() |
元素级的截断函数。 |
| getitem |
scipy.sparse.csr_matrix
class scipy.sparse.csr_matrix(arg1, shape=None, dtype=None, copy=False)
压缩稀疏行（CSR）矩阵。
可以通过几种方式实例化：
csr_matrix(D)
其中 D 是一个二维 ndarray
csr_matrix(S)
与另一个稀疏数组或矩阵 S 进行操作（等同于 S.tocsr()）
csr_matrix((M, N), [dtype])
以形状（M，N）实例化空矩阵时，数据类型是可选的，默认为 dtype=’d’。
csr_matrix((data, (row_ind, col_ind)), [shape=(M, N)])
其中 data，row_ind 和 col_ind 满足关系 a[row_ind[k], col_ind[k]] = data[k]。
csr_matrix((data, indices, indptr), [shape=(M, N)])
是标准的 CSR 表示，其中行 i 的列索引存储在 indices[indptr[i]:indptr[i+1]] 中，并且它们对应的值存储在 data[indptr[i]:indptr[i+1]] 中。如果未提供形状参数，则从索引数组中推断出矩阵的维度。
注释
稀疏矩阵可以用于算术运算：它们支持加法、减法、乘法、除法和矩阵乘方。
CSR 格式的优势
-
高效的算术操作 CSR + CSR，CSR * CSR 等。
-
高效的行切片
-
快速矩阵向量乘积
CSR 格式的缺点
-
缓慢的列切片操作（考虑 CSC）
-
更改稀疏结构的代价高昂（考虑 LIL 或 DOK）
规范格式
-
每行内部的索引按列排序。
-
没有重复条目。
示例
>>> import numpy as np
>>> from scipy.sparse import csr_matrix
>>> csr_matrix((3, 4), dtype=np.int8).toarray()
array([[0, 0, 0, 0],
[0, 0, 0, 0],
[0, 0, 0, 0]], dtype=int8)
>>> row = np.array([0, 0, 1, 2, 2, 2])
>>> col = np.array([0, 2, 2, 0, 1, 2])
>>> data = np.array([1, 2, 3, 4, 5, 6])
>>> csr_matrix((data, (row, col)), shape=(3, 3)).toarray()
array([[1, 0, 2],
[0, 0, 3],
[4, 5, 6]])
>>> 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]])
重复条目将被合并：
>>> row = np.array([0, 1, 2, 0])
>>> col = np.array([0, 1, 1, 0])
>>> data = np.array([1, 2, 4, 8])
>>> csr_matrix((data, (row, col)), shape=(3, 3)).toarray()
array([[9, 0, 0],
[0, 2, 0],
[0, 4, 0]])
作为逐步构建 CSR 矩阵的示例，以下代码段从文本构建术语-文档矩阵：
>>> docs = [["hello", "world", "hello"], ["goodbye", "cruel", "world"]]
>>> indptr = [0]
>>> indices = []
>>> data = []
>>> vocabulary = {}
>>> for d in docs:
... for term in d:
... index = vocabulary.setdefault(term, len(vocabulary))
... indices.append(index)
... data.append(1)
... indptr.append(len(indices))
...
>>> csr_matrix((data, indices, indptr), dtype=int).toarray()
array([[2, 1, 0, 0],
[0, 1, 1, 1]])
属性：
dtype 数据类型
矩阵的数据类型
shape 2-元组
矩阵的形状
ndimint
维度数（始终为 2）
存储的值的数量，包括显式的零。
存储的值的数量。
data
CSR 格式矩阵的数据数组
indices
CSR 格式矩阵的索引数组
indptr
CSR 格式矩阵的索引指针数组
索引是否已排序
数组/矩阵是否具有排序的索引且无重复项
转置。
方法
__len__() |
|
|---|---|
__mul__(other) |
|
arcsin() |
元素级反正弦。 |
arcsinh() |
元素级反双曲正弦。 |
arctan() |
元素级反正切。 |
arctanh() |
元素级反双曲正切。 |
argmax([axis, out]) |
沿轴返回最大元素的索引。 |
argmin([axis, out]) |
沿轴返回最小元素的索引。 |
asformat(format[, copy]) |
以指定格式返回此数组/矩阵。 |
asfptype() |
将矩阵升级为浮点格式（如果需要） |
astype(dtype[, casting, copy]) |
将数组/矩阵元素转换为指定类型。 |
ceil() |
元素级向上取整。 |
check_format([full_check]) |
检查数组/矩阵是否符合 CSR 或 CSC 格式。 |
conj([copy]) |
元素级复数共轭。 |
conjugate([copy]) |
元素级复数共轭。 |
copy() |
返回此数组/矩阵的副本。 |
count_nonzero() |
非零元素的数量，相当于 |
deg2rad() |
元素级角度转弧度。 |
diagonal([k]) |
返回数组/矩阵的第 k 条对角线。 |
dot(other) |
普通的点积。 |
eliminate_zeros() |
从数组/矩阵中删除零条目。 |
expm1() |
逐元素的 expm1 运算。 |
floor() |
逐元素的 floor 运算。 |
getH() |
返回该矩阵的共轭转置。 |
get_shape() |
获取矩阵的形状。 |
getcol(j) |
返回矩阵第 j 列的副本，作为（m x 1）稀疏矩阵（列向量）。 |
getformat() |
矩阵存储格式。 |
getmaxprint() |
打印时显示的最大元素数量。 |
getnnz([axis]) |
存储值的数量，包括显式的零值。 |
getrow(i) |
返回矩阵第 i 行的副本，作为（1 x n）稀疏矩阵（行向量）。 |
log1p() |
逐元素的 log1p 运算。 |
max([axis, out]) |
返回数组/矩阵的最大值或沿轴的最大值。 |
maximum(other) |
该数组/矩阵与另一个数组/矩阵的逐元素最大值。 |
mean([axis, dtype, out]) |
沿指定轴计算算术平均值。 |
min([axis, out]) |
返回数组/矩阵的最小值或沿轴的最小值。 |
minimum(other) |
与另一个数组/矩阵之间的逐元素最小值。 |
multiply(other) |
与另一个数组/矩阵、向量或标量的逐点乘积。 |
nanmax([axis, out]) |
返回数组/矩阵或沿轴的最大值，忽略任何 NaN 值。 |
nanmin([axis, out]) |
返回数组/矩阵或沿轴的最小值，忽略任何 NaN 值。 |
nonzero() |
数组/矩阵的非零索引。 |
power(n[, dtype]) |
执行逐元素的幂运算。 |
prune() |
移除所有非零元素后的空白空间。 |
rad2deg() |
逐元素的 rad2deg。 |
reshape(self, shape[, order, copy]) |
在不改变数据的情况下，为稀疏数组/矩阵提供新的形状。 |
resize(*shape) |
原地调整数组/矩阵的形状为给定的 shape。 |
rint() |
逐元素的 rint。 |
set_shape(shape) |
原地设置矩阵的形状。 |
setdiag(values[, k]) |
设置数组/矩阵的对角线或非对角线元素。 |
sign() |
逐元素的符号。 |
sin() |
逐元素的 sin。 |
sinh() |
逐元素的 sinh。 |
sort_indices() |
原地对数组/矩阵的索引进行排序。 |
sorted_indices() |
返回按索引排序的稀疏数组/矩阵的副本。 |
sqrt() |
逐元素的平方根函数。 |
sum([axis, dtype, out]) |
沿着给定轴对数组/矩阵元素求和。 |
sum_duplicates() |
通过将重复条目相加来消除重复条目。 |
tan() |
逐元素的正切函数。 |
tanh() |
逐元素的双曲正切函数。 |
toarray([order, out]) |
返回这个稀疏数组/矩阵的稠密 ndarray 表示。 |
tobsr([blocksize, copy]) |
将这个数组/矩阵转换为块稀疏行格式。 |
tocoo([copy]) |
将这个数组/矩阵转换为坐标格式。 |
tocsc([copy]) |
将这个数组/矩阵转换为压缩稀疏列格式。 |
tocsr([copy]) |
将这个数组/矩阵转换为压缩稀疏行格式。 |
todense([order, out]) |
返回这个稀疏数组/矩阵的稠密表示。 |
todia([copy]) |
将这个数组/矩阵转换为稀疏对角格式。 |
todok([copy]) |
将这个数组/矩阵转换为键值对字典格式。 |
tolil([copy]) |
将这个数组/矩阵转换为列表格式。 |
trace([offset]) |
返回稀疏数组/矩阵对角线元素的总和。 |
transpose([axes, copy]) |
反转稀疏数组/矩阵的维度。 |
trunc() |
按元素截断。 |
| getitem |
scipy.sparse.dia_matrix
class scipy.sparse.dia_matrix(arg1, shape=None, dtype=None, copy=False)
使用 DIAgonal 存储的稀疏矩阵。
这可以通过几种方式来实例化：
dia_matrix(D)
其中 D 是一个二维 ndarray
dia_matrix(S)
与另一个稀疏数组或矩阵 S 一起（相当于 S.todia()）
dia_matrix((M, N), [dtype])
用形状为（M，N）的空矩阵构造，数据类型是可选的，默认为 dtype=’d’。
dia_matrix((data, offsets), shape=(M, N))
其中data[k,:]存储对角线offsets[k]的对角线条目（参见下面的示例）
注意事项
稀疏矩阵可用于算术运算：它们支持加法、减法、乘法、除法和矩阵幂。
示例
>>> import numpy as np
>>> from scipy.sparse import dia_matrix
>>> dia_matrix((3, 4), dtype=np.int8).toarray()
array([[0, 0, 0, 0],
[0, 0, 0, 0],
[0, 0, 0, 0]], dtype=int8)
>>> data = np.array([[1, 2, 3, 4]]).repeat(3, axis=0)
>>> offsets = np.array([0, -1, 2])
>>> dia_matrix((data, offsets), shape=(4, 4)).toarray()
array([[1, 0, 3, 0],
[1, 2, 0, 4],
[0, 2, 3, 0],
[0, 0, 3, 4]])
>>> from scipy.sparse import dia_matrix
>>> n = 10
>>> ex = np.ones(n)
>>> data = np.array([ex, 2 * ex, ex])
>>> offsets = np.array([-1, 0, 1])
>>> dia_matrix((data, offsets), shape=(n, n)).toarray()
array([[2., 1., 0., ..., 0., 0., 0.],
[1., 2., 1., ..., 0., 0., 0.],
[0., 1., 2., ..., 0., 0., 0.],
...,
[0., 0., 0., ..., 2., 1., 0.],
[0., 0., 0., ..., 1., 2., 1.],
[0., 0., 0., ..., 0., 1., 2.]])
属性：
数据类型dtype
矩阵的数据类型
shape2 元组
矩阵的形状
维数整数
维度数（始终为 2）
存储的值数量，包括显式零。
存储值的数量。
数据
矩阵的 DIA 格式数据数组
偏移量
矩阵的 DIA 格式偏移数组
转置。
方法
__len__() |
|
|---|---|
__mul__ |
|
arcsin() |
逐元素反正弦。 |
arcsinh() |
逐元素反双曲正弦。 |
arctan() |
逐元素反正切。 |
arctanh() |
逐元素反双曲正切。 |
asformat(format[, copy]) |
以传递的格式返回此数组/矩阵。 |
asfptype() |
将矩阵升级为浮点格式（如有必要） |
astype(dtype[, casting, copy]) |
将数组/矩阵元素转换为指定类型。 |
ceil() |
按元素进行向上取整。 |
conj([copy]) |
对每个元素进行复数共轭。 |
conjugate([copy]) |
对每个元素进行复数共轭。 |
copy() |
返回此数组/矩阵的副本。 |
count_nonzero() |
非零条目的数量，等同于。 |
deg2rad() |
按元素进行角度转弧度。 |
diagonal([k]) |
返回数组/矩阵的第 k 条对角线。 |
dot(other) |
普通点积。 |
expm1() |
按元素进行 expm1 计算。 |
floor() |
按元素进行向下取整。 |
getH() |
返回该矩阵的共轭转置。 |
get_shape() |
获取矩阵的形状。 |
getcol(j) |
返回矩阵第 j 列的复制，作为一个 (m x 1) 稀疏矩阵（列向量）。 |
getformat() |
矩阵存储格式。 |
getmaxprint() |
打印时显示的最大元素数量。 |
getnnz([axis]) |
存储值的数量，包括显式的零值。 |
getrow(i) |
返回矩阵第 i 行的复制，作为 (1 x n) 稀疏矩阵（行向量）。 |
log1p() |
按元素进行 log1p 计算。 |
maximum(other) |
数组/矩阵的逐元素最大值。 |
mean([axis, dtype, out]) |
沿指定轴计算数组/矩阵的算术平均值。 |
minimum(other) |
|
multiply(other) |
逐点乘以另一个数组/矩阵。 |
nonzero() |
数组/矩阵的非零索引。 |
power(n[, dtype]) |
对数组/矩阵进行逐元素的幂运算。 |
rad2deg() |
逐元素的弧度转角度。 |
reshape(self, shape[, order, copy]) |
在不改变数据的情况下为稀疏数组/矩阵提供新的形状。 |
resize(*shape) |
就地调整数组/矩阵的尺寸为给定的shape。 |
rint() |
逐元素的四舍五入。 |
set_shape(shape) |
将矩阵的形状就地设置。 |
setdiag(values[, k]) |
设置数组/矩阵的对角线或非对角线元素。 |
sign() |
逐元素的符号。 |
sin() |
逐元素的 sin。 |
sinh() |
逐元素的 sinh。 |
sqrt() |
逐元素的平方根。 |
sum([axis, dtype, out]) |
沿指定轴对数组/矩阵元素求和。 |
tan() |
逐元素的 tan。 |
tanh() |
逐元素双曲正切。 |
toarray([order, out]) |
返回此稀疏数组/矩阵的稠密 ndarray 表示。 |
tobsr([blocksize, copy]) |
将该数组/矩阵转换为块稀疏行格式。 |
tocoo([copy]) |
将该数组/矩阵转换为坐标格式。 |
tocsc([copy]) |
将该数组/矩阵转换为压缩稀疏列格式。 |
tocsr([copy]) |
将该数组/矩阵转换为压缩稀疏行格式。 |
todense([order, out]) |
返回此稀疏数组/矩阵的稠密表示。 |
todia([copy]) |
将该数组/矩阵转换为稀疏对角格式。 |
todok([copy]) |
将该数组/矩阵转换为键值对字典格式。 |
tolil([copy]) |
将该数组/矩阵转换为列表列表格式。 |
trace([offset]) |
返回稀疏数组/矩阵对角线上的元素和。 |
transpose([axes, copy]) |
反转稀疏数组/矩阵的维度。 |
trunc() |
逐元素截断。 |
scipy.sparse.dok_matrix
class scipy.sparse.dok_matrix(arg1, shape=None, dtype=None, copy=False)
基于键的稀疏矩阵。
这是逐步构建稀疏矩阵的高效结构。
可以通过几种方式实例化：
dok_matrix(D)
其中 D 为 2-D ndarray
dok_matrix(S)
与另一个稀疏数组或矩阵 S 一起（等同于 S.todok()）
dok_matrix((M,N), [dtype])
使用初始形状为(M,N)的矩阵创建，dtype 为可选，默认为 dtype=’d’
注释
稀疏矩阵可用于算术操作：支持加法、减法、乘法、除法和矩阵幂。
-
允许以 O(1)的效率访问单个元素。
-
不允许重复。
-
构造后可高效转换为 coo_matrix。
示例
>>> import numpy as np
>>> from scipy.sparse import dok_matrix
>>> S = dok_matrix((5, 5), dtype=np.float32)
>>> for i in range(5):
... for j in range(5):
... S[i, j] = i + j # Update element
属性：
dtypedtype
矩阵的数据类型
shape2 元组
获取稀疏矩阵的形状。
ndim整型
维数（始终为 2）
存储值的数量，包括显式零值。
存储值的数量。
转置。
方法
__mul__(other) |
|
|---|---|
asformat(format[, copy]) |
以传递的格式返回此数组/矩阵。 |
asfptype() |
将矩阵升级到浮点格式（如果需要） |
astype(dtype[, casting, copy]) |
将数组/矩阵元素转换为指定类型。 |
conj([copy]) |
逐元素复数共轭。 |
conjtransp() |
返回共轭转置。 |
conjugate([copy]) |
逐元素复数共轭。 |
copy() |
返回此数组/矩阵的副本。 |
count_nonzero() |
非零条目数量，等同于。 |
diagonal([k]) |
返回数组/矩阵的第 k 条对角线。 |
dot(other) |
普通的点积。 |
fromkeys(iterable[, value]) |
使用可迭代对象的键创建一个新字典，并将值设置为 value。 |
get(key[, default]) |
这覆盖了 dict.get 方法，提供类型检查但功能上相同。 |
getH() |
返回该矩阵的共轭转置。 |
get_shape() |
获取稀疏矩阵的形状。 |
getcol(j) |
返回矩阵的第 j 列的副本，作为一个 (m x 1) 稀疏矩阵（列向量）。 |
getformat() |
矩阵存储格式。 |
getmaxprint() |
打印时显示的最大元素数。 |
getnnz([axis]) |
存储值的数量，包括显式零。 |
getrow(i) |
返回矩阵第 i 行的副本，作为 (1 x n) 稀疏矩阵（行向量）。 |
maximum(other) |
该数组/矩阵与另一个数组/矩阵的逐元素最大值。 |
mean([axis, dtype, out]) |
沿指定轴计算算术平均值。 |
minimum(other) |
该数组/矩阵与另一个数组/矩阵的逐元素最小值。 |
multiply(other) |
与另一个数组/矩阵的逐点乘法。 |
nonzero() |
返回数组/矩阵的非零索引。 |
pop(key[, default]) |
如果找不到键key，则返回default，否则引发KeyError。 |
power(n[, dtype]) |
逐元素的幂运算。 |
reshape(self, shape[, order, copy]) |
给稀疏数组/矩阵赋予新的形状，但不改变其数据。 |
resize(*shape) |
原地调整数组/矩阵的尺寸为给定的shape。 |
set_shape(shape) |
原地设置矩阵的形状。 |
setdiag(values[, k]) |
设置数组/矩阵的对角线或非对角线元素。 |
sum([axis, dtype, out]) |
沿指定轴对数组/矩阵的元素求和。 |
toarray([order, out]) |
返回此稀疏数组/矩阵的密集 ndarray 表示。 |
tobsr([blocksize, copy]) |
将此数组/矩阵转换为块状稀疏行（Block Sparse Row）格式。 |
tocoo([copy]) |
将此数组/矩阵转换为坐标（COOrdinate）格式。 |
tocsc([copy]) |
将此数组/矩阵转换为压缩稀疏列（Compressed Sparse Column）格式。 |
tocsr([copy]) |
将此数组/矩阵转换为压缩稀疏行（Compressed Sparse Row）格式。 |
todense([order, out]) |
返回此稀疏数组/矩阵的密集表示。 |
todia([copy]) |
将此数组/矩阵转换为稀疏对角线（DIAgonal）格式。 |
todok([copy]) |
将此数组/矩阵转换为键值对（Dictionary Of Keys）格式。 |
tolil([copy]) |
将此数组/矩阵转换为列表列表格式。 |
trace([offset]) |
返回稀疏数组/矩阵对角线上元素的和。 |
transpose([axes, copy]) |
反转稀疏数组/矩阵的维度。 |
| getitem | |
| len | |
| clear | |
| items | |
| keys | |
| popitem | |
| setdefault | |
| update | |
| values |
scipy.sparse.lil_matrix
class scipy.sparse.lil_matrix(arg1, shape=None, dtype=None, copy=False)
基于行的列表列表稀疏矩阵。
这是用于逐步构建稀疏矩阵的结构。请注意，在最坏情况下插入单个项可能需要线性时间；为了有效构建矩阵，请确保按行预先排序索引。
这可以通过几种方式实例化：
lil_matrix(D)
其中 D 是 2-D ndarray
lil_matrix(S)
与另一个稀疏数组或矩阵 S（相当于 S.tolil()）。
lil_matrix((M, N), [dtype])
为了构建一个形状为(M, N)的空矩阵，dtype 是可选的，默认为 dtype='d'。
注意事项
稀疏矩阵可用于算术运算：支持加法、减法、乘法、除法和矩阵幂运算。
LIL 格式的优势
-
支持灵活的切片
-
矩阵稀疏结构的变化是高效的
LIL 格式的缺点
-
算术运算 LIL + LIL 很慢（考虑 CSR 或 CSC）
-
慢的列切片（考虑 CSC）
-
慢的矩阵向量乘积（考虑 CSR 或 CSC）
预期使用
-
LIL 格式对于构建稀疏矩阵很方便
-
一旦构建了矩阵，为了快速算术和矩阵向量操作，将其转换为 CSR 或 CSC 格式
-
在构建大型矩阵时考虑使用 COO 格式
数据结构
-
一个数组（
self.rows），其中每个元素都是非零元素的列索引的排序列表。 -
相应的非零值以类似的方式存储在
self.data中。
属性：
dtypedtype
矩阵的数据类型
shape2 元组
矩阵的形状
ndimint
维度数量（这总是 2）
存储的值的数量，包括显式零值。
存储的值的数量。
数据
LIL 格式矩阵的数据数组
行
LIL 格式矩阵的行索引数组
转置。
方法
__len__() |
|
|---|---|
__mul__(other) |
|
asformat(format[, copy]) |
将此数组/矩阵以指定格式返回。 |
asfptype() |
将矩阵转换为浮点数格式（如果必要）。 |
astype(dtype[, casting, copy]) |
将数组/矩阵元素转换为指定类型。 |
conj([copy]) |
对每个元素进行复数共轭。 |
conjugate |
对每个元素进行复数共轭。 |
copy() |
返回该数组/矩阵的副本。 |
count_nonzero() |
非零条目的数量，等同于... |
diagonal([k]) |
返回数组/矩阵的第 k 条对角线。 |
dot(other) |
普通的点积运算。 |
getH() |
返回该矩阵的共轭转置。 |
get_shape() |
获取矩阵的形状。 |
getcol(j) |
返回该矩阵的第 j 列的副本，作为(m x 1)稀疏矩阵（列向量）。 |
getformat() |
矩阵的存储格式。 |
getmaxprint() |
打印时显示的最大元素数量。 |
getnnz([axis]) |
存储的值的数量，包括显式的零值。 |
getrow(i) |
返回该矩阵的第 i 行的副本，作为(1 x n)稀疏矩阵（行向量）。 |
getrowview(i) |
返回第'i'行的视图（无需复制）。 |
maximum(other) |
该数组/矩阵与另一个数组/矩阵之间的逐元素最大值。 |
mean([axis, dtype, out]) |
计算沿指定轴的算术平均值。 |
minimum(other) |
此数组/矩阵与另一个数组/矩阵的逐元素最小值。 |
multiply(other) |
与另一个数组/矩阵进行逐点乘法。 |
nonzero() |
数组/矩阵的非零索引。 |
power(n[, dtype]) |
逐元素的幂运算。 |
reshape(self, shape[, order, copy]) |
给稀疏数组/矩阵赋予新的形状，但不更改其数据。 |
resize(*shape) |
就地调整数组/矩阵的尺寸为给定的shape维度。 |
set_shape(shape) |
就地设置矩阵的形状。 |
setdiag(values[, k]) |
设置数组/矩阵的对角线或非对角线元素。 |
sum([axis, dtype, out]) |
沿指定轴对数组/矩阵元素求和。 |
toarray([order, out]) |
返回此稀疏数组/矩阵的密集 ndarray 表示。 |
tobsr([blocksize, copy]) |
将此数组/矩阵转换为块稀疏行格式。 |
tocoo([copy]) |
将此数组/矩阵转换为坐标格式。 |
tocsc([copy]) |
将此数组/矩阵转换为压缩稀疏列格式。 |
tocsr([copy]) |
将此数组/矩阵转换为压缩稀疏行格式。 |
todense([order, out]) |
返回此稀疏数组/矩阵的密集表示。 |
todia([copy]) |
将该数组/矩阵转换为稀疏的对角线格式。 |
todok([copy]) |
将该数组/矩阵转换为字典键格式。 |
tolil([copy]) |
将该数组/矩阵转换为列表列表格式。 |
trace([offset]) |
返回稀疏数组/矩阵沿对角线的和。 |
transpose([axes, copy]) |
反转稀疏数组/矩阵的维度。 |
| getitem |
scipy.sparse.spmatrix
Original text：
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.sparse.spmatrix.html#scipy.sparse.spmatrix
class scipy.sparse.spmatrix
此类为所有稀疏矩阵类提供了基类。
它不能被实例化。大部分工作由子类提供。
Attributes:
Shape of the matrix
Methods
__mul__(other) |
|
|---|---|
| - | asfptype() |
| - | getH() |
| - | get_shape() |
| - | getcol(j) |
| - | getformat() |
| - | getmaxprint() |
| - | getnnz([axis]) |
| - | getrow(i) |
| - | set_shape(shape) |
scipy.sparse.diags_array
scipy.sparse.diags_array(diagonals, /, *, offsets=0, shape=None, format=None, dtype=None)
从对角线构造稀疏数组。
参数：
diagonals数组样式的序列
包含数组对角线的数组序列，对应于偏移。
offsets整数序列或整数，可选
要设置的对角线：
-
k = 0 主对角线（默认）
-
k > 0 第 k 个上对角线
-
k < 0 第 k 个下对角线
shape整数元组，可选
结果的形状。如果省略，将返回足够容纳对角线的方阵。
format，可选
结果的矩阵格式。默认情况下（format=None），返回适当的稀疏数组格式。此选择可能会更改。
dtypedtype，可选
数组的数据类型。
注意
diags_array的结果是稀疏等效于：
np.diag(diagonals[0], offsets[0])
+ ...
+ np.diag(diagonals[k], offsets[k])
不允许重复对角线偏移。
1.11 版新增。
示例
>>> from scipy.sparse import diags_array
>>> diagonals = [[1, 2, 3, 4], [1, 2, 3], [1, 2]]
>>> diags_array(diagonals, offsets=[0, -1, 2]).toarray()
array([[1, 0, 1, 0],
[1, 2, 0, 2],
[0, 2, 3, 0],
[0, 0, 3, 4]])
支持标量的广播（但需要指定形状）：
>>> diags_array([1, -2, 1], offsets=[-1, 0, 1], shape=(4, 4)).toarray()
array([[-2., 1., 0., 0.],
[ 1., -2., 1., 0.],
[ 0., 1., -2., 1.],
[ 0., 0., 1., -2.]])
如果只需要一个对角线（如numpy.diag中），以下内容同样适用：
>>> diags_array([1, 2, 3], offsets=1).toarray()
array([[ 0., 1., 0., 0.],
[ 0., 0., 2., 0.],
[ 0., 0., 0., 3.],
[ 0., 0., 0., 0.]])
scipy.sparse.eye_array
scipy.sparse.eye_array(m, n=None, *, k=0, dtype=<class 'float'>, format=None)
稀疏数组格式的单位矩阵
返回一个稀疏数组，对角线上为 1。具体为稀疏数组（m x n），其中第 k 个对角线上全为 1，其他位置为 0。
参数：
m整数或整数元组
请求的行数。
n整数，可选
列数。默认为m。
k整数，可选
放置 1 的对角线。默认为 0（主对角线）。
dtype数据类型，可选
数组的数据类型
format字符串，可选（默认为“dia”）
结果的稀疏格式，例如，format=”csr”等。
示例
>>> import numpy as np
>>> import scipy as sp
>>> sp.sparse.eye_array(3).toarray()
array([[ 1., 0., 0.],
[ 0., 1., 0.],
[ 0., 0., 1.]])
>>> sp.sparse.eye_array(3, dtype=np.int8)
<3x3 sparse array of type '<class 'numpy.int8'>'
with 3 stored elements (1 diagonals) in DIAgonal format>
scipy.sparse.random_array
scipy.sparse.random_array(shape, *, density=0.01, format='coo', dtype=None, random_state=None, data_sampler=None)
返回在[0, 1)中均匀随机的稀疏数组
返回一个给定形状和密度的稀疏数组，其中值在范围[0, 1)内均匀随机生成。
警告
自 numpy 1.17 起，为random_state传递np.random.Generator（例如np.random.default_rng）将导致执行时间大大加快。
默认情况下使用更慢的实现以保持向后兼容性。
参数：
shape：int 或 int 元组
数组的形状
density：实数，可选（默认值：0.01）
生成矩阵的密度：密度为 1 表示完整矩阵，密度为 0 表示没有非零项的矩阵。
format：str，可选（默认值：'coo'）
稀疏矩阵格式。
dtype：dtype，可选（默认值：np.float64）
返回矩阵值的类型。
random_state：{None, int, Generator, RandomState}，可选
用于确定非零结构的随机数生成器。我们建议每次调用手动提供一个numpy.random.Generator，因为它比 RandomState 快得多。
-
如果为None（或np.random），则使用
numpy.random.RandomState单例。 -
如果是整数，将使用新的
Generator实例，并以该整数作为种子。 -
如果是
Generator或RandomState实例，则使用该实例。
这个随机状态将用于采样索引（稀疏结构），默认情况下也用于数据值（见data_sampler）。
data_sampler：可调用对象，可选（默认取决于 dtype）
具有关键字参数size的随机数据值取样器。此函数应接受一个关键字参数size，指定其返回的 ndarray 的长度。它用于在选择这些值的位置后生成矩阵中的非零值。默认情况下，使用均匀分布的[0, 1)随机值，除非dtype是整数（默认从该 dtype 生成均匀整数）或复数（默认在复平面单位正方形上均匀分布）。对于这些情况，使用random_state RNG，例如rng.uniform(size=size)。
返回：
res：稀疏数组
示例
传递np.random.Generator实例以获得更好的性能：
>>> import numpy as np
>>> import scipy as sp
>>> rng = np.random.default_rng()
默认从[0, 1)均匀采样：
>>> S = sp.sparse.random_array((3, 4), density=0.25, random_state=rng)
提供值的取样器：
>>> rvs = sp.stats.poisson(25, loc=10).rvs
>>> S = sp.sparse.random_array((3, 4), density=0.25,
... random_state=rng, data_sampler=rvs)
>>> S.toarray()
array([[ 36., 0., 33., 0.], # random
[ 0., 0., 0., 0.],
[ 0., 0., 36., 0.]])
构建自定义分布。此示例从 np.random 构建了一个平方正态分布：
>>> def np_normal_squared(size=None, random_state=rng):
... return random_state.standard_normal(size) ** 2
>>> S = sp.sparse.random_array((3, 4), density=0.25, random_state=rng,
... data_sampler=np_normal_squared)
或者我们可以从 sp.stats 风格的 rvs 函数构建它：
>>> def sp_stats_normal_squared(size=None, random_state=rng):
... std_normal = sp.stats.distributions.norm_gen().rvs
... return std_normal(size=size, random_state=random_state) ** 2
>>> S = sp.sparse.random_array((3, 4), density=0.25, random_state=rng,
... data_sampler=sp_stats_normal_squared)
或者我们可以子类化 sp.stats rv_continous 或 rv_discrete：
>>> class NormalSquared(sp.stats.rv_continuous):
... def _rvs(self, size=None, random_state=rng):
... return random_state.standard_normal(size) ** 2
>>> X = NormalSquared()
>>> Y = X().rvs
>>> S = sp.sparse.random_array((3, 4), density=0.25,
... random_state=rng, data_sampler=Y)
scipy.sparse.block_array
scipy.sparse.block_array(blocks, *, format=None, dtype=None)
从稀疏子块构建稀疏数组
参数:
块array_like
具有兼容形状的稀疏数组网格。None 表示全零数组。
格式，可选
结果的稀疏格式（例如“csr”）。默认情况下返回适当的稀疏数组格式。此选择可能会更改。
dtypedtype，可选
输出数组的数据类型。如果未给出，则从blocks的数据类型确定。
返回：
块稀疏数组
另请参阅
指定沿主对角线的块
指定（可能有偏移的）对角线
示例
>>> from scipy.sparse import coo_array, block_array
>>> A = coo_array([[1, 2], [3, 4]])
>>> B = coo_array([[5], [6]])
>>> C = coo_array([[7]])
>>> block_array([[A, B], [None, C]]).toarray()
array([[1, 2, 5],
[3, 4, 6],
[0, 0, 7]])
>>> block_array([[A, None], [None, C]]).toarray()
array([[1, 2, 0],
[3, 4, 0],
[0, 0, 7]])
scipy.sparse.eye
原文：
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.sparse.eye.html#scipy.sparse.eye
scipy.sparse.eye(m, n=None, k=0, dtype=<class 'float'>, format=None)
对角线上有 1 的稀疏矩阵
返回一个稀疏矩阵（m x n），其中第 k 个对角线上全为 1，其余为 0。
参数：
mint
矩阵中的行数。
nint，可选
列数。默认值：m。
kint，可选
放置 1 的对角线。默认值：0（主对角线）。
dtypedtype，可选
矩阵的数据类型。
formatstr，可选
结果的稀疏格式，例如，format=”csr”等。
.. warning::
此函数返回一个稀疏矩阵，而不是稀疏数组。建议使用eye_array来利用稀疏数组的功能。
示例
>>> import numpy as np
>>> import scipy as sp
>>> sp.sparse.eye(3).toarray()
array([[ 1., 0., 0.],
[ 0., 1., 0.],
[ 0., 0., 1.]])
>>> sp.sparse.eye(3, dtype=np.int8)
<3x3 sparse matrix of type '<class 'numpy.int8'>'
with 3 stored elements (1 diagonals) in DIAgonal format>
scipy.sparse.identity
原文链接：
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.sparse.identity.html#scipy.sparse.identity
scipy.sparse.identity(n, dtype='d', format=None)
稀疏格式的单位矩阵
返回一个形状为(n,n)的单位矩阵，使用给定的稀疏格式和 dtype。这与eye_array不同，后者具有方形形状，只有在主对角线上有 1。因此它是乘法单位。eye_array允许矩形形状，对角线可以偏离主对角线。
警告
此函数返回稀疏矩阵，而不是稀疏数组。建议您使用eye_array以利用稀疏数组的功能。
参数：
nint
单位矩阵的形状。
dtypedtype，可选
矩阵的数据类型
格式str，可选
结果的稀疏格式，例如，format=”csr”等。
示例
>>> import scipy as sp
>>> sp.sparse.identity(3).toarray()
array([[ 1., 0., 0.],
[ 0., 1., 0.],
[ 0., 0., 1.]])
>>> sp.sparse.identity(3, dtype='int8', format='dia')
<3x3 sparse matrix of type '<class 'numpy.int8'>'
with 3 stored elements (1 diagonals) in DIAgonal format>
>>> sp.sparse.eye_array(3, dtype='int8', format='dia')
<3x3 sparse array of type '<class 'numpy.int8'>'
with 3 stored elements (1 diagonals) in DIAgonal format>
scipy.sparse.diags
原文链接：
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.sparse.diags.html#scipy.sparse.diags
scipy.sparse.diags(diagonals, offsets=0, shape=None, format=None, dtype=None)
从对角线构建稀疏矩阵。
警告
此函数返回稀疏矩阵 – 而不是稀疏数组。建议您使用diags_array来利用稀疏数组功能。
参数：
diagonals数组序列
包含矩阵对角线的数组序列，对应于offsets。
offsets整数序列或整数，可选
要设置的对角线：
-
k = 0 主对角线（默认）
-
k > 0 第 k 个上对角线
-
k < 0 第 k 个下对角线
shape整数元组，可选
结果的形状。如果省略，将返回一个足够大以包含对角线的方阵。
format，可选
结果的矩阵格式。默认情况下（format=None），将返回适当的稀疏矩阵格式。此选择可能会更改。
dtypedtype，可选
矩阵的数据类型。
另请参阅
spdiags
从对角线构建矩阵
diags_array
构建稀疏数组而不是稀疏矩阵
注意事项
此函数与spdiags在处理非对角线元素的方式上有所不同。
diags的结果是稀疏等价于：
np.diag(diagonals[0], offsets[0])
+ ...
+ np.diag(diagonals[k], offsets[k])
禁止重复的对角线偏移。
从版本 0.11 开始新增。
示例
>>> from scipy.sparse import diags
>>> diagonals = [[1, 2, 3, 4], [1, 2, 3], [1, 2]]
>>> diags(diagonals, [0, -1, 2]).toarray()
array([[1, 0, 1, 0],
[1, 2, 0, 2],
[0, 2, 3, 0],
[0, 0, 3, 4]])
支持标量的广播（但需要指定形状）：
>>> diags([1, -2, 1], [-1, 0, 1], shape=(4, 4)).toarray()
array([[-2., 1., 0., 0.],
[ 1., -2., 1., 0.],
[ 0., 1., -2., 1.],
[ 0., 0., 1., -2.]])
如果只想要一个对角线（如numpy.diag中所述），以下方法同样适用：
>>> diags([1, 2, 3], 1).toarray()
array([[ 0., 1., 0., 0.],
[ 0., 0., 2., 0.],
[ 0., 0., 0., 3.],
[ 0., 0., 0., 0.]])
scipy.sparse.spdiags
原文：
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.sparse.spdiags.html#scipy.sparse.spdiags
scipy.sparse.spdiags(data, diags, m=None, n=None, format=None)
从对角线返回稀疏矩阵。
参数:
dataarray_like
矩阵对角线按行存储
diags整数或整数序列
要设置的对角线:
-
k = 0 主对角线
-
k > 0 第 k 个上对角线
-
k < 0 第 k 个下对角线
m, n整数，元组，可选
结果的形状。如果n为 None 且m为给定的元组，则形状是这个元组。如果省略，则矩阵是方阵，其形状为 len(data[0])。
format字符串，可选
结果的格式。默认情况下（format=None），返回适当的稀疏矩阵格式。此选择可能会更改。
.. 警告::
此函数返回稀疏矩阵 - 而不是稀疏数组。建议使用diags_array以利用稀疏数组功能。
另请参阅
更方便的此函数形式
diags_array 的矩阵版本
稀疏 DIAgonal 格式。
示例
>>> import numpy as np
>>> from scipy.sparse import spdiags
>>> data = np.array([[1, 2, 3, 4], [1, 2, 3, 4], [1, 2, 3, 4]])
>>> diags = np.array([0, -1, 2])
>>> spdiags(data, diags, 4, 4).toarray()
array([[1, 0, 3, 0],
[1, 2, 0, 4],
[0, 2, 3, 0],
[0, 0, 3, 4]])
scipy.sparse.bmat
原文：
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.sparse.bmat.html#scipy.sparse.bmat
scipy.sparse.bmat(blocks, format=None, dtype=None)
从稀疏子块构建稀疏数组或矩阵
注意：block_array 优先于 bmat。它们是相同的函数，除了 bmat 可能会返回一个已弃用的稀疏矩阵。如果输入的所有内容都不是稀疏数组，则 bmat 返回一个 coo_matrix。
警告
此函数返回一个稀疏矩阵 - 而不是稀疏数组。建议使用 block_array 来利用稀疏数组的功能。
参数：
blocksarray_like
具有兼容形状的稀疏矩阵网格。None 表示全零矩阵。
格式，可选
结果的稀疏格式（例如“csr”）。默认情况下会返回适当的稀疏矩阵格式。这种选择可能会改变。
dtypedtype，可选
输出矩阵的数据类型。如果未提供，则从 blocks 的数据类型确定。
返回：
bmat稀疏矩阵或数组
如果 blocks 中的任何块是稀疏数组，则返回稀疏数组。否则返回稀疏矩阵。
如果希望从非稀疏数组的块构建稀疏数组，请使用 block_array()。
另请参见
示例
>>> from scipy.sparse import coo_array, bmat
>>> A = coo_array([[1, 2], [3, 4]])
>>> B = coo_array([[5], [6]])
>>> C = coo_array([[7]])
>>> bmat([[A, B], [None, C]]).toarray()
array([[1, 2, 5],
[3, 4, 6],
[0, 0, 7]])
>>> bmat([[A, None], [None, C]]).toarray()
array([[1, 2, 0],
[3, 4, 0],
[0, 0, 7]])
scipy.sparse.random
原文：
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.sparse.random.html#scipy.sparse.random
scipy.sparse.random(m, n, density=0.01, format='coo', dtype=None, random_state=None, data_rvs=None)
以给定形状和密度生成稀疏矩阵，其值是随机分布的。
警告
自 numpy 1.17 起，传递np.random.Generator（例如np.random.default_rng）作为random_state将导致执行时间大大缩短。
默认情况下，为了向后兼容性使用了一个较慢的实现。
警告
此函数返回稀疏矩阵 – 而不是稀疏数组。建议您使用random_array来利用稀疏数组功能。
参数：
m, nint
矩阵的形状
密度real, 可选
生成矩阵的密度：密度等于一表示完整矩阵，密度为零表示没有非零项的矩阵。
格式str, 可选
稀疏矩阵格式。
dtypedtype, 可选
返回矩阵值的类型。
随机状态{None, int, numpy.random.Generator,
-
如果seed为 None（或np.random），则使用
numpy.random.RandomState单例。 -
如果seed是一个整数，则使用一个新的
RandomState实例，并用seed进行种子化。 -
如果seed已经是一个
Generator或RandomState实例，则使用该实例。
此随机状态将用于采样稀疏矩阵的非结构化非零条目的值，但不一定用于采样结构非零条目的值。
data_rvscallable, 可选
样本请求数量的随机值。此函数应该接受一个参数，指定它将返回的 ndarray 的长度。稀疏随机矩阵的结构化非零条目将从此函数采样的数组中获取。默认情况下，将使用与用于采样稀疏性结构的随机状态相同的均匀 0, 1)随机值进行采样。
返回：
res稀疏矩阵
另请参阅
[random_array
构建稀疏数组而不是稀疏矩阵
示例
为了更好的性能，传递一个np.random.Generator实例：
>>> import scipy as sp
>>> import numpy as np
>>> rng = np.random.default_rng()
>>> S = sp.sparse.random(3, 4, density=0.25, random_state=rng)
为值提供一个采样器：
>>> rvs = sp.stats.poisson(25, loc=10).rvs
>>> S = sp.sparse.random(3, 4, density=0.25, random_state=rng, data_rvs=rvs)
>>> S.toarray()
array([[ 36., 0., 33., 0.], # random
[ 0., 0., 0., 0.],
[ 0., 0., 36., 0.]])
构建自定义分布。此示例从 np.random 构建了一个平方正态分布：
>>> def np_normal_squared(size=None, random_state=rng):
... return random_state.standard_normal(size) ** 2
>>> S = sp.sparse.random(3, 4, density=0.25, random_state=rng,
... data_rvs=np_normal_squared)
或者我们可以从 sp.stats 风格的 rvs 函数构建它：
>>> def sp_stats_normal_squared(size=None, random_state=rng):
... std_normal = sp.stats.distributions.norm_gen().rvs
... return std_normal(size=size, random_state=random_state) ** 2
>>> S = sp.sparse.random(3, 4, density=0.25, random_state=rng,
... data_rvs=sp_stats_normal_squared)
或者我们可以子类化 sp.stats rv_continuous 或 rv_discrete：
>>> class NormalSquared(sp.stats.rv_continuous):
... def _rvs(self, size=None, random_state=rng):
... return random_state.standard_normal(size) ** 2
>>> X = NormalSquared()
>>> Y = X() # get a frozen version of the distribution
>>> S = sp.sparse.random(3, 4, density=0.25, random_state=rng, data_rvs=Y.rvs)
scipy.sparse.rand
原文：
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.sparse.rand.html#scipy.sparse.rand
scipy.sparse.rand(m, n, density=0.01, format='coo', dtype=None, random_state=None)
生成具有均匀分布值的给定形状和密度的稀疏矩阵。
警告
此函数返回一个稀疏矩阵 - 而不是稀疏数组。建议使用 random_array 利用稀疏数组功能。
参数：
m, n整数
矩阵的形状
density实数，可选
生成矩阵的密度：密度为一表示完整矩阵，密度为 0 表示没有非零项的矩阵。
formatstr，可选
稀疏矩阵格式。
dtypedtype，可选
返回矩阵值类型。
random_state{None, int, numpy.random.Generator，
如果 seed 为 None（或 np.random），则使用 numpy.random.RandomState 单例。如果 seed 是整数，则使用种子为 seed 的新 RandomState 实例。如果 seed 已经是 Generator 或 RandomState 实例，则使用该实例。
返回：
res稀疏矩阵
另请参阅
random
允许自定义随机数据采样器的类似函数
random_array
类似于 random() 但返回稀疏数组
注意事项
目前仅支持浮点类型。
示例
>>> from scipy.sparse import rand
>>> matrix = rand(3, 4, density=0.25, format="csr", random_state=42)
>>> matrix
<3x4 sparse matrix of type '<class 'numpy.float64'>'
with 3 stored elements in Compressed Sparse Row format>
>>> matrix.toarray()
array([[0.05641158, 0\. , 0\. , 0.65088847], # random
[0\. , 0\. , 0\. , 0.14286682],
[0\. , 0\. , 0\. , 0\. ]])
scipy.sparse.kron
原文：
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.sparse.kron.html#scipy.sparse.kron
scipy.sparse.kron(A, B, format=None)
稀疏矩阵 A 和 B 的克罗内克积
参数：
A 稀疏或密集矩阵
乘积的第一个矩阵
B 稀疏或密集矩阵
乘积的第二个矩阵
format str，可选（默认为 ‘bsr’ 或 ‘coo’）
结果的格式（例如，“csr”）。如果为 None，则对相对密集的数组选择“bsr”，对其他情况选择“coo”。
返回：
克罗内克积的稀疏格式。
除非 A 或 B 是稠密矩阵，否则返回稀疏矩阵。
稀疏数组在这种情况下返回稀疏数组。
示例
>>> import numpy as np
>>> import scipy as sp
>>> A = sp.sparse.csr_array(np.array([[0, 2], [5, 0]]))
>>> B = sp.sparse.csr_array(np.array([[1, 2], [3, 4]]))
>>> sp.sparse.kron(A, B).toarray()
array([[ 0, 0, 2, 4],
[ 0, 0, 6, 8],
[ 5, 10, 0, 0],
[15, 20, 0, 0]])
>>> sp.sparse.kron(A, [[1, 2], [3, 4]]).toarray()
array([[ 0, 0, 2, 4],
[ 0, 0, 6, 8],
[ 5, 10, 0, 0],
[15, 20, 0, 0]])
scipy.sparse.kronsum
原文：
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.sparse.kronsum.html#scipy.sparse.kronsum
scipy.sparse.kronsum(A, B, format=None)
方阵 A 和 B 的 Kronecker 和
两个稀疏矩阵的 Kronecker 和是两个 Kronecker 积 kron(I_n,A) + kron(B,I_m)的和，其中 A 的形状为(m,m)，B 的形状为(n,n)，而 I_m 和 I_n 分别是形状为(m,m)和(n,n)的单位矩阵。
参数：
A
方阵
B
方阵
formatstr
结果的格式（例如“csr”）
返回结果：
稀疏矩阵中的 Kronecker 和
scipy.sparse.block_diag
scipy.sparse.block_diag(mats, format=None, dtype=None)
从提供的矩阵构建块对角稀疏矩阵或数组。
参数：
mats 矩阵或数组序列
输入的矩阵或数组。
format str，可选
结果的稀疏格式（例如，“csr”）。如果未给出，则以“coo”格式返回结果。
dtype dtype 指定器，可选
输出的数据类型。如果未给出，则从blocks的数据类型确定。
返回：
res 稀疏矩阵或数组
如果至少有一个输入是稀疏数组，则输出为稀疏数组。否则输出为稀疏矩阵。
另请参阅
block_array
diags_array
注意
新版本 0.11.0 中引入。
示例
>>> from scipy.sparse import coo_array, block_diag
>>> A = coo_array([[1, 2], [3, 4]])
>>> B = coo_array([[5], [6]])
>>> C = coo_array([[7]])
>>> block_diag((A, B, C)).toarray()
array([[1, 2, 0, 0],
[3, 4, 0, 0],
[0, 0, 5, 0],
[0, 0, 6, 0],
[0, 0, 0, 7]])
scipy.sparse.tril
原文链接：
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.sparse.tril.html#scipy.sparse.tril
scipy.sparse.tril(A, k=0, format=None)
返回稀疏数组或矩阵的下三角部分
返回矩阵 A 的第 k 条对角线上方或其对角线上的元素。
-
k = 0 对应于主对角线
-
k > 0 位于主对角线之上
-
k < 0 位于主对角线之下
参数：
A密集或稀疏数组或矩阵
所需矩阵的下三角部分。
k整数可选
下三角形的最顶部对角线。
format字符串
结果的稀疏格式，例如 format=”csr”等。
返回：
L稀疏矩阵
矩阵 A 的稀疏格式下的下三角部分。
另请参见
稀疏格式中的上三角形式
示例
>>> from scipy.sparse import csr_array, tril
>>> A = csr_array([[1, 2, 0, 0, 3], [4, 5, 0, 6, 7], [0, 0, 8, 9, 0]],
... dtype='int32')
>>> A.toarray()
array([[1, 2, 0, 0, 3],
[4, 5, 0, 6, 7],
[0, 0, 8, 9, 0]])
>>> tril(A).toarray()
array([[1, 0, 0, 0, 0],
[4, 5, 0, 0, 0],
[0, 0, 8, 0, 0]])
>>> tril(A).nnz
4
>>> tril(A, k=1).toarray()
array([[1, 2, 0, 0, 0],
[4, 5, 0, 0, 0],
[0, 0, 8, 9, 0]])
>>> tril(A, k=-1).toarray()
array([[0, 0, 0, 0, 0],
[4, 0, 0, 0, 0],
[0, 0, 0, 0, 0]])
>>> tril(A, format='csc')
<3x5 sparse array of type '<class 'numpy.int32'>'
with 4 stored elements in Compressed Sparse Column format>
scipy.sparse.triu
原文：
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.sparse.triu.html#scipy.sparse.triu
scipy.sparse.triu(A, k=0, format=None)
返回稀疏数组或矩阵的上三角部分
返回矩阵 A 的第 k 条对角线及其以上的元素。
-
k = 0 对应于主对角线
-
k > 0 在主对角线上方
-
k < 0 在主对角线下方
参数：
A密集或稀疏的数组或矩阵
所需获取其上三角部分的矩阵。
k整数可选
上三角的最底部对角线。
format字符串
结果的稀疏格式，例如 format=”csr” 等。
返回：
L稀疏的数组或矩阵
A 的稀疏格式的上三角部分。如果 A 是稀疏数组，则返回稀疏数组，否则返回矩阵。
另请参阅
tril
稀疏格式的下三角
示例
>>> from scipy.sparse import csr_array, triu
>>> A = csr_array([[1, 2, 0, 0, 3], [4, 5, 0, 6, 7], [0, 0, 8, 9, 0]],
... dtype='int32')
>>> A.toarray()
array([[1, 2, 0, 0, 3],
[4, 5, 0, 6, 7],
[0, 0, 8, 9, 0]])
>>> triu(A).toarray()
array([[1, 2, 0, 0, 3],
[0, 5, 0, 6, 7],
[0, 0, 8, 9, 0]])
>>> triu(A).nnz
8
>>> triu(A, k=1).toarray()
array([[0, 2, 0, 0, 3],
[0, 0, 0, 6, 7],
[0, 0, 0, 9, 0]])
>>> triu(A, k=-1).toarray()
array([[1, 2, 0, 0, 3],
[4, 5, 0, 6, 7],
[0, 0, 8, 9, 0]])
>>> triu(A, format='csc')
<3x5 sparse array of type '<class 'numpy.int32'>'
with 8 stored elements in Compressed Sparse Column format>
scipy.sparse.hstack
原文：
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.sparse.hstack.html#scipy.sparse.hstack
scipy.sparse.hstack(blocks, format=None, dtype=None)
水平堆叠稀疏矩阵（按列堆叠）
参数：
blocks
具有兼容形状的稀疏矩阵序列
格式str
返回结果的稀疏格式（例如，“csr”），默认情况下返回适当的稀疏矩阵格式。此选择可能会更改。
dtypedtype，可选
输出矩阵的数据类型。如果未指定，则从blocks中确定。
返回：
new_array稀疏矩阵或数组
如果 blocks 中的任何块是稀疏数组，则返回稀疏数组。否则返回稀疏矩阵。
如果您希望从非稀疏数组构建稀疏数组，使用block(hstack(blocks))或转换一个块，例如blocks[0] = csr_array(blocks[0])。
另请参见
vstack
垂直堆叠稀疏矩阵（按行堆叠）
示例
>>> from scipy.sparse import coo_matrix, hstack
>>> A = coo_matrix([[1, 2], [3, 4]])
>>> B = coo_matrix([[5], [6]])
>>> hstack([A,B]).toarray()
array([[1, 2, 5],
[3, 4, 6]])
scipy.sparse.vstack
原文：
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.sparse.vstack.html#scipy.sparse.vstack
scipy.sparse.vstack(blocks, format=None, dtype=None)
垂直堆叠稀疏数组（按行）
参数：
blocks
兼容形状的稀疏数组序列
formatstr，可选
结果的稀疏格式（例如，“csr”）默认情况下返回适当的稀疏数组格式。此选择可能会更改。
dtypedtype，可选
输出数组的数据类型。如果未指定，则从blocks的数据类型确定。
返回：
new_array稀疏矩阵或数组
如果 blocks 中的任何一个块是稀疏数组，则返回稀疏数组。否则返回稀疏矩阵。
如果您希望从非稀疏数组块构建稀疏数组，请使用block(vstack(blocks))或转换一个块，例如blocks[0] = csr_array(blocks[0])。
参见
hstack
水平堆叠稀疏矩阵（按列）
示例
>>> from scipy.sparse import coo_array, vstack
>>> A = coo_array([[1, 2], [3, 4]])
>>> B = coo_array([[5, 6]])
>>> vstack([A, B]).toarray()
array([[1, 2],
[3, 4],
[5, 6]])
scipy.sparse.save_npz
原文：
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.sparse.save_npz.html#scipy.sparse.save_npz
scipy.sparse.save_npz(file, matrix, compressed=True)
将稀疏矩阵或数组保存到文件中，使用.npz格式。
参数：
文件str 或类文件对象
文件名（字符串）或数据将保存到的打开文件（类文件对象）。如果文件是字符串，则如果文件名尚未包含.npz扩展名，则将其添加到文件名中。
矩阵：spmatrix 或 sparray
要保存的稀疏矩阵或数组。支持的格式：csc、csr、bsr、dia 或 coo。
压缩bool, 可选
允许压缩文件。默认：True
另请参阅
scipy.sparse.load_npz
从文件中使用.npz格式加载稀疏矩阵。
将多个数组保存到.npz归档文件中。
将多个数组保存到压缩的.npz归档文件中。
示例
将稀疏矩阵存储到磁盘，并再次加载：
>>> import numpy as np
>>> import scipy as sp
>>> sparse_matrix = sp.sparse.csc_matrix([[0, 0, 3], [4, 0, 0]])
>>> sparse_matrix
<2x3 sparse matrix of type '<class 'numpy.int64'>'
with 2 stored elements in Compressed Sparse Column format>
>>> sparse_matrix.toarray()
array([[0, 0, 3],
[4, 0, 0]], dtype=int64)
>>> sp.sparse.save_npz('/tmp/sparse_matrix.npz', sparse_matrix)
>>> sparse_matrix = sp.sparse.load_npz('/tmp/sparse_matrix.npz')
>>> sparse_matrix
<2x3 sparse matrix of type '<class 'numpy.int64'>'
with 2 stored elements in Compressed Sparse Column format>
>>> sparse_matrix.toarray()
array([[0, 0, 3],
[4, 0, 0]], dtype=int64)
scipy.sparse.load_npz
原文：
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.sparse.load_npz.html#scipy.sparse.load_npz
scipy.sparse.load_npz(file)
使用.npz格式从文件加载稀疏数组/矩阵。
参数：
filestr 或类文件对象
要么是文件名（字符串），要么是一个打开的文件（类似文件对象），其中数据将被加载。
返回：
resultcsc_array, csr_array, bsr_array, dia_array 或 coo_array
包含加载数据的稀疏数组/矩阵。
引发：
OSError
如果输入文件不存在或无法读取。
另请参阅
scipy.sparse.save_npz
使用.npz格式将稀疏数组/矩阵保存到文件中。
从.npz存档中加载多个数组。
示例
将稀疏数组/矩阵存储到磁盘上，并再次加载：
>>> import numpy as np
>>> import scipy as sp
>>> sparse_array = sp.sparse.csc_array([[0, 0, 3], [4, 0, 0]])
>>> sparse_array
<2x3 sparse array of type '<class 'numpy.int64'>'
with 2 stored elements in Compressed Sparse Column format>
>>> sparse_array.toarray()
array([[0, 0, 3],
[4, 0, 0]], dtype=int64)
>>> sp.sparse.save_npz('/tmp/sparse_array.npz', sparse_array)
>>> sparse_array = sp.sparse.load_npz('/tmp/sparse_array.npz')
>>> sparse_array
<2x3 sparse array of type '<class 'numpy.int64'>'
with 2 stored elements in Compressed Sparse Column format>
>>> sparse_array.toarray()
array([[0, 0, 3],
[4, 0, 0]], dtype=int64)
在这个例子中，我们强制结果为 csr_array，从 csr_matrix >>> sparse_matrix = sp.sparse.csc_matrix([[0, 0, 3], [4, 0, 0]]) >>> sp.sparse.save_npz('/tmp/sparse_matrix.npz', sparse_matrix) >>> tmp = sp.sparse.load_npz('/tmp/sparse_matrix.npz') >>> sparse_array = sp.sparse.csr_array(tmp)
scipy.sparse.find
原文：
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.sparse.find.html#scipy.sparse.find
scipy.sparse.find(A)
返回矩阵非零元素的索引和值
参数：
A 密集或稀疏数组或矩阵
需要非零元素的矩阵。
返回：
(I,J,V) 由数组组成的元组
I、J 和 V 包含非零条目的行索引、列索引和值。
示例
>>> from scipy.sparse import csr_array, find
>>> A = csr_array([[7.0, 8.0, 0],[0, 0, 9.0]])
>>> find(A)
(array([0, 0, 1], dtype=int32),
array([0, 1, 2], dtype=int32),
array([ 7., 8., 9.]))
scipy.sparse.issparse
原文：
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.sparse.issparse.html#scipy.sparse.issparse
scipy.sparse.issparse(x)
x 是否是稀疏数组或稀疏矩阵类型？
参数：
x
用于检查是否为稀疏数组或稀疏矩阵的对象
返回：
布尔值
如果 x 是稀疏数组或稀疏矩阵，则返回 True，否则返回 False
示例
>>> import numpy as np
>>> from scipy.sparse import csr_array, csr_matrix, issparse
>>> issparse(csr_matrix([[5]]))
True
>>> issparse(csr_array([[5]]))
True
>>> issparse(np.array([[5]]))
False
>>> issparse(5)
False
scipy.sparse.isspmatrix
scipy.sparse.isspmatrix(x)
x 是否为稀疏矩阵类型？
参数：
x
检查是否为稀疏矩阵的对象
返回：
布尔值
如果 x 是稀疏矩阵则返回 True，否则返回 False
示例
>>> import numpy as np
>>> from scipy.sparse import csr_array, csr_matrix, isspmatrix
>>> isspmatrix(csr_matrix([[5]]))
True
>>> isspmatrix(csr_array([[5]]))
False
>>> isspmatrix(np.array([[5]]))
False
>>> isspmatrix(5)
False
scipy.sparse.isspmatrix_csc
scipy.sparse.isspmatrix_csc(x)
x是否为 csc_matrix 类型？
参数：
x
要检查是否为 csc 矩阵的对象
返回：
布尔值
如果x是 csc 矩阵，则为 True，否则为 False
示例
>>> from scipy.sparse import csc_array, csc_matrix, coo_matrix, isspmatrix_csc
>>> isspmatrix_csc(csc_matrix([[5]]))
True
>>> isspmatrix_csc(csc_array([[5]]))
False
>>> isspmatrix_csc(coo_matrix([[5]]))
False
scipy.sparse.isspmatrix_csr
scipy.sparse.isspmatrix_csr(x)
x是 csr_matrix 类型吗？
参数：
x
要检查是否为 csr 矩阵的对象。
返回：
布尔值
如果x是 csr 矩阵，则为 True，否则为 False。
示例
>>> from scipy.sparse import csr_array, csr_matrix, coo_matrix, isspmatrix_csr
>>> isspmatrix_csr(csr_matrix([[5]]))
True
>>> isspmatrix_csr(csr_array([[5]]))
False
>>> isspmatrix_csr(coo_matrix([[5]]))
False
scipy.sparse.isspmatrix_bsr
scipy.sparse.isspmatrix_bsr(x)
x 是否是 bsr_matrix 类型？
参数：
x
检查是否为 bsr 矩阵的对象
返回：
布尔（bool）
如果 x 是 bsr 矩阵，则返回 True，否则返回 False
示例
>>> from scipy.sparse import bsr_array, bsr_matrix, csr_matrix, isspmatrix_bsr
>>> isspmatrix_bsr(bsr_matrix([[5]]))
True
>>> isspmatrix_bsr(bsr_array([[5]]))
False
>>> isspmatrix_bsr(csr_matrix([[5]]))
False
scipy.sparse.isspmatrix_lil
scipy.sparse.isspmatrix_lil(x)
x 是否为 lil_matrix 类型？
参数：
x
用于检查是否为 lil 矩阵的对象
返回：
布尔值
如果 x 是 lil 矩阵，则为 True；否则为 False
示例
>>> from scipy.sparse import lil_array, lil_matrix, coo_matrix, isspmatrix_lil
>>> isspmatrix_lil(lil_matrix([[5]]))
True
>>> isspmatrix_lil(lil_array([[5]]))
False
>>> isspmatrix_lil(coo_matrix([[5]]))
False
scipy.sparse.isspmatrix_dok
scipy.sparse.isspmatrix_dok(x)
是否为dok_array类型的x？
参数：
x
要检查是否为 dok 矩阵的对象
返回：
布尔值
如果x是 dok 矩阵，则为 True，否则为 False
示例
>>> from scipy.sparse import dok_array, dok_matrix, coo_matrix, isspmatrix_dok
>>> isspmatrix_dok(dok_matrix([[5]]))
True
>>> isspmatrix_dok(dok_array([[5]]))
False
>>> isspmatrix_dok(coo_matrix([[5]]))
False
scipy.sparse.isspmatrix_coo
scipy.sparse.isspmatrix_coo(x)
x 是否为 coo_matrix 类型？
参数：
x
要检查是否为 coo 矩阵的对象
返回值：
布尔值
如果 x 是 coo 矩阵则返回 True，否则返回 False
示例
>>> from scipy.sparse import coo_array, coo_matrix, csr_matrix, isspmatrix_coo
>>> isspmatrix_coo(coo_matrix([[5]]))
True
>>> isspmatrix_coo(coo_array([[5]]))
False
>>> isspmatrix_coo(csr_matrix([[5]]))
False
scipy.sparse.isspmatrix_dia
scipy.sparse.isspmatrix_dia(x)
x 是 dia_matrix 类型吗？
参数：
x
检查对象是否为 dia 矩阵
返回：
布尔值
如果 x 是 dia 矩阵则为 True，否则为 False
示例
>>> from scipy.sparse import dia_array, dia_matrix, coo_matrix, isspmatrix_dia
>>> isspmatrix_dia(dia_matrix([[5]]))
True
>>> isspmatrix_dia(dia_array([[5]]))
False
>>> isspmatrix_dia(coo_matrix([[5]]))
False
压缩稀疏图例程（scipy.sparse.csgraph）
原文：
docs.scipy.org/doc/scipy-1.12.0/reference/sparse.csgraph.html#module-scipy.sparse.csgraph
基于稀疏矩阵表示的快速图算法。
内容
connected_components(csgraph[, directed, ...]) |
分析稀疏图的连通分量 |
|---|---|
laplacian(csgraph[, normed, return_diag, ...]) |
返回有向图的拉普拉斯矩阵。 |
shortest_path(csgraph[, method, directed, ...]) |
在正向有向或无向图上执行最短路径图搜索。 |
dijkstra(csgraph[, directed, indices, ...]) |
使用斐波那契堆的迪杰斯特拉算法 |
floyd_warshall(csgraph[, directed, ...]) |
使用弗洛伊德-沃舍尔算法计算最短路径长度 |
bellman_ford(csgraph[, directed, indices, ...]) |
使用贝尔曼-福特算法计算最短路径长度。 |
johnson(csgraph[, directed, indices, ...]) |
使用约翰逊算法计算最短路径长度。 |
breadth_first_order(csgraph, i_start[, ...]) |
返回以指定节点开始的广度优先排序。 |
depth_first_order(csgraph, i_start[, ...]) |
返回以指定节点开始的深度优先排序。 |
breadth_first_tree(csgraph, i_start[, directed]) |
返回广度优先搜索生成的树。 |
depth_first_tree(csgraph, i_start[, directed]) |
返回深度优先搜索生成的树。 |
minimum_spanning_tree(csgraph[, overwrite]) |
返回无向图的最小生成树。 |
reverse_cuthill_mckee(graph[, symmetric_mode]) |
返回一个排列数组，按照 Reverse-Cuthill McKee 顺序排列稀疏 CSR 或 CSC 矩阵。 |
maximum_flow(csgraph, source, sink) |
在图中的两个顶点之间最大化流量。 |
maximum_bipartite_matching(graph[, perm_type]) |
返回一个二分图的匹配，其基数至少与图的任何给定匹配的基数相同。 |
min_weight_full_bipartite_matching(...[, ...]) |
返回二分图的最小权重完全匹配。 |
structural_rank(graph) |
计算给定稀疏模式图（矩阵）的结构秩。 |
NegativeCycleError([message]) |
|
construct_dist_matrix(graph, predecessors[, ...]) |
从前任矩阵构建距离矩阵。 |
csgraph_from_dense(graph[, null_value, ...]) |
从密集矩阵构建 CSR 格式稀疏图。 |
csgraph_from_masked(graph) |
从掩码数组构建 CSR 格式图。 |
csgraph_masked_from_dense(graph[, ...]) |
从密集矩阵构建掩码数组图表示。 |
csgraph_to_dense(csgraph[, null_value]) |
将稀疏图表示转换为密集表示 |
csgraph_to_masked(csgraph) |
将稀疏图表示转换为掩码数组表示 |
reconstruct_path(csgraph, predecessors[, ...]) |
从图和前任列表构造树。 |
图表示
该模块使用以矩阵格式存储的图。具有 N 个节点的图可以由(N x N)邻接矩阵 G 表示。如果从节点 i 到节点 j 存在连接，则 G[i, j] = w，其中 w 是连接的权重。对于未连接的节点 i 和 j，其值取决于表示方式：
-
对于密集数组表示，非边由 G[i, j] = 0, 无穷大或 NaN 表示。
-
对于密集掩码表示（类型为 np.ma.MaskedArray），非边由掩码值表示。当需要具有零权重边的图时，这将非常有用。
-
对于稀疏数组表示，非边由矩阵中的非条目表示。这种稀疏表示还允许具有零权重的边。
作为一个具体的例子，想象一下，您希望表示以下无向图：
G
(0)
/ \
1 2
/ \
(2) (1)
此图具有三个节点，其中节点 0 和 1 由权重为 2 的边连接，并且节点 0 和 2 由权重为 1 的边连接。我们可以构建如下的密集、掩码和稀疏表示，记住无向图由对称矩阵表示：
>>> import numpy as np
>>> G_dense = np.array([[0, 2, 1],
... [2, 0, 0],
... [1, 0, 0]])
>>> G_masked = np.ma.masked_values(G_dense, 0)
>>> from scipy.sparse import csr_matrix
>>> G_sparse = csr_matrix(G_dense)
当零边具有重要意义时，这变得更加困难。例如，考虑稍微修改上述图的情况：
G2
(0)
/ \
0 2
/ \
(2) (1)
这与上述图相同，除了节点 0 和 2 由零权重边连接。在这种情况下，上述的密集表示会导致歧义：如果零是一个有意义的值，那么如何表示非边？在这种情况下，必须使用掩码或稀疏表示来消除歧义：
>>> import numpy as np
>>> G2_data = np.array([[np.inf, 2, 0 ],
... [2, np.inf, np.inf],
... [0, np.inf, np.inf]])
>>> G2_masked = np.ma.masked_invalid(G2_data)
>>> from scipy.sparse.csgraph import csgraph_from_dense
>>> # G2_sparse = csr_matrix(G2_data) would give the wrong result
>>> G2_sparse = csgraph_from_dense(G2_data, null_value=np.inf)
>>> G2_sparse.data
array([ 2., 0., 2., 0.])
我们使用了来自csgraph子模块的实用程序例程，以便将密集表示转换为可以被子模块中的算法理解的稀疏表示。通过查看数据数组，我们可以看到零值在图中是明确编码的。
有向 vs. 无向
矩阵可以表示有向或无向图。这在 csgraph 模块中通过布尔关键字指定。默认情况下假定图是有向的。在有向图中，从节点 i 到节点 j 的遍历可以通过边 G[i, j] 完成，但不能通过边 G[j, i] 完成。考虑下面的稠密图：
>>> import numpy as np
>>> G_dense = np.array([[0, 1, 0],
... [2, 0, 3],
... [0, 4, 0]])
当 directed=True 时，我们得到如下图：
---1--> ---3-->
(0) (1) (2)
<--2--- <--4---
在非定向图中，从节点 i 到节点 j 的遍历可以通过 G[i, j] 或 G[j, i] 之一完成。如果两条边都不为空，并且它们的权重不相等，则选择较小的那条。
因此，对于相同的图，当 directed=False 时，我们得到如下图：
(0)--1--(1)--3--(2)
需要注意的是，对称矩阵将表示无向图，无论‘directed’关键字设置为 True 还是 False。在这种情况下，通常使用 directed=True 可以更高效地进行计算。
本模块中的例程接受作为输入的 scipy.sparse 表示（csr、csc 或 lil 格式）、带有掩码的表示或通过零、无穷大和 NaN 条目表示的密集表示的表示非边缘。
稀疏线性代数（scipy.sparse.linalg）
原文：
docs.scipy.org/doc/scipy-1.12.0/reference/sparse.linalg.html#module-scipy.sparse.linalg
抽象线性操作符
LinearOperator(*args, **kwargs) |
执行矩阵向量乘积的通用接口。 |
|---|---|
aslinearoperator(A) |
将 A 返回为 LinearOperator。 |
矩阵操作
inv(A) |
计算稀疏矩阵的逆。 |
|---|---|
expm(A) |
使用 Pade 逼近计算矩阵指数。 |
expm_multiply(A, B[, start, stop, num, ...]) |
计算矩阵 A 的指数在 B 上的作用。 |
matrix_power(A, power) |
将方阵 A 提升到整数次幂power。 |
矩阵范数
norm(x[, ord, axis]) |
稀疏矩阵的范数。 |
|---|---|
onenormest(A[, t, itmax, compute_v, compute_w]) |
计算稀疏矩阵 1-范数的下界。 |
解线性问题
线性方程系统的直接方法：
spsolve(A, b[, permc_spec, use_umfpack]) |
解稀疏线性系统 Ax=b，其中 b 可以是向量或矩阵。 |
|---|---|
spsolve_triangular(A, b[, lower, ...]) |
解方程A x = b，假设 A 是一个三角矩阵。 |
factorized(A) |
返回一个用于求解预因子化稀疏线性系统 A 的函数。 |
MatrixRankWarning |
|
use_solver(**kwargs) |
选择要使用的默认稀疏直接求解器。 |
线性方程组的迭代方法：
bicg(A, b[, x0, tol, maxiter, M, callback, ...]) |
使用 BI 共轭梯度迭代法解 Ax = b。 |
|---|---|
bicgstab(A, b, *[, x0, tol, maxiter, M, ...]) |
使用稳定化的 BI 共轭梯度迭代法解 Ax = b。 |
cg(A, b[, x0, tol, maxiter, M, callback, ...]) |
使用共轭梯度迭代法解 Ax = b。 |
cgs(A, b[, x0, tol, maxiter, M, callback, ...]) |
使用共轭梯度平方迭代法解 Ax = b。 |
gmres(A, b[, x0, tol, restart, maxiter, M, ...]) |
使用广义最小残差迭代法解决 Ax = b。 |
lgmres(A, b[, x0, tol, maxiter, M, ...]) |
使用 LGMRES 算法解方程。 |
minres(A, b[, x0, shift, tol, maxiter, M, ...]) |
使用最小残差迭代法解决方程 Ax = b |
qmr(A, b[, x0, tol, maxiter, M1, M2, ...]) |
使用准最小残差迭代法解 Ax = b。 |
gcrotmk(A, b[, x0, tol, maxiter, M, ...]) |
使用灵活的 GCROT(m,k) 算法解方程。 |
tfqmr(A, b[, x0, tol, maxiter, M, callback, ...]) |
使用无转置的准最小残差迭代法解 Ax = b。 |
最小二乘问题的迭代方法：
lsqr(A, b[, damp, atol, btol, conlim, ...]) |
求解大型稀疏线性方程组的最小二乘解。 |
|---|---|
lsmr(A, b[, damp, atol, btol, conlim, ...]) |
用于最小二乘问题的迭代求解器。 |
矩阵分解
特征值问题：
eigs(A[, k, M, sigma, which, v0, ncv, ...]) |
寻找方阵 A 的 k 个特征值和特征向量。 |
|---|---|
eigsh(A[, k, M, sigma, which, v0, ncv, ...]) |
求解实对称方阵或复共轭 Hermitian 方阵 A 的 k 个特征值和特征向量。 |
lobpcg(A, X[, B, M, Y, tol, maxiter, ...]) |
局部最优块预处理共轭梯度法（LOBPCG）。 |
特征值问题：
svds(A[, k, ncv, tol, which, v0, maxiter, ...]) |
稀疏矩阵的部分奇异值分解。 |
|---|
svds 函数支持以下求解器：
-
svds(solver=’arpack’)
-
svds(solver=’lobpcg’)
-
svds(solver=’propack’)
完全或不完全 LU 分解
splu(A[, permc_spec, diag_pivot_thresh, ...]) |
计算稀疏方阵的 LU 分解。 |
|---|---|
spilu(A[, drop_tol, fill_factor, drop_rule, ...]) |
计算稀疏方阵的不完全 LU 分解。 |
SuperLU() |
稀疏矩阵的 LU 分解。 |
稀疏结构的稀疏数组
LaplacianNd(*args, **kwargs) |
N 维网格的 Laplacian 及其特征值/特征向量。 |
|---|
异常情况
ArpackNoConvergence(msg, eigenvalues, ...) |
ARPACK 迭代未收敛 |
|---|---|
ArpackError(info[, infodict]) |
ARPACK 错误 |
scipy.sparse.SparseEfficiencyWarning
exception scipy.sparse.SparseEfficiencyWarning
with_traceback()
Exception.with_traceback(tb) – 设置 self.traceback 为 tb 并返回 self。
scipy.sparse.SparseWarning
exception scipy.sparse.SparseWarning
with_traceback()
Exception.with_traceback(tb) – 设置 self.traceback 为 tb 并返回 self。
空间算法和数据结构（scipy.spatial）
空间变换
这些内容包含在scipy.spatial.transform子模块中。
最近邻查询
KDTree(data[, leafsize, compact_nodes, ...]) |
用于快速最近邻查找的 kd 树 |
|---|---|
cKDTree(data[, leafsize, compact_nodes, ...]) |
用于快速最近邻查找的 kd 树 |
Rectangle(maxes, mins) |
超矩形类。 |
距离度量
距离度量包含在scipy.spatial.distance子模块中。
Delaunay 三角剖分，凸包和 Voronoi 图
Delaunay(points[, furthest_site, ...]) |
N 维空间中的 Delaunay 剖分 |
|---|---|
ConvexHull(points[, incremental, qhull_options]) |
N 维空间中的凸包 |
Voronoi(points[, furthest_site, ...]) |
N 维空间中的 Voronoi 图 |
SphericalVoronoi(points[, radius, center, ...]) |
球面上的 Voronoi 图 |
HalfspaceIntersection(halfspaces, interior_point) |
N 维空间中的半空间交 |
绘图辅助函数
delaunay_plot_2d(tri[, ax]) |
绘制给定的二维 Delaunay 三角剖分 |
|---|---|
convex_hull_plot_2d(hull[, ax]) |
绘制给定的二维凸包图 |
voronoi_plot_2d(vor[, ax]) |
绘制给定的二维 Voronoi 图 |
另请参见
教程
单纯形表示
Delaunay 剖分中出现的单纯形（三角形，四面体等），凸壳的面和 Voronoi 岭（N-1-D 单纯形）在以下方案中表示：
tess = Delaunay(points)
hull = ConvexHull(points)
voro = Voronoi(points)
# coordinates of the jth vertex of the ith simplex
tess.points[tess.simplices[i, j], :] # tessellation element
hull.points[hull.simplices[i, j], :] # convex hull facet
voro.vertices[voro.ridge_vertices[i, j], :] # ridge between Voronoi cells
对于 Delaunay 三角剖分和凸包，简单形式的邻域结构满足条件：tess.neighbors[i,j] 是第 i 个简单形式中第 j 个顶点对应的相邻简单形式。如果没有相邻简单形式，则为 -1。
凸包面也定义了一个超平面方程：
(hull.equations[i,:-1] * coord).sum() + hull.equations[i,-1] == 0
对于 Delaunay 三角剖分，类似的超平面方程对应于相应的 N+1 维抛物面上的凸包面。
Delaunay 三角剖分对象提供了一个方法，用于定位包含给定点的简单形式，以及重心坐标计算。
函数
tsearch(tri, xi) |
找到包含给定点的简单形式。 |
|---|---|
distance_matrix(x, y[, p, threshold]) |
计算距离矩阵。 |
minkowski_distance(x, y[, p]) |
计算两个数组之间的 L**p 距离。 |
minkowski_distance_p(x, y[, p]) |
计算两个数组之间 L**p 距离的 p 次方。 |
procrustes(data1, data2) |
Procrustes 分析，用于比较两个数据集的相似性。 |
geometric_slerp(start, end, t[, tol]) |
几何球面线性插值。 |
在 scipy.spatial 中使用的警告 / 错误信息
QhullError |
|---|
scipy.spatial.KDTree
原文：
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.spatial.KDTree.html#scipy.spatial.KDTree
class scipy.spatial.KDTree(data, leafsize=10, compact_nodes=True, copy_data=False, balanced_tree=True, boxsize=None)
用于快速最近邻查找的 kd 树。
该类提供了对一组 k 维点的索引，可用于快速查找任意点的最近邻居。
参数：
data 数组样式，形状（n，m）
要索引的 n 个 m 维数据点。除非需要生成双精度连续数组，否则不会复制此数组，因此修改此数据将导致错误的结果。如果使用 copy_data=True 构建 kd 树，则也会复制数据。
leafsize 正整数，可选
算法在切换到暴力法的点数。默认值：10。
compact_nodes 布尔值，可选
如果为 True，则构建 kd 树以缩小超矩形到实际数据范围。这通常会得到一个更紧凑的树，对退化输入数据更具鲁棒性，并以更快的查询速度换取更长的构建时间。默认值：True。
copy_data 布尔值，可选
如果为 True，则数据始终会复制以保护 kd 树免受数据损坏。默认值：False。
balanced_tree 布尔值，可选
如果为 True，则使用中位数来分割超矩形，而不是中点。这通常会得到一个更紧凑的树和更快的查询速度，但以更长的构建时间为代价。默认值：True。
boxsize 数组样式或标量，可选
将 m 维环面拓扑应用于 KDTree。该拓扑由(x_i + n_i L_i)生成，其中(n_i)为整数，(L_i)为第 i 维的盒尺寸。输入数据将被包裹到(0, L_i))中。如果任何数据超出此边界，则会引发 ValueError。
注意：
使用的算法在 Maneewongvatana 和 Mount 1999 年的文章中有描述。总体思想是 kd 树是一个二叉树，每个节点代表一个轴对齐的超矩形。每个节点指定一个轴并根据它们沿该轴的坐标是否大于或小于特定值来分割点集。
在构建过程中，轴和分割点是由“滑动中点”规则选择的，这确保单元不会全部变得又长又细。
可查询给定点的 r 个最近邻居（可选仅返回距离点的最大距离内的那些）。还可以查询 r 个近似最近邻居，效率显著提高。
对于大维度（20 已经很大），不要指望比暴力法运行得更快。高维度最近邻查询是计算机科学中一个重要的未解决问题。
属性：
data ndarray，形状（n，m）
要索引的维度 m 的 n 数据点。除非需要生成连续的 double 数组，否则不会复制此数组。如果使用copy_data=True构建 kd 树，则数据也会被复制。
leafsizepositive int
算法转换为暴力方法的点数。
mint
单个数据点的维度。
nint
数据点的数量。
maxesndarray, shape (m,)
数据点 n 维度中每个维度的最大值。
minsndarray, shape (m,)
数据点 n 维度中每个维度的最小值。
sizeint
树中节点的数量。
方法
[count_neighbors(other, r[, p, weights, ...]) |
计算可以形成的附近点对数。 |
|---|---|
query(x[, k, eps, p, distance_upper_bound, ...]) |
查询 kd 树以获取最近邻居。 |
query_ball_point(x, r[, p, eps, workers, ...]) |
查找距离点 x 距离小于 r 的所有点。 |
query_ball_tree(other, r[, p, eps]) |
查找self和other之间距离最多为 r 的所有点对。 |
query_pairs(r[, p, eps, output_type]) |
查找self中距离最多为 r 的所有点对。 |
sparse_distance_matrix(other, max_distance) |
计算稀疏距离矩阵。 |
| innernode | |
| leafnode | |
| node |
scipy.spatial.cKDTree
原文链接：
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.spatial.cKDTree.html#scipy.spatial.cKDTree
class scipy.spatial.cKDTree(data, leafsize=16, compact_nodes=True, copy_data=False, balanced_tree=True, boxsize=None)
用于快速最近邻查找的 kd 树
此类提供对一组 k 维点的索引，可用于快速查找任意点的最近邻居。
注意
cKDTree在功能上与KDTree相同。在 SciPy v1.6.0 之前，cKDTree性能更好，功能略有不同，但现在这两个名称仅用于向后兼容。如果不考虑与 SciPy < 1.6 的兼容性问题，请优先使用KDTree。
参数:
data类似数组，形状为(n,m)
要索引的 n 个 m 维数据点。除非必须生成连续的双精度数组，否则不会复制此数组，因此修改这些数据将导致伪数据结果。如果使用 copy_data=True 构建 kd 树，则也会复制数据。
leafsize正整数，可选
算法切换到暴力方法的点数。默认值：16。
compact_nodes布尔值，可选
如果为 True，则构建 kd 树以缩小超矩形至实际数据范围。这通常会得到更紧凑的树，能够处理退化输入数据并在查询时提供更快的速度，但会增加构建时间。默认值：True。
copy_data布尔值，可选
如果为 True，则始终复制数据以保护 kd 树免受数据损坏。默认值：False。
balanced_tree布尔值，可选
如果为 True，则使用中位数来分割超矩形，而不是使用中点。这通常会给出更紧凑的树和更快的查询速度，但会增加构建时间。默认值：True。
boxsize类似数组或标量，可选
对 KDTree 应用 m 维环形拓扑结构。拓扑结构由(x_i + n_i L_i)生成，其中(n_i)为整数，(L_i)为第 i 维的箱尺寸。输入数据将被包装到([0, L_i))。如果任何数据超出此边界，则会引发 ValueError。
注意事项
所使用的算法描述在 Maneewongvatana 和 Mount 1999 年的论文中。其主要思想是 kd 树是一棵二叉树，每个节点代表一个轴对齐的超矩形。每个节点指定一个轴，并根据它们沿该轴的坐标是否大于或小于特定值来分割点集。
在构建过程中，通过“滑动中位数”规则选择轴和分割点，以确保单元格不会全部变得又长又薄。
可以查询树以获取任意给定点的最接近的 r 个邻居（可选仅返回距离该点某些最大距离内的邻居）。还可以查询，效率大大提高，获取 r 个近似最近邻居。
对于大维度（20 已经很大），不要指望此方法比暴力搜索运行更快。高维度最近邻查询是计算机科学中一个重要的开放问题。
属性：
datandarray，形状为 (n,m)
要索引的 n 个维度为 m 的数据点。除非需要生成连续的 double 数组，否则不会复制此数组。如果使用 copy_data=True 构建 kd 树，则还会复制数据。
leafsize正整数
算法切换到暴力搜索的点数。
mint
单个数据点的维数。
nint
数据点的数量。
maxesndarray，形状为 (m,)
n 个数据点每个维度的最大值。
minsndarray，形状为 (m,)
n 个数据点中每个维度的最小值。
tree对象，类 cKDTreeNode
此属性提供了 cKDTree 对象中根节点的 Python 视图。kd 树的完整 Python 视图在首次访问时动态创建。此属性允许您在 Python 中创建自己的查询函数。
sizeint
树中的节点数。
方法
count_neighbors(self, other, r[, p, ...]) |
计算可以形成的附近对数。 |
|---|---|
query(self, x[, k, eps, p, ...]) |
查询 kd 树的最近邻居 |
query_ball_point(self, x, r[, p, eps, ...]) |
查找距离点 x 距离小于 r 的所有点。 |
query_ball_tree(self, other, r[, p, eps]) |
找到 self 和 other 之间距离最多为 r 的所有点对。 |
query_pairs(self, r[, p, eps, output_type]) |
找到距离 self 中任意一对点距离最多为 r 的所有点对。 |
sparse_distance_matrix(self, other, max_distance) |
计算稀疏距离矩阵 |
scipy.spatial.Rectangle
class scipy.spatial.Rectangle(maxes, mins)
超矩形类。
表示区间的笛卡尔积。
方法
max_distance_point(x[, p]) |
返回输入点与超矩形中点之间的最大距离。 |
|---|---|
max_distance_rectangle(other[, p]) |
计算两个超矩形之间点的最大距离。 |
min_distance_point(x[, p]) |
返回输入点与超矩形中点之间的最小距离。 |
min_distance_rectangle(other[, p]) |
计算两个超矩形之间点的最小距离。 |
split(d, split) |
通过分割生成两个超矩形。 |
volume() |
总体积。 |
scipy.spatial.Delaunay
class scipy.spatial.Delaunay(points, furthest_site=False, incremental=False, qhull_options=None)
N 维中的 Delaunay 镶嵌。
从版本 0.9 开始新增。
参数：
points浮点数数组，形状为（npoints，ndim）
要三角化的点的坐标
furthest_site布尔值，可选
是否计算最远点 Delaunay 三角剖分。默认值：False
从版本 0.12.0 开始新增。
incremental布尔值，可选
允许逐步添加新点。这会占用额外的资源。
qhull_options字符串，可选
传递给 Qhull 的其他选项。有关详细信息，请参阅 Qhull 手册。选项“Qt”始终启用。默认值：“Qbb Qc Qz Qx Q12”（对于 ndim > 4）和“Qbb Qc Qz Q12”（否则）。递增模式省略“Qz”。
从版本 0.12.0 开始新增。
引发：
QhullError
当 Qhull 遇到错误条件（例如在未启用解决选项的几何退化时）时引发。
ValueError
如果输入给出的数组不兼容，则引发。
注意
使用 Qhull 库计算的镶嵌 Qhull library。
注意
除非您传入 Qhull 选项“QJ”，否则 Qhull 不保证每个输入点都会出现在 Delaunay 三角剖分的顶点中。省略的点在coplanar属性中列出。
示例
一组点的三角剖分：
>>> import numpy as np
>>> points = np.array([[0, 0], [0, 1.1], [1, 0], [1, 1]])
>>> from scipy.spatial import Delaunay
>>> tri = Delaunay(points)
我们可以绘制它：
>>> import matplotlib.pyplot as plt
>>> plt.triplot(points[:,0], points[:,1], tri.simplices)
>>> plt.plot(points[:,0], points[:,1], 'o')
>>> plt.show()
形成三角剖分的两个三角形的点的索引和坐标：
>>> tri.simplices
array([[2, 3, 0], # may vary
[3, 1, 0]], dtype=int32)
请注意，根据舍入误差的处理方式，简单形可能与上述不同的顺序排列。
>>> points[tri.simplices]
array([[[ 1\. , 0\. ], # may vary
[ 1\. , 1\. ],
[ 0\. , 0\. ]],
[[ 1\. , 1\. ],
[ 0\. , 1.1],
[ 0\. , 0\. ]]])
三角形 0 是三角形 1 的唯一相邻单元，并且它位于三角形 1 的顶点 1 的对面：
>>> tri.neighbors[1]
array([-1, 0, -1], dtype=int32)
>>> points[tri.simplices[1,1]]
array([ 0\. , 1.1])
我们可以找出哪些三角形点在：
>>> p = np.array([(0.1, 0.2), (1.5, 0.5), (0.5, 1.05)])
>>> tri.find_simplex(p)
array([ 1, -1, 1], dtype=int32)
数组中返回的整数是相应点所在单纯形的索引。如果返回-1，则表示该点不在任何单纯形中。请注意，以下示例中的快捷方式仅适用于有效点，因为无效点返回-1，而-1 本身是列表中最后一个单纯形的有效索引。
>>> p_valids = np.array([(0.1, 0.2), (0.5, 1.05)])
>>> tri.simplices[tri.find_simplex(p_valids)]
array([[3, 1, 0], # may vary
[3, 1, 0]], dtype=int32)
我们还可以为这些点在三角形 1 中计算重心坐标：
>>> b = tri.transform[1,:2].dot(np.transpose(p - tri.transform[1,2]))
>>> np.c_[np.transpose(b), 1 - b.sum(axis=0)]
array([[ 0.1 , 0.09090909, 0.80909091],
[ 1.5 , -0.90909091, 0.40909091],
[ 0.5 , 0.5 , 0\. ]])
第一个点的坐标全为正，这意味着它确实在三角形内部。第三个点在边缘上，因此其第三个坐标为空。
属性：
points双精度数组，形状为（npoints，ndim）
输入点的坐标。
simplices整数数组，形状为（nsimplex，ndim+1）
在三角形剖分中形成单纯形的点的索引。对于 2-D，点是逆时针方向排列的。
neighbors整数数组，形状为（nsimplex，ndim+1）
每个单纯形的相邻单纯形的索引。第 k 个相邻单纯形位于第 k 个顶点的对面。对于边界上的单纯形，-1 表示没有相邻单纯形。
equations双精度数组，形状为（nsimplex，ndim+2）
[normal, offset]构成抛物面上平面方程的超平面（详见Qhull 文档）。
paraboloid_scale, paraboloid_shiftfloat
用于额外抛物面维度的缩放和移位（详见Qhull 文档）。
transform双精度数组，形状为 (nsimplex, ndim+1, ndim)
从x到重心坐标c的仿射变换。
vertex_to_simplex整数的 ndarray，形状为 (npoints,)
从顶点到其所属单纯形的查找数组。
convex_hull整数的 ndarray，形状为 (nfaces, ndim)
构成点集凸包的面的顶点。
coplanar整数的 ndarray，形状为 (ncoplanar, 3)
共面点的索引及其最近平面和最近顶点的相应索引。由于数值精度问题，共面点是未包含在三角剖分中的输入点。
如果未指定选项“Qc”，则不计算此列表。
新版本 0.12.0 中引入。
vertex_neighbor_vertices包含两个 int 类型的 ndarray 元组；(indptr, indices)
顶点的相邻顶点。
furthest_site
如果这是一个最远点三角剖分，则为 True；如果不是，则为 False。
新版本 1.4.0 中引入。
方法
add_points(points[, restart]) |
处理一组额外的新点。 |
|---|---|
close() |
完成增量处理。 |
find_simplex(self, xi[, bruteforce, tol]) |
查找包含给定点的单纯形。 |
lift_points(self, x) |
将点映射到 Qhull 抛物面上。 |
plane_distance(self, xi) |
计算到所有单纯形点 xi 的超平面距离。 |
