1235

我想从 Pandas DataFrame 中获取列标题列表。DataFrame 将来自用户输入，所以我不知道会有多少列或它们将被调用什么。

例如，如果给我一个这样的 DataFrame：

>>> my_dataframe
    y  gdp  cap
0   1    2    5
1   2    3    9
2   8    7    2
3   3    4    7
4   6    7    7
5   4    8    3
6   8    2    8
7   9    9   10
8   6    6    4
9  10   10    7

我会得到这样的列表：

>>> header_list
['y', 'gdp', 'cap']
4

19 回答 19

1902

您可以通过执行以下操作将值作为列表获取：

list(my_dataframe.columns.values)

您也可以简单地使用（如Ed Chum 的回答所示）：

list(my_dataframe)
于 2013-10-20T21:23:07.363 回答
481

有一个内置方法是性能最高的：

my_dataframe.columns.values.tolist()

.columns返回一个Index，.columns.values返回一个数组，这有一个帮助函数.tolist来返回一个列表。

如果性能对您来说不那么重要，Index对象定义一个.tolist()您可以直接调用的方法：

my_dataframe.columns.tolist()

性能差异很明显：

%timeit df.columns.tolist()
16.7 µs ± 317 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

%timeit df.columns.values.tolist()
1.24 µs ± 12.3 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)

对于那些讨厌打字的人，您可以调用list，df如下所示：

list(df)
于 2013-10-20T22:25:15.950 回答
103

我做了一些快速测试，不出所料，使用的内置版本dataframe.columns.values.tolist()是最快的：

In [1]: %timeit [column for column in df]
1000 loops, best of 3: 81.6 µs per loop

In [2]: %timeit df.columns.values.tolist()
10000 loops, best of 3: 16.1 µs per loop

In [3]: %timeit list(df)
10000 loops, best of 3: 44.9 µs per loop

In [4]: % timeit list(df.columns.values)
10000 loops, best of 3: 38.4 µs per loop

（虽然我仍然非常喜欢list(dataframe)，所以感谢 EdChum！）

于 2014-12-01T20:31:56.667 回答
61

它变得更加简单（通过 Pandas 0.16.0）：

df.columns.tolist()

会给你一个很好的列表中的列名。

于 2015-04-07T14:50:33.247 回答
49

扩展的可迭代解包（Python 3.5+）：[*df]和朋友

Python 3.5 引入了解包泛化 (PEP 448) 。因此，以下操作都是可能的。

df = pd.DataFrame('x', columns=['A', 'B', 'C'], index=range(5))
df

   A  B  C
0  x  x  x
1  x  x  x
2  x  x  x
3  x  x  x
4  x  x  x

如果你想要一个list......

[*df]
# ['A', 'B', 'C']

或者，如果你想要一个set，

{*df}
# {'A', 'B', 'C'}

或者，如果你想要一个tuple，

*df,  # Please note the trailing comma
# ('A', 'B', 'C')

或者，如果您想将结果存储在某处，

*cols, = df  # A wild comma appears, again
cols
# ['A', 'B', 'C']

...如果您是将咖啡转换为打字声音的那种人，那么这将更有效地消耗您的咖啡；）

PS：如果性能很重要，您将需要放弃上述解决方案以支持

df.columns.to_numpy().tolist()
# ['A', 'B', 'C']

这类似于Ed Chum 的答案，但更新为 v0.24，其中.to_numpy()首选使用.values. 有关更多信息，请参阅 此答案（由我提供）。

目视检查

由于我已经在其他答案中看到了这一点，因此您可以使用可迭代解包（不需要显式循环）。

print(*df)
A B C

print(*df, sep='\n')
A
B
C

对其他方法的批评

不要for对可以在一行中完成的操作使用显式循环（列表推导是可以的）。

接下来， usingsorted(df) 不会保留列的原始顺序。为此，您应该list(df)改用。

接下来是糟糕list(df.columns)的list(df.columns.values)建议（从当前版本开始，v0.24）。Index（从 返回df.columns）和 NumPy 数组（从 返回）都df.columns.values定义.tolist()了更快、更惯用的方法。

最后，listification ie,list(df)应该只作为上述 Python 3.4 或更早版本的方法的简洁替代方法，在扩展解包不可用的情况下。

于 2019-04-03T09:18:29.193 回答
41 
>>> list(my_dataframe)
['y', 'gdp', 'cap']

要在调试器模式下列出数据框的列，请使用列表推导：

>>> [c for c in my_dataframe]
['y', 'gdp', 'cap']

顺便说一句，您只需使用以下命令即可获得排序列表sorted：

