稀疏数据结构

pandas 提供了有效存储稀疏数据的数据结构。这些并不一定是典型的“大部分为 0”的稀疏现象。相反，您可以将这些对象视为被“压缩”，其中匹配特定值（NaN/缺失值，尽管可以选择任何值，包括 0）的任何数据都被省略。压缩值实际上并未存储在数组中。

In [1]: arr = np.random.randn(10)

In [2]: arr[2:-2] = np.nan

In [3]: ts = pd.Series(pd.arrays.SparseArray(arr))

In [4]: ts
Out[4]: 
0    0.469112
1   -0.282863
2         NaN
3         NaN
4         NaN
5         NaN
6         NaN
7         NaN
8   -0.861849
9   -2.104569
dtype: Sparse[float64, nan]

注意 dtype ，.这意味着数组中的元素实际上并未存储，仅存储非元素。这些非元素具有dtype。Sparse[float64, nan]nannannannanfloat64

稀疏对象的存在是出于内存效率的原因。假设你有一个很大的，大部分是 NA DataFrame：

In [5]: df = pd.DataFrame(np.random.randn(10000, 4))

In [6]: df.iloc[:9998] = np.nan

In [7]: sdf = df.astype(pd.SparseDtype("float", np.nan))

In [8]: sdf.head()
Out[8]: 
     0    1    2    3
0  NaN  NaN  NaN  NaN
1  NaN  NaN  NaN  NaN
2  NaN  NaN  NaN  NaN
3  NaN  NaN  NaN  NaN
4  NaN  NaN  NaN  NaN

In [9]: sdf.dtypes
Out[9]: 
0    Sparse[float64, nan]
1    Sparse[float64, nan]
2    Sparse[float64, nan]
3    Sparse[float64, nan]
dtype: object

In [10]: sdf.sparse.density
Out[10]: 0.0002

正如您所看到的，密度（未“压缩”的值的百分比）极低。这个稀疏对象在磁盘（pickled）和Python解释器中占用的内存要少得多。

In [11]: 'dense : {:0.2f} bytes'.format(df.memory_usage().sum() / 1e3)
Out[11]: 'dense : 320.13 bytes'

In [12]: 'sparse: {:0.2f} bytes'.format(sdf.memory_usage().sum() / 1e3)
Out[12]: 'sparse: 0.22 bytes'

从功能上讲，它们的行为应该与密集的对应物几乎相同。

稀疏数组

arrays.SparseArray用于ExtensionArray 存储稀疏值数组（有关扩展数组的更多信息，请参阅dtypes ）。它是一个类似 ndarray 的一维对象，仅存储不同于以下值的值fill_value：

In [13]: arr = np.random.randn(10)

In [14]: arr[2:5] = np.nan

In [15]: arr[7:8] = np.nan

In [16]: sparr = pd.arrays.SparseArray(arr)

In [17]: sparr
Out[17]: 
[-1.9556635297215477, -1.6588664275960427, nan, nan, nan, 1.1589328886422277, 0.14529711373305043, nan, 0.6060271905134522, 1.3342113401317768]
Fill: nan
IntIndex
Indices: array([0, 1, 5, 6, 8, 9], dtype=int32)

稀疏数组可以转换为常规（密集）ndarraynumpy.asarray()

In [18]: np.asarray(sparr)
Out[18]: 
array([-1.9557, -1.6589,     nan,     nan,     nan,  1.1589,  0.1453,
           nan,  0.606 ,  1.3342])

稀疏D类型

该SparseArray.dtype属性存储了两条信息

1. 非稀疏值的数据类型

2. 标量填充值

In [19]: sparr.dtype
Out[19]: Sparse[float64, nan]

ASparseDtype可以通过仅传递 dtype 来构造

In [20]: pd.SparseDtype(np.dtype('datetime64[ns]'))
Out[20]: Sparse[datetime64[ns], numpy.datetime64('NaT')]

在这种情况下，将使用默认填充值（对于 NumPy 数据类型，这通常是该数据类型的“缺失”值）。要覆盖此默认值，可以传递显式填充值

In [21]: pd.SparseDtype(np.dtype('datetime64[ns]'),
   ....:                fill_value=pd.Timestamp('2017-01-01'))
   ....: 
Out[21]: Sparse[datetime64[ns], Timestamp('2017-01-01 00:00:00')]

