如何透视数据帧？

以下是我们可以用来枢轴的成语列表

1. pd.DataFrame.pivot_table

   • 具有更直观的 API 的美化版本。对于许多人来说，这是首选方法。这是开发人员的预期方法。groupby
   • 指定行级别、列级别、要聚合的值以及要执行聚合的函数。

2. PD的。DataFrame.groupby + pd。DataFrame.unstack

   • 适用于执行几乎任何类型的枢轴的良好通用方法
   • 指定将构成一个组中的透视行级别和列级别的所有列。然后，选择要聚合的剩余列和要执行聚合的函数。最后，您希望在列索引中显示级别。unstack

3. PD的。DataFrame.set_index + PD。DataFrame.unstack

   • 对某些人（包括我自己）来说既方便又直观。无法处理重复的分组键。
   • 与范式类似，我们指定所有最终将成为行或列级别的列，并将它们设置为索引。然后，我们在列中列出我们想要的级别。如果其余索引级别或列级别不唯一，则此方法将失败。groupbyunstack

4. pd.DataFrame.pivot

   • 非常相似的是，它共享重复密钥限制。API 也非常有限。它只接受 、 、 的标量值。set_indexindexcolumnsvalues
   • 与该方法类似，我们选择要透视的行、列和值。但是，我们无法聚合，如果行或列不唯一，则此方法将失败。pivot_table

5. pd.crosstab

   • 这是其最纯粹的特殊版本，是执行多项任务的最直观方式。pivot_table

6. pd.factorize + np.bincount

   • 这是一项非常先进的技术，非常晦涩难懂，但速度非常快。它不能在所有情况下使用，但当它可以使用并且你习惯使用它时，你将获得绩效奖励。

7. pd.get_dummies + PD。数据帧.dot

   • 我用它来巧妙地执行交叉表。

另请参阅：

• 重塑和数据透视表 — pandas 用户指南

第1项质询

为什么我会得到ValueError: Index contains duplicate entries, cannot reshape

发生这种情况的原因是 pandas 正在尝试使用重复条目重新索引 or 对象。可以使用多种方法来执行透视。其中一些不太适合要求它旋转的键有重复的情况。例如：考虑 .我知道有重复的条目共享 和 值：columnsindexpd.DataFrame.pivotrowcol

df.duplicated(['row', 'col']).any()

True

所以当我使用pivot

df.pivot(index='row', columns='col', values='val0')

我收到上面提到的错误。事实上，当我尝试执行相同的任务时，我会遇到同样的错误：

df.set_index(['row', 'col'])['val0'].unstack()

例子

对于每个后续问题，我要做的是使用 pd 来回答它。DataFrame.pivot_table。然后，我将提供执行相同任务的替代方法。

问题 2 和 3

如何进行透视，使值为列，值为索引，均值为值？dfcolrowval0

• pd.DataFrame.pivot_table

  df.pivot_table(
      values='val0', index='row', columns='col',
      aggfunc='mean')
  
  col   col0   col1   col2   col3  col4
  row                                  
  row0  0.77  0.605    NaN  0.860  0.65
  row2  0.13    NaN  0.395  0.500  0.25
  row3   NaN  0.310    NaN  0.545   NaN
  row4   NaN  0.100  0.395  0.760  0.24
  

  • aggfunc='mean'是默认值，我不必设置它。我把它包括在内是为了明确。

如何使缺失值为 0？

• pd.DataFrame.pivot_table

  • fill_value默认情况下未设置。我倾向于适当地设置它。在本例中，我将其设置为 .0

  df.pivot_table(
      values='val0', index='row', columns='col',
      fill_value=0, aggfunc='mean')
  
  col   col0   col1   col2   col3  col4
  row
  row0  0.77  0.605  0.000  0.860  0.65
  row2  0.13  0.000  0.395  0.500  0.25
  row3  0.00  0.310  0.000  0.545  0.00
  row4  0.00  0.100  0.395  0.760  0.24
  

• pd.DataFrame.groupby

  df.groupby(['row', 'col'])['val0'].mean().unstack(fill_value=0)
  

• pd.crosstab

  pd.crosstab(
      index=df['row'], columns=df['col'],
      values=df['val0'], aggfunc='mean').fillna(0)
  

