maxframe.dataframe.DataFrame.stack#

DataFrame.stack(level=-1, dropna=True)#

将指定层级从列轴堆叠到索引轴。

返回一个重塑后的 DataFrame 或 Series，其多级索引相对于当前 DataFrame 具有一个或多个新的最内层级别。这些新的最内层级别是通过对当前 dataframe 的列进行透视操作创建的：

如果列只有一个层级，则输出为 Series；

如果列具有多个层级，则新索引层级来自指定的层级，且输出为 DataFrame。

参数:

level (int, str, list, default -1) -- 要从列轴堆叠到索引轴的层级，定义为一个索引或标签，或索引或标签的列表。
dropna (bool, default True) -- 是否删除结果 Frame/Series 中包含缺失值的行。将列层级堆叠到索引轴可能会产生在原始 dataframe 中缺失的索引和列值组合。参见示例部分。

返回:

堆叠后的 dataframe 或 series。

返回类型:

DataFrame or Series

参见

DataFrame.unstack: 将指定层级从索引轴展开到列轴。
DataFrame.pivot: 将 dataframe 从长格式重塑为宽格式。
DataFrame.pivot_table: 创建一个类似电子表格的透视表作为 DataFrame。

备注

该函数的命名是类比于一组书籍从水平并排的位置（dataframe 的列）重新组织成垂直堆叠在一起（dataframe 的索引中）。

示例

单层列

>>> import maxframe.dataframe as md
>>> df_single_level_cols = md.DataFrame([[0, 1], [2, 3]],
...                                     index=['cat', 'dog'],
...                                     columns=['weight', 'height'])

对具有单层列轴的 dataframe 进行堆叠操作将返回一个 Series：

>>> df_single_level_cols.execute()
     weight height
cat       0      1
dog       2      3
>>> df_single_level_cols.stack().execute()
cat  weight    0
     height    1
dog  weight    2
     height    3
dtype: int64

多层列：简单情况

>>> multicol1 = pd.MultiIndex.from_tuples([('weight', 'kg'),
...                                        ('weight', 'pounds')])
>>> df_multi_level_cols1 = md.DataFrame([[1, 2], [2, 4]],
...                                     index=['cat', 'dog'],
...                                     columns=multicol1)

对具有多层级列轴的 dataframe 进行堆叠操作：

>>> df_multi_level_cols1.execute()
     weight
         kg    pounds
cat       1        2
dog       2        4
>>> df_multi_level_cols1.stack().execute()
            weight
cat kg           1
    pounds       2
dog kg           2
    pounds       4

缺失值

>>> multicol2 = pd.MultiIndex.from_tuples([('weight', 'kg'),
...                                        ('height', 'm')])
>>> df_multi_level_cols2 = md.DataFrame([[1.0, 2.0], [3.0, 4.0]],
...                                     index=['cat', 'dog'],
...                                     columns=multicol2)

在对具有多层级列的 dataframe 进行堆叠时，通常会出现缺失值，因为堆叠后的 dataframe 通常比原始 dataframe 包含更多的值。缺失值将用 NaN 填充：

>>> df_multi_level_cols2.execute()
    weight height
        kg      m
cat    1.0    2.0
dog    3.0    4.0
>>> df_multi_level_cols2.stack().execute()
        height  weight
cat kg     NaN     1.0
    m      2.0     NaN
dog kg     NaN     3.0
    m      4.0     NaN

指定要堆叠的层级

第一个参数控制要堆叠的层级：

>>> df_multi_level_cols2.stack(0).execute()
             kg    m
cat height  NaN  2.0
    weight  1.0  NaN
dog height  NaN  4.0
    weight  3.0  NaN
>>> df_multi_level_cols2.stack([0, 1]).execute()
cat  height  m     2.0
     weight  kg    1.0
dog  height  m     4.0
     weight  kg    3.0
dtype: float64

删除缺失值

>>> df_multi_level_cols3 = md.DataFrame([[None, 1.0], [2.0, 3.0]],
...                                     index=['cat', 'dog'],
...                                     columns=multicol2)

请注意，默认情况下所有值都缺失的行会被删除，但此行为可以通过 dropna 关键字参数来控制：

>>> df_multi_level_cols3.execute()
    weight height
        kg      m
cat    NaN    1.0
dog    2.0    3.0
>>> df_multi_level_cols3.stack(dropna=False).execute()
        height  weight
cat kg     NaN     NaN
    m      1.0     NaN
dog kg     NaN     2.0
    m      3.0     NaN
>>> df_multi_level_cols3.stack(dropna=True).execute()
        height  weight
cat m      1.0     NaN
dog kg     NaN     2.0
    m      3.0     NaN