API · Pandas

Pandas DataFrame DataFrame.transpose()函数

Pandas DataFrame transpose()函数将 DataFrame 的行改为列,反之亦然。

本页内容

使用 DataFrame.transpose() 交换 pandas DataFrame 的行和列。返回的 DataFrame 会将原行标签用作列标签,并将原列标签用作行标签。本指南中的示例在 pandas 3.1 上运行,除了不带参数的调用之外,还介绍 T 快捷方式、数字与文本混合时数据类型受到的影响,以及转置结果与原数据共享内存的方式。

DataFrame.transpose() 的语法

在要转置的对象上调用此方法:df.transpose()。它会返回转置后的 DataFrame;原对象仍可通过 df 使用。

import pandas as pd

transposed = dataframe.transpose()

该方法的签名还接受 *args 和 copy 关键字,两者都是为兼容 NumPy API 和旧版 pandas 代码而保留的。在普通调用中两者都没有用处:pandas 不接受轴位置(传入后会发生什么见下文的错误部分),而且 pandas 3 已弃用 copy 关键字,因为写时复制(Copy-on-Write)已经决定了何时复制数据。

示例:使用 DataFrame.transpose() 转置 DataFrame

此示例创建一个小型表格,其中包含学生姓名、出勤情况和分数。调用该方法后,原来的每一列都会变成一行,原来的每个索引标签都会变成一列。

import pandas as pd

dataframe = pd.DataFrame(
    {
        "Attendance": [60, 100, 80, 78, 95],
        "Name": ["Olivia", "John", "Laura", "Ben", "Kevin"],
        "Obtained Marks": [90, 75, 82, 64, 45],
    }
)

transposed = dataframe.transpose()
print(transposed)

输出:

                     0     1      2    3      4
Attendance          60   100     80   78     95
Name            Olivia  John  Laura  Ben  Kevin
Obtained Marks      90    75     82   64     45

这些标签便于确认行列交换的方向:结果中的行标签为 Attendance、Name 和 Obtained Marks,列标签则为 0 到 4。

转置数据类型一致的 DataFrame

当每一列都包含整数时,输入数据的值类型一致。转置数据后,可以查看转置前后的列数据类型,了解此示例在你的 pandas 环境中的表示方式。

import pandas as pd

dataframe = pd.DataFrame(
    {
        "A": [6, 20, 80, 78, 95],
        "B": [60, 50, 7, 67, 54],
    }
)

transposed = dataframe.transpose()
print("Original values:")
print(dataframe)
print("Transposed values:")
print(transposed)
print("Original dtypes:")
print(dataframe.dtypes)
print("Transposed dtypes:")
print(transposed.dtypes)

输出:

Original values:
    A   B
0   6  60
1  20  50
2  80   7
3  78  67
4  95  54
Transposed values:
    0   1   2   3   4
A   6  20  80  78  95
B  60  50   7  67  54
Original dtypes:
A    int64
B    int64
dtype: object
Transposed dtypes:
0    int64
1    int64
2    int64
3    int64
4    int64
dtype: object

此输入有五行,标签为 0 到 4,以及两列 A 和 B,因此结果有两行和五列。由于每个输入列都包含整数,转置后的列保持 int64 数据类型:当 DataFrame 的所有列共享同一种数据类型时,转置后各列也会保持该类型。下一个示例将展示当各列类型不一致时会有什么变化。

转置数据类型混合的 DataFrame

DataFrame 的各列可以包含不同类型的数据。此例中,两列包含数字,另一列包含姓名。代码展示了操作前后的值和数据类型,便于你检查此输入对应的结果。

import pandas as pd

dataframe = pd.DataFrame(
    {
        "Attendance": [60, 100, 80, 78, 95],
        "Name": ["Olivia", "John", "Laura", "Ben", "Kevin"],
        "Obtained Marks": [90, 75, 82, 64, 45],
    }
)

transposed = dataframe.transpose()
print("Original values:")
print(dataframe)
print("Transposed values:")
print(transposed)
print("Original dtypes:")
print(dataframe.dtypes)
print("Transposed dtypes:")
print(transposed.dtypes)

输出:

Original values:
   Attendance    Name  Obtained Marks
0          60  Olivia              90
1         100    John              75
2          80   Laura              82
3          78     Ben              64
4          95   Kevin              45
Transposed values:
                     0     1      2    3      4
Attendance          60   100     80   78     95
Name            Olivia  John  Laura  Ben  Kevin
Obtained Marks      90    75     82   64     45
Original dtypes:
Attendance        int64
Name                str
Obtained Marks    int64
dtype: object
Transposed dtypes:
0    object
1    object
2    object
3    object
4    object
dtype: object

值本身原封不动地移动,但请比较数据类型:转置后的 DataFrame 中每一列的数据类型都是 object,包括那些只包含数字的列。现在每一列都组合了两个整数列和 Name 列的值,而 object 是唯一能同时容纳这些值的类型。数字仍然存在,只是以通用 Python 对象的形式存储,而不是 int64 值。