第4项质询

我能得到别的东西吗，比如也许？meansum

• pd.DataFrame.pivot_table

  df.pivot_table(
      values='val0', index='row', columns='col',
      fill_value=0, aggfunc='sum')
  
  col   col0  col1  col2  col3  col4
  row
  row0  0.77  1.21  0.00  0.86  0.65
  row2  0.13  0.00  0.79  0.50  0.50
  row3  0.00  0.31  0.00  1.09  0.00
  row4  0.00  0.10  0.79  1.52  0.24
  

• pd.DataFrame.groupby

  df.groupby(['row', 'col'])['val0'].sum().unstack(fill_value=0)
  

• pd.crosstab

  pd.crosstab(
      index=df['row'], columns=df['col'],
      values=df['val0'], aggfunc='sum').fillna(0)
  

第5项质询

我可以一次执行更多聚合吗？

请注意，for 和 我需要传递可调用对象列表。另一方面，能够为有限数量的特殊函数获取字符串。 也会采用我们传递给其他人的相同可调用对象，但利用字符串函数名称通常更有效，因为可以提高效率。pivot_tablecrosstabgroupby.agggroupby.agg

• pd.DataFrame.pivot_table

  df.pivot_table(
      values='val0', index='row', columns='col',
      fill_value=0, aggfunc=[np.size, np.mean])
  
       size                      mean
  col  col0 col1 col2 col3 col4  col0   col1   col2   col3  col4
  row
  row0    1    2    0    1    1  0.77  0.605  0.000  0.860  0.65
  row2    1    0    2    1    2  0.13  0.000  0.395  0.500  0.25
  row3    0    1    0    2    0  0.00  0.310  0.000  0.545  0.00
  row4    0    1    2    2    1  0.00  0.100  0.395  0.760  0.24
  

• pd.DataFrame.groupby

  df.groupby(['row', 'col'])['val0'].agg(['size', 'mean']).unstack(fill_value=0)
  

• pd.crosstab

  pd.crosstab(
      index=df['row'], columns=df['col'],
      values=df['val0'], aggfunc=[np.size, np.mean]).fillna(0, downcast='infer')
  

第6项质询

是否可以跨多个值列进行聚合？

• PD的。DataFrame.pivot_table我们通过了，但我们本可以完全不这样做values=['val0', 'val1']

  df.pivot_table(
      values=['val0', 'val1'], index='row', columns='col',
      fill_value=0, aggfunc='mean')
  
        val0                             val1
  col   col0   col1   col2   col3  col4  col0   col1  col2   col3  col4
  row
  row0  0.77  0.605  0.000  0.860  0.65  0.01  0.745  0.00  0.010  0.02
  row2  0.13  0.000  0.395  0.500  0.25  0.45  0.000  0.34  0.440  0.79
  row3  0.00  0.310  0.000  0.545  0.00  0.00  0.230  0.00  0.075  0.00
  row4  0.00  0.100  0.395  0.760  0.24  0.00  0.070  0.42  0.300  0.46
  

• pd.DataFrame.groupby

  df.groupby(['row', 'col'])['val0', 'val1'].mean().unstack(fill_value=0)
  

第7项质询

我可以按多列细分吗？

• pd.DataFrame.pivot_table

  df.pivot_table(
      values='val0', index='row', columns=['item', 'col'],
      fill_value=0, aggfunc='mean')
  
  item item0             item1                         item2
  col   col2  col3  col4  col0  col1  col2  col3  col4  col0   col1  col3  col4
  row
  row0  0.00  0.00  0.00  0.77  0.00  0.00  0.00  0.00  0.00  0.605  0.86  0.65
  row2  0.35  0.00  0.37  0.00  0.00  0.44  0.00  0.00  0.13  0.000  0.50  0.13
  row3  0.00  0.00  0.00  0.00  0.31  0.00  0.81  0.00  0.00  0.000  0.28  0.00
  row4  0.15  0.64  0.00  0.00  0.10  0.64  0.88  0.24  0.00  0.000  0.00  0.00
  

