如何旋转数据框？

我们从回答第一个问题开始：

问题 1

为什么我会收到 ValueError：索引包含重复的条目，无法重塑

发生这种情况是因为 pandas 试图重新索引具有重复条目的 columns 或 index 对象。可以使用多种方法来执行数据透视。其中一些不太适合当要求其旋转的键存在重复项时。例如。考虑 pd.DataFrame.pivot。我知道有共享 row 和 col 值的重复条目：

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

True

所以当我pivot使用

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

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

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

以下是我们可以用来旋转的习语列表

pd.DataFrame.groupby + pd.DataFrame.unstack 进行几乎任何类型的枢轴的良好通用方法您指定将构成枢轴的行级别和列级别的所有列在一个 group by 中。您可以通过选择要聚合的剩余列和要执行聚合的函数来遵循这一点。最后，您取消堆叠您希望在列索引中的级别。 pd.DataFrame.pivot_table groupby 的美化版本，具有更直观的 API。对于许多人来说，这是首选方法。并且是开发人员的预期方法。指定行级别、列级别、要聚合的值以及执行聚合的函数。 pd.DataFrame.set_index + pd.DataFrame.unstack 对某些人来说方便直观（包括我自己）。无法处理重复的分组键。与 groupby 范例类似，我们指定最终将是行或列级别的所有列，并将它们设置为索引。然后我们在列中取消堆叠我们想要的级别。如果剩余的索引级别或列级别不是唯一的，则此方法将失败。 pd.DataFrame.pivot 与 set_index 非常相似，因为它共享重复键限制。 API 也非常有限。它只需要索引、列、值的标量值。类似于 pivot_table 方法，我们选择要旋转的行、列和值。但是，我们无法聚合，如果行或列不是唯一的，则此方法将失败。 pd.crosstab 这是 pivot_table 的一个特殊版本，其最纯粹的形式是执行多项任务的最直观的方式。 pd.factorize + np.bincount 这是一种非常先进的技术，非常晦涩但速度非常快。它不能在所有情况下都使用，但是当它可以使用并且您使用它时，您将获得性能奖励。 pd.get_dummies + pd.DataFrame.dot 我用它来巧妙地执行交叉制表。

例子

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

问题 3

如何旋转 df 使得 col 值是列，行值是索引，val0 的平均值是值，缺失值是 0？

pd.DataFrame.pivot_table fill_value 默认情况下未设置。我倾向于适当地设置它。在这种情况下，我将其设置为 0。请注意，我跳过了问题 2，因为它与此答案相同，但没有 fill_value aggfunc='mean' 是默认值，我不必设置它。我包括它是明确的。 df.pivot_table（values='val0'，index='row'，columns='col'，fill_value=0，aggfunc='mean'）col col0 col1 col2 col3 col4 row0 0.77 0.605 0.000 0.860 0.65 row2 0.13 0.000 0.395 0.500 0.25 行3 0.00 0.310 0.000 0.545 0.00 行4 0.00 0.100 0.395 0.760 0.24

fill_value 默认情况下未设置。我倾向于适当地设置它。在这种情况下，我将其设置为 0。请注意，我跳过了问题 2，因为它与没有 fill_value 的此答案相同

aggfunc='mean' 是默认值，我不必设置它。我包括它是明确的。 df.pivot_table（values='val0'，index='row'，columns='col'，fill_value=0，aggfunc='mean'）col col0 col1 col2 col3 col4 row0 0.77 0.605 0.000 0.860 0.65 row2 0.13 0.000 0.395 0.500 0.25 行3 0.00 0.310 0.000 0.545 0.00 行4 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

我能得到比平均值以外的东西，比如总和吗？

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第2行 0.13 0.00 0.79 0.50 0.50 第3行 0.00 0.31 0.00 1.09 0.00 第4行 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

我可以一次做多个聚合吗？

请注意，对于 pivot_table 和 crosstab，我需要传递可调用对象列表。另一方面，groupby.agg 能够为有限数量的特殊函数获取字符串。 groupby.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='推断')

