它可以作为my_datafframe。columns。

你可以通过以下方式获取值:

list(my_dataframe.columns.values)

你也可以简单地使用(如Ed Chum的回答所示):

list(my_dataframe)

n = []
for i in my_dataframe.columns:
    n.append(i)
print n

有一个内置的方法是性能最好的:

my_dataframe.columns.values.tolist()

.columns返回一个索引，.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)

对于那些讨厌打字的人，你可以在df上调用list，如下所示:

list(df)

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)

我做了一些快速测试，也许不出意外，使用datafframe .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

(尽管如此，我仍然非常喜欢这个列表(数据框架)，所以感谢EdChum!)

它变得更简单(由Pandas 0.16.0):

df.columns.tolist()

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

>>> list(my_dataframe)
['y', 'gdp', 'cap']

要在调试器模式下列出数据帧的列，使用列表理解式:

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

顺便说一下，你可以简单地使用sorted:

>>> sorted(my_dataframe)
['cap', 'gdp', 'y']

这很有趣，但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

在笔记本上

对于IPython笔记本中的数据探索，我的首选方法是:

sorted(df)

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

在代码存储库中

在代码中，我发现它更明确

df.columns

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

我觉得这个问题值得再解释一下。

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

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

df.keys().tolist()因为没有任何df.keys。Columns方法尚未实现。

这个keys方法的优点是，它甚至可以在更新版本的Pandas中工作，因此更加通用。

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

list(my_dataframe.columns.values)

or

list(my_dataframe) # For less typing.

但我认为最完美的地方是:

list(my_dataframe.columns)

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

为了快速，简洁，直观的检查，试试这个:

for col in df.columns:
    print col

即使之前提供的解决方案很好，我也希望像frame.column_names()这样的东西是Pandas中的一个函数，但由于它不是，也许使用下面的语法会很好。通过调用"tolist"函数，它以某种方式保留了您正在以正确的方式使用pandas的感觉:

frame.columns.tolist()

扩展可迭代解包(Python 3.5+): [*df]和Friends

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

如果你想要一个列表....

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

或者，如果你想要一组，

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

如果你想要一个元组，

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

或者，如果你想把结果存储在某个地方，

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

．.． 如果你是那种把咖啡转换成打字声音的人，好吧，这将更有效地消耗你的咖啡;)

附注:如果性能很重要，你会想要抛弃 上述解决方案有利于 .tolist df.columns.to_numpy () () # [' a '， ' b '， ' c '] 这与Ed Chum的答案相似，但更新了 V0.24，其中.to_numpy()优先于.values的使用。看到 这个答案(由我)为更多的信息。

目视检查

因为我在其他回答中已经看到过这个问题，所以可以使用可迭代解包(不需要显式循环)。

print(*df)
A B C

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

其他方法的批判

对于可以在单行中完成的操作，不要使用显式for循环(列表推导式是可以的)。

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

其次，list(df.columns)和list(df.columns.values)是不好的建议(就当前版本v0.24而言)。Index(从df.columns返回)和NumPy数组(从df.columns.values返回)都定义了.tolist()方法，该方法更快，更习惯。

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

%%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)

如果DataFrame碰巧有一个Index或MultiIndex，你也想把它们包括在列名中:

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

它避免调用reset_index()，因为对于这样一个简单的操作，reset_index()会造成不必要的性能损失。

我经常遇到这种情况，因为我从数据库中穿梭数据，其中dataframe索引映射到一个主键/唯一键，但对我来说实际上只是另一个“列”。对于熊猫来说，有一个内置的方法可能是有意义的(完全有可能我错过了它)。

李光复

最简单的选择是: List (my_datafframe .columns)或my_datafframe .columns.tolist()

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

import pandas as pd

# create test dataframe
df = pd.DataFrame('x', columns=['A', 'B', 'C'], index=range(2))

list(df.columns)

返回

['A', 'B', 'C']

这是达到目标最简单的方法。

my_dataframe.columns.values.tolist ()

如果你很懒，试试这个>

列表（my_dataframe）

它的简单代码为您:

for i in my_dataframe:
    print(i)

尽管去做

这很简单。

比如你可以这样做:

列表(df.columns)