• pd.DataFrame.groupby

  df.groupby(
      ['row', 'item', 'col']
  )['val0'].mean().unstack(['item', 'col']).fillna(0).sort_index(1)
  

第8项质询

我可以按多列细分吗？

• pd.DataFrame.pivot_table

  df.pivot_table(
      values='val0', index=['key', 'row'], columns=['item', 'col'],
      fill_value=0, aggfunc='mean')
  
  item      item0             item1                         item2
  col        col2  col3  col4  col0  col1  col2  col3  col4  col0  col1  col3  col4
  key  row
  key0 row0  0.00  0.00  0.00  0.00  0.00  0.00  0.00  0.00  0.00  0.00  0.86  0.00
       row2  0.00  0.00  0.37  0.00  0.00  0.00  0.00  0.00  0.00  0.00  0.50  0.00
       row3  0.00  0.00  0.00  0.00  0.31  0.00  0.81  0.00  0.00  0.00  0.00  0.00
       row4  0.15  0.64  0.00  0.00  0.00  0.00  0.00  0.24  0.00  0.00  0.00  0.00
  key1 row0  0.00  0.00  0.00  0.77  0.00  0.00  0.00  0.00  0.00  0.81  0.00  0.65
       row2  0.35  0.00  0.00  0.00  0.00  0.44  0.00  0.00  0.00  0.00  0.00  0.13
       row3  0.00  0.00  0.00  0.00  0.00  0.00  0.00  0.00  0.00  0.00  0.28  0.00
       row4  0.00  0.00  0.00  0.00  0.10  0.00  0.00  0.00  0.00  0.00  0.00  0.00
  key2 row0  0.00  0.00  0.00  0.00  0.00  0.00  0.00  0.00  0.00  0.40  0.00  0.00
       row2  0.00  0.00  0.00  0.00  0.00  0.00  0.00  0.00  0.13  0.00  0.00  0.00
       row4  0.00  0.00  0.00  0.00  0.00  0.64  0.88  0.00  0.00  0.00  0.00  0.00
  

• pd.DataFrame.groupby

  df.groupby(
      ['key', 'row', 'item', 'col']
  )['val0'].mean().unstack(['item', 'col']).fillna(0).sort_index(1)
  

• PD的。DataFrame.set_index，因为键集对于行和列都是唯一的

  df.set_index(
      ['key', 'row', 'item', 'col']
  )['val0'].unstack(['item', 'col']).fillna(0).sort_index(1)
  

第9项质询

我可以聚合列和行一起出现的频率，即“交叉制表”吗？

• pd.DataFrame.pivot_table

  df.pivot_table(index='row', columns='col', fill_value=0, aggfunc='size')
  
  col   col0  col1  col2  col3  col4
  row
  row0     1     2     0     1     1
  row2     1     0     2     1     2
  row3     0     1     0     2     0
  row4     0     1     2     2     1
  

• pd.DataFrame.groupby

  df.groupby(['row', 'col'])['val0'].size().unstack(fill_value=0)
  

• pd.crosstab

  pd.crosstab(df['row'], df['col'])
  

• pd.factorize + np.bincount

  # get integer factorization `i` and unique values `r`
  # for column `'row'`
  i, r = pd.factorize(df['row'].values)
  # get integer factorization `j` and unique values `c`
  # for column `'col'`
  j, c = pd.factorize(df['col'].values)
  # `n` will be the number of rows
  # `m` will be the number of columns
  n, m = r.size, c.size
  # `i * m + j` is a clever way of counting the
  # factorization bins assuming a flat array of length
  # `n * m`.  Which is why we subsequently reshape as `(n, m)`
  b = np.bincount(i * m + j, minlength=n * m).reshape(n, m)
  # BTW, whenever I read this, I think 'Bean, Rice, and Cheese'
  pd.DataFrame(b, r, c)
  
        col3  col2  col0  col1  col4
  row3     2     0     0     1     0
  row2     1     2     1     0     2
  row0     1     0     1     2     1
  row4     2     2     0     1     1
  

• pd.get_dummies

  pd.get_dummies(df['row']).T.dot(pd.get_dummies(df['col']))
  
        col0  col1  col2  col3  col4
  row0     1     2     0     1     1
  row2     1     0     2     1     2
  row3     0     1     0     2     0
  row4     0     1     2     2     1
  