问题 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 行3 0.00 0.310 0.000 0.545 0.00 0.00 0.230 0.00 0.075 0.00 行4 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第 4 行 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 行 4 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 row0 1 2 0 1 1 row2 1 0 2 1 2第 3 行 0 1 0 2 0 第 4 行 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 # 获取整数分解 `i` 和唯一值 `r` # 列 `'row'` i, r = pd.factorize(df['row'].values) # 获取整数分解 ` j` 和唯一值 `c` # 对于列 `'col'` j, c = pd.factorize(df['col'].values) # `n` 将是行数 # `m` 将是列数 n, m = r.size, c.size # `i * m + j` 是一种巧妙的方法来计算 # 因式分解箱，假设长度为扁平数组 # `n * m`。这就是为什么我们随后将整形为 `(n, m)` b = np.bincount(i * m + j, minlength=n * m).reshape(n, m) # 顺便说一句，每当我读到这篇文章时，我认为'豆、米和奶酪的 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 行 4 0 1 2 2 1

问题 10

如何通过仅旋转两列将 DataFrame 从长转换为宽？

DataFrame.pivot 第一步是为每一行分配一个数字——这个数字将是该值在透视结果中的行索引。这是使用 GroupBy.cumcount 完成的： df2.insert(0, 'count', df2.groupby('A').cumcount()) df2 count AB 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 abc 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.cumcount 可以直接作为索引传递，而无需创建显式列。 df2.pivot_table(index=df2.groupby('A').cumcount(), columns='A', values='B') A abc 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

透视后如何将多个索引展平为单个索引

如果 columns 输入带有字符串 join 的 object

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

否则format

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

---

扩展 @piRSquared's answer 另一个版本的 Question 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

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

或者将 pd.pivot_table 与 df.squeeze. 结合使用的更好选择

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

---

为了更好地理解 pivot 的工作原理，您可以查看 Pandas 文档中的 example：

https://i.stack.imgur.com/GPsB5.png

df = pd.DataFrame({
    'foo': ['one', 'one', 'one', 'two', 'two', 'two'],
    'bar': ['A', 'B', 'C', 'A', 'B', 'C'],
    'baz': [1, 2, 3, 4, 5, 6],
    'zoo': ['x', 'y', 'z', 'q', 'w', 't']
})

输入表：

   foo bar  baz zoo
0  one   A    1   x
1  one   B    2   y
2  one   C    3   z
3  two   A    4   q
4  two   B    5   w
5  two   C    6   t

枢：

pd.pivot(
    data=df,        
    index='foo',    # Column to use to make new frame’s index. If None, uses existing index.
    columns='bar',  # Column to use to make new frame’s columns.
    values='baz'    # Column(s) to use for populating new frame’s values.
)

输出表：

bar  A  B  C
foo         
one  1  2  3
two  4  5  6

---

您可以使用列名列表作为 index、columns 和 values 参数。

rows, cols, vals, aggfuncs = ['row', 'key'], ['col', 'item'], ['val0', 'val1'], ['mean', 'sum']

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


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

您也可以将问题 10 中的见解应用到多列透视操作。只需将辅助索引从 groupby().cumcount() 附加到 rows 或 cols，具体取决于您希望结果如何（将其附加到 rows 使结果“长”，并将其附加到 cols 使其“宽的”）。此外，调用 droplevel().reset_index() 修复了多余和重复索引问题。

# for "long" result
df.assign(ix=df.groupby(rows+cols).cumcount()).pivot(rows+['ix'], cols, vals).droplevel(-1).reset_index()

# for "wide" result
df.assign(ix=df.groupby(rows+cols).cumcount()).pivot(rows, cols+['ix'], vals).droplevel(-1, axis=1).reset_index()

例如，以下内容不起作用。

df = pd.DataFrame({'A': [1, 1, 2], 'B': ['a', 'a', 'b'], 'C': range(3)})
df.pivot('A','B','C')

但以下工作：

# long
(
    df.assign(ix=df.groupby(['A','B']).cumcount())
    .pivot(['A','ix'], 'B', 'C')
    .droplevel(-1).reset_index()
)

