Получить список из заголовков столбцов Pandas DataFrame

avatar
natsuki_2002
20 октября 2013 в 21:18
1951239
19
1210

Я хочу получить список заголовков столбцов из 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']
Источник
cs95
7 июня 2020 в 22:13
4

Из python3.5 + вы можете использовать [*df] вместо list(df) или df.columns.tolist(), это благодаря Распаковка обобщений (PEP 448).

Pe Dro
19 августа 2020 в 07:50
1

>>> list(df.columns) достаточно :)

Ответы (19)

avatar
Simeon Visser
20 октября 2013 в 21:23
1882

Вы можете получить значения в виде списка, выполнив:

list(my_dataframe.columns.values)

Также вы можете просто использовать (как показано в ответе Эда Чума):

list(my_dataframe)
Tjorriemorrie
21 ноября 2014 в 08:30
46

Почему этот документ не имеет атрибута columns?

Simeon Visser
21 ноября 2014 в 10:18
0

@Tjorriemorrie: Я не уверен, возможно, это связано с тем, как они автоматически создают свою документацию. Однако он упоминается в других местах: pandas.pydata.org/pandas-docs/stable/…

alvas
13 января 2016 в 06:48
9

Я ожидал чего-то вроде df.column_names(). Этот ответ все еще верен или устарел?

Simeon Visser
13 января 2016 в 09:30
1

@alvas существуют различные другие способы сделать это (см. другие ответы на этой странице), но, насколько я знаю, в кадре данных нет метода для создания списка напрямую.

WindChimes
25 января 2016 в 13:07
21

Важно отметить, что это сохраняет порядок столбцов.

Davos
2 мая 2018 в 07:20
0

Я попытался использовать это с unittest assertListEqual, чтобы проверить, что заголовки в df соответствуют ожидаемому списку, и он сообщает мне, что это не список, а последовательность, это выглядит как array(['colBoolean','colTinyint', 'colSmallnt', ...], dtype=object)

StefanK
9 мая 2018 в 08:22
0

df.keys().tolist() более универсален, потому что он работает и для более старых версий панд, чем 0.16.0

Igor Jakovljevic
23 ноября 2018 в 09:53
0

Несмотря на то, что решение, которое было предоставлено выше, хорошее. Я бы также ожидал, что что-то вроде frame.column_names () будет функцией в пандах, но, поскольку это не так, возможно, было бы неплохо использовать следующий синтаксис. Он каким-то образом сохраняет ощущение, что вы используете панды должным образом, вызывая функцию "tolist": frame.columns.tolist ()

Timbus Calin
16 марта 2019 в 07:35
0

Обратите внимание, что dataframe [column_name] .to_numpy () - это рекомендуемый метод для получения значений столбца с pandas 0.24.1

cs95
3 апреля 2019 в 09:50
1

Этот первый вариант ужасен (для текущей версии pandas - v0.24), потому что он смешивает идиомы. Если у вас возникли проблемы с доступом к массиву numpy, используйте вместо него метод .tolist(), он быстрее и идиоматичнее.

Jayank
21 августа 2020 в 17:05
0

когда я использовал list(my_df), он дает мне [u'Col_Name1', u'Col_Name2'], но, пожалуйста, укажите, , что означает список столбцов «u»

msoutopico
27 февраля 2021 в 13:12
0

Подход headers = list(df.columns.values) работает не во всех случаях. Это дает мне TypeError: 'list' object is not callable с python 3.9.1. Вместо этого headers = [*df] работает нормально. Кроме того, headers = df.columns.values дает <class 'numpy.ndarray'>, а не список, но, похоже, тоже работает.

avatar
Grégoire
19 января 2022 в 01:02
0

Самый простой вариант: list(my_dataframe.columns) или my_dataframe.columns.tolist()

Никаких сложных вещей выше :)

avatar
Spesh
27 октября 2021 в 22:35
0

listHeaders = [colName для colName в my_dataframe]

Community
28 октября 2021 в 02:28
0