第10项质询

如何通过仅对两个 DataFrame 进行透视将 DataFrame 从长到宽 列？

• DataFrame.pivot

  第一步是为每行分配一个数字 - 该数字将是透视结果中该值的行索引。这是使用 GroupBy.cumcount 完成的：

  df2.insert(0, 'count', df2.groupby('A').cumcount())
  df2
  
     count  A   B
  0      0  a   0
  1      1  a  11
  2      2  a   2
  3      3  a  11
  4      0  b  10
  5      1  b  10
  6      2  b  14
  7      0  c   7
  

  第二步是使用新创建的列作为索引来调用 DataFrame.pivot。

  df2.pivot(*df2)
  # df2.pivot(index='count', columns='A', values='B')
  
  A         a     b    c
  count
  0       0.0  10.0  7.0
  1      11.0  10.0  NaN
  2       2.0  14.0  NaN
  3      11.0   NaN  NaN
  

• DataFrame.pivot_table

  DataFrame.pivot 只接受列，DataFrame.pivot_table 也接受数组，因此可以直接作为 传递，而无需创建显式列。GroupBy.cumcountindex

  df2.pivot_table(index=df2.groupby('A').cumcount(), columns='A', values='B')
  
  A         a     b    c
  0       0.0  10.0  7.0
  1      11.0  10.0  NaN
  2       2.0  14.0  NaN
  3      11.0   NaN  NaN
  

第11项质询

如何在之后将多个索引展平为单个索引pivot

如果键入字符串columnsobjectjoin

df.columns = df.columns.map('|'.join)

还format

df.columns = df.columns.map('{0[0]}|{0[1]}'.format)

扩展@piRSquared的回答 问题 10 的另一个版本

问题10.1

数据帧：

d = data = {'A': {0: 1, 1: 1, 2: 1, 3: 2, 4: 2, 5: 3, 6: 5},
 'B': {0: 'a', 1: 'b', 2: 'c', 3: 'a', 4: 'b', 5: 'a', 6: 'c'}}
df = pd.DataFrame(d)

   A  B
0  1  a
1  1  b
2  1  c
3  2  a
4  2  b
5  3  a
6  5  c

输出：

   0     1     2
A
1  a     b     c
2  a     b  None
3  a  None  None
5  c  None  None

使用 df.groupby 和 pd.Series.tolist（系列.tolist）

t = df.groupby('A')['B'].apply(list)
out = pd.DataFrame(t.tolist(),index=t.index)
out
   0     1     2
A
1  a     b     c
2  a     b  None
3  a  None  None
5  c  None  None

或 使用带有 df.squeeze 的 pd.pivot_table 是一个更好的选择。

t = df.pivot_table(index='A',values='B',aggfunc=list).squeeze()
out = pd.DataFrame(t.tolist(),index=t.index)

为了更好地理解函数透视的工作原理，您可以查看 Pandas 文档中的示例。但是，如果您有重复的索引列 （-） 组合（如第二个示例中所示），则会失败：pivotfoobardf

与函数相反，pivot_table默认支持使用该函数进行数据聚合。下面是聚合函数的示例：pivotmeansum

致电（连同reset_index()add_suffix())

通常，在您调用或 之后需要。例如，要进行以下转换（其中一列成为列名）reset_index()pivot_tablepivot

使用以下代码，其中 之后，将前缀添加到新创建的列名称，并将索引（在本例中）转换回列，并删除轴名称的名称：pivot"movies"

df.pivot(index='movie', columns='week', values='sales').add_prefix('week_').reset_index().rename_axis(columns=None)

正如其他答案所提到的，“枢轴”可能是指 2 种不同的操作：

1. 非堆叠聚合（即使结果更宽。groupby.agg
2. 重塑（类似于 Excel、numpy 或 R 中的透视）reshapepivot_wider

1. 聚合

pivot_table或者只是未堆叠的操作结果。事实上，源代码表明，在引擎盖下，以下情况是正确的：crosstabgroupby.agg