>>> sorted(my_dataframe)
['cap', 'gdp', 'y']
于 2015-05-28T15:58:05.373 回答
27

可以作为my_dataframe.columns.

于 2013-10-20T21:20:06.947 回答
20

DataFrame遵循迭代对象的“键”的类似字典的约定。

my_dataframe.keys()

创建键/列列表 - 对象方法to_list()和 Pythonic 方式：

my_dataframe.keys().to_list()
list(my_dataframe.keys())

DataFrame 上的基本迭代返回列标签：

[column for column in my_dataframe]

不要将 DataFrame 转换为列表，只是为了获取列标签。在寻找方便的代码示例时不要停止思考。

xlarge = pd.DataFrame(np.arange(100000000).reshape(10000,10000))
list(xlarge) # Compute time and memory consumption depend on dataframe size - O(N)
list(xlarge.keys()) # Constant time operation - O(1)
于 2014-01-23T17:23:40.807 回答
20

这很有趣，但df.columns.values.tolist()几乎比 快三倍df.columns.tolist()，但我认为它们是相同的：

In [97]: %timeit df.columns.values.tolist()
100000 loops, best of 3: 2.97 µs per loop

In [98]: %timeit df.columns.tolist()
10000 loops, best of 3: 9.67 µs per loop
于 2015-12-04T21:41:53.610 回答
15

在笔记本中

对于IPython notebook 中的数据探索，我首选的方法是：

sorted(df)

这将产生一个易于阅读的按字母顺序排列的列表。

在代码存储库中

在代码中，我发现这样做更明确

df.columns

因为它告诉其他阅读你的代码的人你在做什么。

于 2016-03-30T07:19:35.183 回答
10 
%%timeit
final_df.columns.values.tolist()
948 ns ± 19.2 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)

%%timeit
list(final_df.columns)
14.2 µs ± 79.1 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

%%timeit
list(final_df.columns.values)
1.88 µs ± 11.7 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)

%%timeit
final_df.columns.tolist()
12.3 µs ± 27.4 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

%%timeit
list(final_df.head(1).columns)
163 µs ± 20.6 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)
于 2019-04-16T06:32:43.807 回答
4

正如Simeon Visser 回答的那样，你可以这样做

list(my_dataframe.columns.values)

或者

list(my_dataframe) # For less typing.

但我认为最甜蜜的地方是：

list(my_dataframe.columns)

它是明确的，同时也不是不必要的长。

于 2018-02-16T18:36:08.137 回答
4

为了快速、整洁、目视检查，试试这个：

for col in df.columns:
    print col
于 2018-08-22T16:17:27.837 回答
3

我觉得这个问题值得额外解释。

正如fixxxer 所指出的，答案取决于您在项目中使用的 Pandas 版本。您可以通过pd.__version__命令获得。

如果您出于某种原因像我一样（在Debian 8 (Jessie) 上使用 0.14.1）使用比 0.16.0 更旧的 Pandas 版本，那么您需要使用：

df.keys().tolist()因为还没有df.columns实现任何方法。

这种键方法的优点是它甚至可以在新版本的 Pandas 中使用，因此它更通用。

于 2017-12-13T14:47:36.183 回答
2 
n = []
for i in my_dataframe.columns:
    n.append(i)
print n
于 2013-10-20T21:43:30.913 回答
1

如果 DataFrame 恰好有一个 Index 或 MultiIndex 并且您希望它们也包含在列名中：

names = list(filter(None, df.index.names + df.columns.values.tolist()))

它避免了调用 reset_index() 对这样一个简单的操作有不必要的性能影响。

我经常需要这个，因为我正在从数据帧索引映射到主/唯一键的数据库中穿梭数据，但对我来说实际上只是另一个“列”。对于 pandas 来说，为这样的事情提供一个内置方法可能是有意义的（我完全有可能错过了它）。

于 2020-01-16T05:24:10.170 回答
0

尽管之前提供的解决方案很好，我也希望像 frame.column_names() 这样的东西在 Pandas 中是一个函数，但既然不是，也许使用以下语法会很好。它通过调用“tolist”函数以某种方式保留了您以正确方式使用熊猫的感觉：frame.columns.tolist()

frame.columns.tolist()
于 2019-02-14T10:58:42.717 回答
0

最简单的选择是： list(my_dataframe.columns)或my_dataframe.columns.tolist()

不需要上面复杂的东西:)

于 2022-01-19T01:02:30.873 回答
-1

listHeaders = [my_dataframe 中 colName 的 colName]

于 2021-10-27T22:35:11.890 回答