Ваш ответ можно улучшить с помощью дополнительной вспомогательной информации. Пожалуйста, отредактируйте, чтобы добавить дополнительную информацию, например цитаты или документацию, чтобы другие могли подтвердить, что ваш ответ правильный. Дополнительную информацию о том, как писать хорошие ответы, можно найти в Справочном центре.

avatar
totalhack
16 января 2020 в 05:24
1

Если у DataFrame есть индекс или мультииндекс, и вы хотите, чтобы они были включены в имена столбцов:

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

Он позволяет избежать вызова reset_index (), который снижает производительность такой простой операции.

Мне это нужно было чаще, потому что я перемещаю данные из баз данных, где индекс фрейма данных сопоставляется с первичным / уникальным ключом, но на самом деле для меня это просто еще один «столбец». Вероятно, для панд было бы разумно иметь встроенный метод для чего-то вроде этого (вполне возможно, что я его пропустил).

avatar
rohit singh
16 апреля 2019 в 06:32
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)
Peter Mortensen
22 октября 2021 в 12:48
0

Объяснение было бы в порядке. Например. что такое резюме и заключение? Пожалуйста, ответьте, отредактировав (изменив) свой ответ, а не здесь, в комментариях ( без «Изменить:», «Обновить:» или аналогичный - ответ должен выглядеть так, как если бы он был написан Cегодня).

avatar
cs95
3 апреля 2019 в 09:18
46

Расширенная итеративная распаковка (Python 3.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

Если вам нужен 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']

... если вы из тех людей, которые превращают кофе в звуки печати, что ж, это будет потреблять ваш кофе более эффективно;)

P.S .: если производительность важна, вы захотите отказаться от вышеупомянутые решения в пользу

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

Это похоже на ответ Эда Чама, но обновлено для 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(), который является более быстрым и идиоматическим.

И, наконец, литификация, т.е. list(df), должна использоваться только как краткая альтернатива вышеупомянутым методам для Python 3.4 или более ранних версий, где расширенная распаковка недоступна.

avatar
Igor Jakovljevic
14 февраля 2019 в 10:58
1

Несмотря на то, что решение, которое было предоставлено ранее, хорошее, я также ожидал бы, что что-то вроде frame.column_names () будет функцией в Pandas, но, поскольку это не так, возможно, было бы неплохо использовать следующий синтаксис. Это каким-то образом сохраняет ощущение, что вы правильно используете pandas, вызывая функцию "tolist": frame.columns.tolist ()

frame.columns.tolist()
Peter Mortensen
22 октября 2021 в 12:41
0

По "решение" : К какому из них вы имеете в виду? Или вы ссылаетесь на несколько решений?

avatar
Joseph True
22 августа 2018 в 16:17
4

Для быстрой, аккуратной и визуальной проверки попробуйте следующее:

for col in df.columns:
    print col
avatar
Vivek
16 февраля 2018 в 18:36
4

Поскольку ответил Симеон Виссер, вы могли бы сделать

list(my_dataframe.columns.values)

или

list(my_dataframe) # For less typing.

Но я думаю, что самое лучшее - это:

list(my_dataframe.columns)

Это явный и в то же время не излишне длинный.

cs95
3 апреля 2019 в 09:42
0

«Это ясно, но в то же время не излишне долго». Я не согласен. Звонок по номеру list не имеет смысла, если вы не звоните по номеру df напрямую (например, для краткости). Доступ к атрибуту .columns возвращает объект Index, для которого определен метод tolist(), и его вызов более идиоматичен, чем прослушивание Index. Смешивать идиомы только для полноты картины - не лучшая идея. То же самое и с просмотром массива, который вы получаете от .values.

avatar
StefanK
13 декабря 2017 в 14:47
3

Я считаю, что этот вопрос заслуживает дополнительного объяснения.

Как отметил fixxxer, ответ зависит от версии Pandas, которую вы используете в своем проекте. Это можно получить с помощью команды pd.__version__.

Если вы по какой-то причине похожи на меня (на Debian 8 (Джесси) я использую 0.14.1), используя более старую версию Pandas, чем 0.16.0, то вам необходимо использовать:

df.keys().tolist(), потому что еще не реализован какой-либо метод df.columns.

Преимущество этого метода ключей в том, что он работает даже в более новой версии Pandas, поэтому он более универсален.

