如何将Pandas DataFrame高效转换为SciPy稀疏CSC_Array？

问题分析 #

你手动实现的逻辑是将原DataFrame的前0行、前1行、前2行……直到指定行数的子矩阵依次垂直堆叠，最终转换为CSC Array，但手动逐个写iloc[:k]无法推广到大量行/列的场景。直接用scipy.sparse.csc_matrix(dataFrame.values)得到的是原DataFrame的直接稀疏转换，形状和内容都不符合你需要的累积堆叠结构，所以需要针对性的高效实现方案。

高效实现思路 #

避免循环堆叠的低效操作，直接通过构造稀疏矩阵的核心组件（data、row_indices、col_indices）来生成目标CSC Array，利用numpy矢量化操作提升性能，时间复杂度远低于循环堆叠。

完整代码示例 #

import pandas as pd
import numpy as np
from scipy.sparse import csc_array

# 你的示例DataFrame
col1 = [1, 5, 6, 3, 3, 8, 6, 7, 4, 2]
col2 = [10, 40, 45, 28, 34, 85, 58, 65, 34, 18]
col3 = [4, 19, 25, 14, 11, 32, 28, 30, 11, 8]
col4 = [1, 2, 1, 2, 2, 1, 2, 1, 1, 2]

dataFrame = pd.DataFrame({'Cost': col1,
                          'Weight': col2,
                          'Value': col3,
                          'Type': col4})

# 核心转换函数：生成包含所有累积行堆叠的CSC Array
def df_to_cumulative_csc(df):
    N, M = df.shape
    # 计算每个子矩阵的起始行号：前k行子矩阵的起始行是0+1+2+...+(k-1)
    starts = np.cumsum(np.arange(N+1))
    
    # 1. 生成重复后的数据：原第i行的每个元素重复(N - i)次（出现在前i+1到前N行的子矩阵中）
    flat_vals = df.values.flatten()
    repeat_counts = np.repeat(N - np.arange(N), M)
    data = np.repeat(flat_vals, repeat_counts)
    
    # 2. 生成列索引：原列号按行重复，再对应次数扩展
    col_indices = np.repeat(np.tile(np.arange(M), N), repeat_counts)
    
    # 3. 生成行索引：每个原行i对应的堆叠后行号集合
    row_indices = []
    for i in range(N):
        # 前k行子矩阵（k从i+1到N）的起始行号 + 原行i在子矩阵中的位置i
        row_indices.append(starts[i+1:N+1] + i)
    row_indices = np.concatenate(row_indices)
    
    # 构造CSC Array
    return csc_array((data, (row_indices, col_indices)), shape=(starts[-1], M))

# 生成最终结果
cscArray = df_to_cumulative_csc(dataFrame)

关键说明 #

• 结构匹配：生成的CSC Array完全对应你手动堆叠的逻辑——包含原DataFrame前0行、前1行……前N行的所有子矩阵垂直堆叠的结果。
• 性能优化：用numpy矢量化操作替代循环堆叠，避免了多次矩阵合并的开销，即使处理1000行+200列的DataFrame也能快速完成。
• 稀疏性兼容：如果原DataFrame存在大量零值，可以使用以下优化版本过滤零元素，进一步减少存储和计算量：

  # 过滤零元素的优化版本
  def df_to_cumulative_csc_sparse(df):
      N, M = df.shape
      starts = np.cumsum(np.arange(N+1))
      
      # 获取非零元素的位置和值
      non_zero_mask = df.values != 0
      rows_orig, cols_orig = np.where(non_zero_mask)
      vals = df.values[non_zero_mask]
      
      # 计算每个非零元素的重复次数
      repeat_counts = N - rows_orig
      
      # 生成扩展后的data、行索引、列索引
      data = np.repeat(vals, repeat_counts)
      col_indices = np.repeat(cols_orig, repeat_counts)
      
      row_indices = []
      for idx, i in enumerate(rows_orig):
          row_indices.append(starts[i+1:N+1] + i)
      row_indices = np.concatenate(row_indices)
      
      return csc_array((data, (row_indices, col_indices)), shape=(starts[-1], M))
  

验证与手动示例一致 #

如果你只想生成和手动示例一样的前4个堆叠（前0、1、2、3行子矩阵），可以使用以下函数：

def df_to_cumulative_csc_partial(df, max_k):
    # max_k对应手动示例中的3（即堆叠前0到前max_k行的子矩阵）
    N = max_k + 1
    M = df.shape[1]
    starts = np.cumsum(np.arange(N))
    
    flat_vals = df.iloc[:max_k].values.flatten()
    repeat_counts = np.repeat(max_k - np.arange(max_k), M)
    data = np.repeat(flat_vals, repeat_counts)
    
    col_indices = np.repeat(np.tile(np.arange(M), max_k), repeat_counts)
    
    row_indices = []
    for i in range(max_k):
        row_indices.append(starts[i+1:N] + i)
    row_indices = np.concatenate(row_indices)
    
    # 手动示例中还包含了前0行的空矩阵，这里直接拼接空矩阵即可
    empty_csc = csc_array((0, M))
    partial_csc = csc_array((data, (row_indices, col_indices)), shape=(starts[-1], M))
    return csc_array(np.vstack([empty_csc.toarray(), partial_csc.toarray()]))

# 生成和手动示例完全一致的结果
cscArray_partial = df_to_cumulative_csc_partial(dataFrame, max_k=3)

内容的提问来源于stack exchange，提问作者CoolGuyHasChillDay