从pandas DataFrame列标题中获取列表

我想从一个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']
Gulzar
已编辑的问题 16日 六月 2019 в 11:48
编程
python pandas dataframe
20日 十月 2013 в 9:18
37 种观点
解决办法

你可以通过以下方式获得列表中的数值。

list(my_dataframe.columns.values)

也可以简单地使用：（如Ed Chum's answer中所示）。

list(my_dataframe)
cs95
编辑本段答案3日 四月 2019 в 9:51
评论(10)

有一种内置的方法是最能表现的。

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)

对于那些讨厌打字的人，你可以直接在df上调用list，如是。

list(df)
cs95
编辑本段答案3日 四月 2019 в 9:26
评论(6)

做了一些快速的测试，也许不出所料，使用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!)

评论(0)

它变得更简单了（由pandas 0.16.0） 。

df.columns.tolist()

会在一个漂亮的列表中给你列名。

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

要在调试器模式下列出数据框的列，请使用列表理解。

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

顺便说一下，你可以通过使用sorted得到一个排序的列表。

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

这可以作为my_dataframe.columns使用。

评论(2)

有趣的是，"df.columns.values.tolist() "比 "df.columns.tolist() "快了近3倍，但我认为它们是一样的。

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
评论(1)

很惊讶我至今没有看到这个帖子，所以我就把这个留在这里。

扩展的可迭代解包(python3.5+)。

[*df]和朋友们。

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

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'}

或者，如果你想要一个ttuple。

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

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

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

... 如果你'是那种将咖啡转换为打字声音的人，那么，这将更有效地消耗你的咖啡;)

&gt.P.S.: 如果你是那种把咖啡转换成打字声音的人，那么，这将会更有效地消耗你的咖啡;) P.S: 如果性能很重要的话，你会想要抛弃这个。

以上解决方案，以支持

＆gt.to_numpy().tolist() df.columns.to_numpy().tolist() &gt.##39;A', 'B', 'C']

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

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

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

。 这类似于[艾德-查姆'的 &gt.答案]()，但更新了。 的回答](https://stackoverflow.com/a/19483602/4909087)，但更新为

v0.24 其中.to_numpy()比使用.values更可取。 参见

本回答(由我)

更多信息。

目测检查 因为我在其他答案中看到过这个问题的讨论，你可以利用可迭代解包（不需要显式循环）。

print(*df)
A B C

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

对其他方法的批评

不要对可以在一行中完成的操作使用显式的for循环（List理解也可以）。

其次，使用sorted(df)不会保留列的原始顺序。 为此，你应该使用list(df)来代替。

其次，list(df.columns)和list(df.columns.values)都是很差的建议(在当前版本，v0.24)。 Index(由df.columns返回)和NumPy数组(由df.columns.values返回)都定义了.tolist()方法，它更快，更习惯。

最后，listification，即list(df)只能作为上述方法的简明替代方法。

cs95
编辑本段答案3日 四月 2019 в 3:08
评论(0)

一个[DataFrame][1]遵循类似于dict的约定，对对象的 "键 "进行迭代。

my_dataframe.keys()

创建键/列列表--对象方法 "to_list() "和pythonic方式。

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

在DataFrame上的[基本迭代][2]返回列标签。

[column for column in my_dataframe]

不要为了得到列标签而将DataFrame转换为列表。 不要一边寻找方便的代码样本，一边停止思考。

<！--语言。 python -->

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)

[1]: https://pandas.pydata.org/pandas-docs/stable/api.html#dataframe [2]: http://pandas.pydata.org/pandas-docs/stable/basics.html#iteration

Sascha Gottfried
编辑本段答案31日 五月 2018 в 11:25
评论(2)

∮在笔记本上∮ 对于IPython笔记本中的数据探索，我的首选方式是这样的。

sorted(df)

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

＃＃在代码库中

在代码中，我发现更明确的做法是

df.columns

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

评论(2)
 
%%时间
final_df.columns.value.tolist()
948 ns ±
每循环19.2 ns（平均值&#177。
std.
dev.
7次运行，每次1000000个循环的平均值)
%%时间
列表(final_df.columns)
14.2 µs ±
79.1 ns/循环（平均值±
std.
dev.
的7次运行，每次100000个循环)
%%时间
list(final_df.columns.value)
1.88 µs ±
11.7 ns/循环（平均值±
std.
dev.
7次运行，每次1000000个循环)
%%时间
final_df.columns.tolist()
12.3 µs ±
27.4 ns/循环（平均值±
std.
dev.
的7次运行，每次100000个循环)
%%时间
list(final_df.head(1).columns)
163 µs ±
20.6 µs/循环（平均值±
std.
dev.
7次运行，每次10000次循环)
评论(0)

由Simeon Visser回答......你可以这样做

list(my_dataframe.columns.values)

或

list(my_dataframe) # for less typing.

但我认为大多数的甜蜜点是。

list(my_dataframe.columns)

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

Vivek
编辑本段答案16日 二月 2018 в 7:15
评论(1)

要想快速、整洁、直观地检查，可以试试这个。

for col in df.columns:
    print col
评论(0)

这给了我们一个列表中的列名。

list(my_dataframe.columns)

也可以使用另一个函数 tolist() 。

my_dataframe.columns.tolist()
评论(1)

我觉得这个问题值得补充解释。

正如 @fixxxer 所说的，答案取决于你在项目中使用的 pandas 版本。 你可以通过pd.__version__命令获得。

如果你因为某些原因像我一样（在 debian jessie 上我使用 0.14.1）使用了比 0.16.0 更老的 pandas 版本，那么你需要使用。

df.keys().tolist()，因为目前还没有实现df.columns方法。

这个keys方法的好处是，它甚至可以在较新版本的pandas中使用，所以它更通用。

评论(1)
n = []
for i in my_dataframe.columns:
    n.append(i)
print n
评论(3)

尽管上面提供的解决方案很好，但我还是希望像frame.column_names()这样的东西在pandas中是一个函数。 我也希望像frame.column_names()这样的东西在pandas中是一个函数，但是既然它不是，也许使用下面的语法会更好。 通过调用 "tolist&quot，它在某种程度上保留了你以正确方式使用 pandas 的感觉。 函数，从而保留了你使用 pandas 的正确方式。 frame.columns.tolist()

frame.columns.tolist()
评论(1)

这个解决方案列出了对象my_dataframe的所有列。

print(list(my_dataframe))
sɐunıɔןɐqɐp
编辑本段答案11日 六月 2018 в 10:30
评论(1)