最后，字符串别名'Sparse[dtype]'可用于在许多地方指定稀疏数据类型

In [22]: pd.array([1, 0, 0, 2], dtype='Sparse[int]')
Out[22]: 
[1, 0, 0, 2]
Fill: 0
IntIndex
Indices: array([0, 3], dtype=int32)

稀疏访问器

pandas 提供了一个.sparse类似于.str字符串数据、.cat 分类数据和.dt类似日期时间数据的访问器。此命名空间提供特定于稀疏数据的属性和方法。

In [23]: s = pd.Series([0, 0, 1, 2], dtype="Sparse[int]")

In [24]: s.sparse.density
Out[24]: 0.5

In [25]: s.sparse.fill_value
Out[25]: 0

此访问器仅适用于 的数据SparseDtype，以及Series 类本身，用于使用来自 scipy COO 矩阵的稀疏数据创建系列。

还.sparse添加了一个访问器。有关更多信息，DataFrame请参阅稀疏访问器。

稀疏计算

您可以应用 NumPy ufuncs并arrays.SparseArray获得arrays.SparseArray结果。

In [26]: arr = pd.arrays.SparseArray([1., np.nan, np.nan, -2., np.nan])

In [27]: np.abs(arr)
Out[27]: 
[1.0, nan, nan, 2.0, nan]
Fill: nan
IntIndex
Indices: array([0, 3], dtype=int32)

ufunc也适用于fill_value.这是获得正确的密集结果所必需的。

In [28]: arr = pd.arrays.SparseArray([1., -1, -1, -2., -1], fill_value=-1)

In [29]: np.abs(arr)
Out[29]: 
[1, 1, 1, 2.0, 1]
Fill: 1
IntIndex
Indices: array([3], dtype=int32)

In [30]: np.abs(arr).to_dense()
Out[30]: array([1., 1., 1., 2., 1.])

转换

要将数据从稀疏转换为密集，请使用.sparse访问器

In [31]: sdf.sparse.to_dense()
Out[31]: 
             0         1         2         3
0          NaN       NaN       NaN       NaN
1          NaN       NaN       NaN       NaN
2          NaN       NaN       NaN       NaN
3          NaN       NaN       NaN       NaN
4          NaN       NaN       NaN       NaN
...        ...       ...       ...       ...
9995       NaN       NaN       NaN       NaN
9996       NaN       NaN       NaN       NaN
9997       NaN       NaN       NaN       NaN
9998  0.509184 -0.774928 -1.369894 -0.382141
9999  0.280249 -1.648493  1.490865 -0.890819

[10000 rows x 4 columns]

从密集到稀疏，DataFrame.astype()与 一起使用SparseDtype。

In [32]: dense = pd.DataFrame({"A": [1, 0, 0, 1]})

In [33]: dtype = pd.SparseDtype(int, fill_value=0)

In [34]: dense.astype(dtype)
Out[34]: 
   A
0  1
1  0
2  0
3  1

与scipy.sparse交互

用于从稀疏矩阵DataFrame.sparse.from_spmatrix()创建稀疏值。DataFrame

In [35]: from scipy.sparse import csr_matrix

In [36]: arr = np.random.random(size=(1000, 5))

In [37]: arr[arr < .9] = 0

In [38]: sp_arr = csr_matrix(arr)

In [39]: sp_arr
Out[39]: 
<1000x5 sparse matrix of type '<class 'numpy.float64'>'
	with 517 stored elements in Compressed Sparse Row format>

In [40]: sdf = pd.DataFrame.sparse.from_spmatrix(sp_arr)

In [41]: sdf.head()
Out[41]: 
          0  1  2         3  4
0   0.95638  0  0         0  0
1         0  0  0         0  0
2         0  0  0         0  0
3         0  0  0         0  0
4  0.999552  0  0  0.956153  0

In [42]: sdf.dtypes
Out[42]: 
0    Sparse[float64, 0]
1    Sparse[float64, 0]
2    Sparse[float64, 0]
3    Sparse[float64, 0]
4    Sparse[float64, 0]
dtype: object

支持所有稀疏格式，但不符合COOrdinate格式的矩阵将被转换，并根据需要复制数据。要转换回 COO 格式的稀疏 SciPy 矩阵，可以使用以下DataFrame.sparse.to_coo()方法：

In [43]: sdf.sparse.to_coo()
Out[43]: 
<1000x5 sparse matrix of type '<class 'numpy.float64'>'
	with 517 stored elements in COOrdinate format>