B  A    a    b
0  1  0.0  NaN
1  1  1.0  NaN
2  2  NaN  2.0



# wide
(
    df.assign(ix=df.groupby(['A','B']).cumcount())
    .pivot('A', ['B', 'ix'], 'C')
    .droplevel(-1, axis=1).reset_index()
)

B  A    a    a    b
0  1  0.0  1.0  NaN
1  2  NaN  NaN  2.0

pivot_table() 和 aggfunc 会产生聚合数据，这与 groupby.agg() 非常相似。 pivot() 只是简单地整形和/或堆叠数据（让人联想到 numpy 的 reshape 和 stack 方法），因此很自然地，它与它们的 pandas 表亲 unstack() 和 stack() 有关。

事实上，如果我们检查 source code，在内部，每个方法对都是相同的。

pivot_table = groupby + unstack pivot = set_index + unstack crosstab = pivot_table

使用 OP 中的设置：

from numpy.core.defchararray import add
np.random.seed([3,1415])
n = 20

cols = np.array(['key', 'row', 'item', 'col'])
arr1 = (np.random.randint(5, size=(n, 4)) // [2, 1, 2, 1]).astype(str)

df = pd.DataFrame(add(cols, arr1), columns=cols).join(pd.DataFrame(np.random.rand(n, 2).round(2)).add_prefix('val'))

rows, cols, vals, aggfuncs = ['row', 'key'], ['col', 'val1'], ['val0'], ['mean', 'sum']

pivot_table() 聚合值并将其取消堆叠。具体来说，它从索引和列中创建一个单一的平面列表，调用 groupby() 将此列表作为分组器，并使用传递的聚合器方法进行聚合（默认为均值）。然后在聚合之后，它通过列列表调用 unstack()。所以在内部，pivot_table = groupby + unstack。此外，如果通过了 fill_value，则会调用 fillna()。换句话说，生成 pv_1 的方法与下面示例中生成 gb_1 的方法相同。

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

pivot() 从作为索引和列传递的列值创建一个 MultiIndex，构建一个 MultiIndex DataFrame 并通过列列表调用 unstack()。所以在内部，pivot = set_index + unstack。换句话说，以下所有内容都是正确的：

# if the entire df needs to be pivoted
pv_2 = df.pivot(index=rows, columns=cols)
# internal operation of `pivot()`
su_2 = df.set_index(rows+cols).unstack(cols)
pv_2.equals(su_2) # True

# if only subset of df.columns need to be considered for pivot, specify so
pv_3 = df.pivot(index=rows, columns=cols, values=vals)
su_3 = df.set_index(rows+cols)[vals].unstack(cols)
pv_3.equals(su_3) # True

# this is the precise method used internally (building a new DF seems to be faster than set_index of an existing one)
pv_4 = df.pivot(index=rows, columns=cols, values=vals)
su_4 = pd.DataFrame(df[vals].values, index=pd.MultiIndex.from_arrays([df[c] for c in rows+cols]), columns=vals).unstack(cols)
pv_4.equals(su_4) # True

crosstab() 调用pivot_table()，即crosstab = pivot_table。具体来说，它从传递的值数组中构建一个 DataFrame，通过公共索引过滤它并调用 pivot_table()。它比 pivot_table() 更受限制，因为它只允许像一维数组一样作为值，不像可以将多列作为值的 pivot_table()。换句话说，以下是正确的。

indexes, columns, values = [df[r] for r in rows], [df[c] for c in cols], next(df[v] for v in vals)
# crosstab
ct_5 = pd.crosstab(indexes, columns, values, aggfunc=aggfuncs)
# internal operation (abbreviated)
from functools import reduce
data = pd.DataFrame({f'row_{i}': r for i, r in enumerate(indexes)} | {f'col_{i}': c for i, c in enumerate(columns)} | {'v': values}, 
                    index = reduce(lambda x, y: x.intersection(y.index), indexes[1:]+columns, indexes[0].index)
                   )
pv_5 = data.pivot_table('v', [k for k in data if k[:4]=='row_'], [k for k in data if k[:4]=='col_'], aggfuncs)
ct_5.equals(pv_5) # True

---