• pivot_table = groupby + unstack (阅读此处了解更多信息。
• crosstab = pivot_table

注意您可以将列名列表用作 和参数。indexcolumnsvalues

df.groupby(rows+cols)[vals].agg(aggfuncs).unstack(cols)
# equivalently,
df.pivot_table(vals, rows, cols, aggfuncs)

1.1. 是 的特例 ;因此crosstabpivot_tablegroupby + unstack

以下是等效的：

• pd.crosstab(df['colA'], df['colB'])
• df.pivot_table(index='colA', columns='colB', aggfunc='size', fill_value=0)
• df.groupby(['colA', 'colB']).size().unstack(fill_value=0)

请注意，它的开销要大得多，因此它比 和 + 都慢得多。事实上，正如这里所指出的，也比 + 慢。pd.crosstabpivot_tablegroupbyunstackpivot_tablegroupbyunstack

2. 重塑

pivot是一个更有限的版本，其目的是将长数据帧重塑为长数据帧。pivot_table

df.set_index(rows+cols)[vals].unstack(cols)
# equivalently, 
df.pivot(index=rows, columns=cols, values=vals)

2.1. 如问题 10 所示增加行/列

您还可以将问题 10 中的见解应用于多列透视操作。有两种情况：

• “多头对多头”：通过增强指数进行重塑

  

  法典：

  df = pd.DataFrame({'A': [1, 1, 1, 2, 2, 2], 'B': [*'xxyyzz'], 
                     'C': [*'CCDCDD'], 'E': [100, 200, 300, 400, 500, 600]})
  rows, cols, vals = ['A', 'B'], ['C'], 'E'
  
  # using pivot syntax
  df1 = (
      df.assign(ix=df.groupby(rows+cols).cumcount())
      .pivot(index=[*rows, 'ix'], columns=cols, values=vals)
      .fillna(0, downcast='infer')
      .droplevel(-1).reset_index().rename_axis(columns=None)
  )
  
  # equivalently, using set_index + unstack syntax
  df1 = (
      df
      .set_index([*rows, df.groupby(rows+cols).cumcount(), *cols])[vals]
      .unstack(fill_value=0)
      .droplevel(-1).reset_index().rename_axis(columns=None)
  )
  

• “long-to-wide”：通过增加列来重塑形状

  

  法典：

  df1 = (
      df.assign(ix=df.groupby(rows+cols).cumcount())
      .pivot(index=rows, columns=[*cols, 'ix'])[vals]
      .fillna(0, downcast='infer')
  )
  df1 = df1.set_axis([f"{c[0]}_{c[1]}" for c in df1], axis=1).reset_index()
  
  # equivalently, using the set_index + unstack syntax
  df1 = (
      df
      .set_index([*rows, df.groupby(rows+cols).cumcount(), *cols])[vals]
      .unstack([-1, *range(-2, -len(cols)-2, -1)], fill_value=0)
  )
  df1 = df1.set_axis([f"{c[0]}_{c[1]}" for c in df1], axis=1).reset_index()
  

• 使用 + 语法的最小大小写：set_indexunstack

  

  法典：

  df1 = df.set_index(['A', df.groupby('A').cumcount()])['E'].unstack(fill_value=0).add_prefix('Col').reset_index()
  

pv_1 = df.pivot_table(index=rows, columns=cols, values=vals, aggfunc=aggfuncs, fill_value=0)
# internal operation of `pivot_table()`
gb_1 = df.groupby(rows+cols)[vals].agg(aggfuncs).unstack(cols).fillna(0, downcast="infer")
pv_1.equals(gb_1) # True

pandas 中的 pivot 函数与 excel 中的 pivot 操作具有相同的功能。我们可以将数据集从长格式转换为宽格式。

让我们举个例子

我们希望将数据集转换为一种形式，使每个国家/地区成为一列，并将新的确诊病例作为与国家/地区对应的值。我们可以使用 pivot 函数执行此数据操作。

透视数据集

pivot_df = pd.pivot(df, index =['Date'], columns ='Country', values =['NewConfirmed'])
## renaming the columns  
pivot_df.columns = df['Country'].sort_values().unique()

我们可以通过重置索引将新列置于与索引列 Data 相同的级别。

重置索引以修改列级别

pivot_df = pivot_df.reset_index（）