Series.sparse.to_coo()实现用于将Series具有由 a 索引的稀疏值的a 转换MultiIndex为 a scipy.sparse.coo_matrix。

该方法需要MultiIndex具有两个或多个级别。

In [44]: s = pd.Series([3.0, np.nan, 1.0, 3.0, np.nan, np.nan])

In [45]: s.index = pd.MultiIndex.from_tuples(
   ....:     [
   ....:         (1, 2, "a", 0),
   ....:         (1, 2, "a", 1),
   ....:         (1, 1, "b", 0),
   ....:         (1, 1, "b", 1),
   ....:         (2, 1, "b", 0),
   ....:         (2, 1, "b", 1),
   ....:     ],
   ....:     names=["A", "B", "C", "D"],
   ....: )
   ....: 

In [46]: ss = s.astype('Sparse')

In [47]: ss
Out[47]: 
A  B  C  D
1  2  a  0    3.0
         1    NaN
   1  b  0    1.0
         1    3.0
2  1  b  0    NaN
         1    NaN
dtype: Sparse[float64, nan]

在下面的示例中，我们通过指定第一和第二级别定义行的标签，第三和第四级别定义列的标签，将 转换Series为二维数组的稀疏表示。MultiIndex我们还指定列和行标签应在最终的稀疏表示中排序。

In [48]: A, rows, columns = ss.sparse.to_coo(
   ....:     row_levels=["A", "B"], column_levels=["C", "D"], sort_labels=True
   ....: )
   ....: 

In [49]: A
Out[49]: 
<3x4 sparse matrix of type '<class 'numpy.float64'>'
	with 3 stored elements in COOrdinate format>

In [50]: A.todense()
Out[50]: 
matrix([[0., 0., 1., 3.],
        [3., 0., 0., 0.],
        [0., 0., 0., 0.]])

In [51]: rows
Out[51]: [(1, 1), (1, 2), (2, 1)]

In [52]: columns
Out[52]: [('a', 0), ('a', 1), ('b', 0), ('b', 1)]

指定不同的行和列标签（而不是对它们进行排序）会产生不同的稀疏矩阵：

In [53]: A, rows, columns = ss.sparse.to_coo(
   ....:     row_levels=["A", "B", "C"], column_levels=["D"], sort_labels=False
   ....: )
   ....: 

In [54]: A
Out[54]: 
<3x2 sparse matrix of type '<class 'numpy.float64'>'
	with 3 stored elements in COOrdinate format>

In [55]: A.todense()
Out[55]: 
matrix([[3., 0.],
        [1., 3.],
        [0., 0.]])

In [56]: rows
Out[56]: [(1, 2, 'a'), (1, 1, 'b'), (2, 1, 'b')]

In [57]: columns
Out[57]: [(0,), (1,)]

Series.sparse.from_coo()实现了一种便捷方法，用于Series从 a 创建具有稀疏值的 a scipy.sparse.coo_matrix。

In [58]: from scipy import sparse

In [59]: A = sparse.coo_matrix(([3.0, 1.0, 2.0], ([1, 0, 0], [0, 2, 3])), shape=(3, 4))

In [60]: A
Out[60]: 
<3x4 sparse matrix of type '<class 'numpy.float64'>'
	with 3 stored elements in COOrdinate format>

In [61]: A.todense()
Out[61]: 
matrix([[0., 0., 1., 2.],
        [3., 0., 0., 0.],
        [0., 0., 0., 0.]])

默认行为（使用dense_index=False）仅返回Series仅包含非空条目的 a 。

In [62]: ss = pd.Series.sparse.from_coo(A)

In [63]: ss
Out[63]: 
0  2    1.0
   3    2.0
1  0    3.0
dtype: Sparse[float64, nan]

指定dense_index=True将产生一个索引，该索引是矩阵的行坐标和列坐标的笛卡尔积。请注意，dense_index=False如果稀疏矩阵足够大（且稀疏），这将消耗大量内存（相对于）。

In [64]: ss_dense = pd.Series.sparse.from_coo(A, dense_index=True)

In [65]: ss_dense
Out[65]: 
1  0    3.0
   2    NaN
   3    NaN
0  0    NaN
   2    1.0
   3    2.0
   0    NaN
   2    1.0
   3    2.0
dtype: Sparse[float64, nan]