混合转置把数字变成对象时

这种数据类型的丢失不只是表面问题。现在,对整个转置后 DataFrame 的算术运算会触及 Name 行中存储的字符串并失败:

import pandas as pd

dataframe = pd.DataFrame(
    {
        "Attendance": [60, 100, 80, 78, 95],
        "Name": ["Olivia", "John", "Laura", "Ben", "Kevin"],
        "Obtained Marks": [90, 75, 82, 64, 45],
    }
)

transposed = dataframe.transpose()
print(transposed + 1)

输出:

TypeError: can only concatenate str (not "int") to str

再次转置可以恢复原来的布局,但不能恢复原来的数据类型:恢复后的 DataFrame 每一列仍为 object。要重新使用真正的数字,请用 astype() 转换那些应当是数字的行:

import pandas as pd

dataframe = pd.DataFrame(
    {
        "Attendance": [60, 100, 80, 78, 95],
        "Name": ["Olivia", "John", "Laura", "Ben", "Kevin"],
        "Obtained Marks": [90, 75, 82, 64, 45],
    }
)

transposed = dataframe.transpose()
restored = transposed.transpose()
print("Dtypes after transposing back:")
print(restored.dtypes)

numeric_rows = transposed.loc[["Attendance", "Obtained Marks"]].astype(int)
print("Dtypes of the recovered numeric rows:")
print(numeric_rows.dtypes)

输出:

Dtypes after transposing back:
Attendance        object
Name              object
Obtained Marks    object
dtype: object
Dtypes of the recovered numeric rows:
0    int64
1    int64
2    int64
3    int64
4    int64
dtype: object

这里的转换只选择两个数字行。如果把 Name 行也包含进来,astype(int) 会在姓名处失败,因此应将文本行排除在选择之外。

使用 T 快捷方式转置

T 属性是不带参数调用的快捷方式,返回相同的 DataFrame。对于非方阵的 DataFrame,从形状就能一眼看出交换结果:五行两列变成两行五列。转置两次会恢复原 DataFrame;对于这个类型一致的输入,equals() 证实往返之后值和数据类型都得以保留,这一点与上面的混合示例不同。

import pandas as pd

dataframe = pd.DataFrame(
    {
        "A": [6, 20, 80, 78, 95],
        "B": [60, 50, 7, 67, 54],
    }
)

print("Original shape:", dataframe.shape)
print("Transposed shape:", dataframe.T.shape)
print("T matches transpose():", dataframe.T.equals(dataframe.transpose()))
print("Transposing twice restores the original:", dataframe.T.T.equals(dataframe))

输出:

Original shape: (5, 2)
Transposed shape: (2, 5)
T matches transpose(): True
Transposing twice restores the original: True

转置后的 DataFrame 如何与原数据共享内存

转置后的 DataFrame 不是数据的独立副本。默认情况下,它是一个与原数据共享内存的视图,numpy.shares_memory() 可以证实这一点:

import numpy as np
import pandas as pd

dataframe = pd.DataFrame(
    {
        "A": [6, 20, 80, 78, 95],
        "B": [60, 50, 7, 67, 54],
    }
)

transposed = dataframe.transpose()
print("Shares memory with the original:", np.shares_memory(transposed, dataframe))

transposed.iloc[0, 0] = 999
print("Value in the transposed frame:", transposed.loc["A", 0])
print("Value in the original frame:", dataframe.loc[0, "A"])

输出:

Shares memory with the original: True
Value in the transposed frame: 999
Value in the original frame: 6

共享内存并不意味着修改会泄漏到原数据中。自 pandas 3.0 起始终启用的写时复制会在第一次写入时复制受影响的数据,因此上面的赋值只改变转置后的 DataFrame,原数据保持其值不变。如果需要从一开始就完全独立的 DataFrame,请对结果调用 .copy()。

错误与边界情况

签名中的 *args 容易让人沿用 NumPy 的习惯,但 pandas 始终交换 DataFrame 的两个轴,不接受任何轴排列:

import pandas as pd

dataframe = pd.DataFrame({"A": [1, 2], "B": [3, 4]})
print(dataframe.transpose(1))

输出:

ValueError: the 'axes' parameter is not supported in the pandas implementation of transpose()

像 (1, 0) 这样的元组也会以同样的 ValueError 失败。另一方面,退化的形状是有效输入,而不是错误:

import pandas as pd

empty = pd.DataFrame(columns=["A", "B"])
print("Original shape:", empty.shape)
print("Transposed shape:", empty.transpose().shape)

single_row = pd.DataFrame({"A": [1], "B": [2], "C": [3]})
print(single_row.transpose())

输出:

Original shape: (0, 2)
Transposed shape: (2, 0)
   0
A  1
B  2
C  3

一个有列但没有行的 DataFrame 会把形状 (0, 2) 换成 (2, 0);而单行 DataFrame 会变成只有一列,其索引为原来的列标签。