cs95
4 апреля 2019 в 21:00
0

Недостаток keys () в том, что это вызов функции, а не поиск атрибутов, поэтому он всегда будет медленнее. Конечно, при постоянном доступе по времени никто особо не заботится о подобных различиях, но я думаю, что в любом случае стоит упомянуть; df.columns теперь является более общепринятой идиомой для доступа к заголовкам.

avatar
firelynx
30 марта 2016 в 07:19
15

В ноутбуке

Для исследования данных в блокноте IPython я предпочитаю следующий способ:

sorted(df)

Будет создан удобный для чтения список в алфавитном порядке.

В репозитории кода

В коде я считаю более явным сделать

df.columns

Потому что он сообщает другим, читающим ваш код, что вы делаете.

cs95
3 апреля 2019 в 09:45
0

sorted(df) изменяет порядок. Используйте с осторожностью.

firelynx
3 апреля 2019 в 11:48
0

@coldspeed Я все же упоминаю об этом, «что позволит создать удобный для чтения список в алфавитном порядке».

avatar
Anton Protopopov
4 декабря 2015 в 21:41
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
cs95
3 апреля 2019 в 09:48
2

Сроки уже были рассмотрены в этом ответе. Причина несоответствия заключается в том, что .values возвращает базовый массив numpy, а выполнение чего-либо с numpy почти всегда быстрее, чем выполнение того же самого с pandas напрямую.

avatar
Alexander
28 мая 2015 в 15:58
41
>>> list(my_dataframe)
['y', 'gdp', 'cap']

Чтобы вывести список столбцов фрейма данных в режиме отладчика, используйте понимание списка:

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

Кстати, вы можете получить отсортированный список, просто используя sorted:

>>> sorted(my_dataframe)
['cap', 'gdp', 'y']
alvas
13 января 2016 в 06:49
0

Будет ли это list(df) работать только с фреймами данных с автоинкрементом? Или это работает для всех фреймов данных?

Alexander
13 января 2016 в 07:28
2

Должно работать для всех. Однако, когда вы находитесь в отладчике, вам нужно использовать понимание списка [c for c in df].

avatar
fixxxer
7 апреля 2015 в 14:50
61

Это становится еще проще (Pandas 0.16.0):

df.columns.tolist()

предоставит вам имена столбцов в красивом списке.

avatar
tegan
1 декабря 2014 в 20:31
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!)

avatar
Sascha Gottfried
23 января 2014 в 17:23
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)
cs95
3 апреля 2019 в 09:45
2

Мои тесты показывают, что df.columns намного быстрее, чем df.keys(). Не уверен, почему у них есть и функция, и атрибут для одного и того же (ну, это не первый раз, когда я вижу 10 разных способов сделать что-то в пандах).

Sascha Gottfried
9 апреля 2019 в 10:05
1

Мой ответ состоял в том, чтобы показать несколько способов запроса меток столбцов из DataFrame и выделить анти-шаблон производительности. Тем не менее мне нравятся ваши комментарии, и я поддержал ваш недавний ответ, поскольку они представляют ценность с точки зрения разработки программного обеспечения.

avatar
EdChum
20 октября 2013 в 22:25
473

Существует встроенный метод, который является наиболее эффективным:

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)
avatar
user21988
20 октября 2013 в 21:43
2
n = []
for i in my_dataframe.columns:
    n.append(i)
print n
Sascha Gottfried
23 января 2014 в 16:22
6

пожалуйста, замените его пониманием списка.

Anton Protopopov
4 декабря 2015 в 21:31
4

измените свои первые 3 строки на [n for n in dataframe.columns]

cs95
3 апреля 2019 в 09:36
0

Зачем вам проходить через все эти неприятности для операции, которую легко выполнить в одной строке?

avatar
BrenBarn
20 октября 2013 в 21:20
26

Это доступно как my_dataframe.columns.

yeliabsalohcin
5 сентября 2017 в 12:59
1

И явно в виде списка от header_list = list(my_dataframe.columns)

cs95
3 апреля 2019 в 09:52
1

^ Или еще лучше: df.columns.tolist().