Quiero obtener una lista de los encabezados de columna de un DataFrame de pandas. El DataFrame vendrá de la entrada del usuario, así que no sabré cuántas columnas habrá o cómo se llamarán.

Por ejemplo, si me dan un DataFrame como este:

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

Me gustaría obtener una lista como esta:

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

Puede obtener los valores como una lista haciendo:

list(my_dataframe.columns.values)

También puede simplemente usar: (como se muestra en la respuesta de Ed Chum ):

list(my_dataframe)

Hay un método integrado que es el más eficaz:

my_dataframe.columns.values.tolist()

.columnsdevuelve un índice, .columns.valuesdevuelve una matriz y esto tiene una función auxiliar .tolistpara devolver una lista.

Si el rendimiento no es tan importante para usted, los Indexobjetos definen un .tolist()método al que puede llamar directamente:

my_dataframe.columns.tolist()

La diferencia en el rendimiento es obvia:

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

Para los que odian a escribir, sólo puede llamar lista df, como así:

list(df)

Hice algunas pruebas rápidas, y quizás como era de esperar, la versión incorporada que usa dataframe.columns.values.tolist()es la más rápida:

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

(Aunque todavía me gusta mucho list(dataframe), ¡así que gracias EdChum!)

Se vuelve aún más simple (por pandas 0.16.0):

df.columns.tolist()

le dará los nombres de las columnas en una buena lista.

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

Para enumerar las columnas de un marco de datos mientras está en modo depurador, use una comprensión de lista:

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

Por cierto, puede obtener una lista ordenada simplemente usando sorted:

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

Sorprendido, no he visto esto publicado hasta ahora, así que lo dejaré aquí.

Desempaquetado Iterable Extendido (python3.5 +): [*df]y Amigos

Las generalizaciones de desempaque (PEP 448) se han introducido con Python 3.5. Entonces, las siguientes operaciones son todas posibles.

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 

Si quieres un list...

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

O, si quieres un set,

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

O, si quieres un tuple,

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

O, si desea almacenar el resultado en algún lugar,

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

... si eres el tipo de persona que convierte el café en sonidos de mecanografía, bueno, esto consumirá tu café de manera más eficiente;)

PD: si el rendimiento es importante, querrás deshacerte de las soluciones anteriores a favor de

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

Esto es similar a la respuesta de Ed Chum , pero actualizado para v0.24, donde .to_numpy()se prefiere el uso de .values. Vea esta respuesta (por mí) para más información.

Verificación visual
Como he visto esto discutido en otras respuestas, puede utilizar desempaquetar iterable (sin necesidad de bucles explícitos).

print(*df)
A B C

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

Crítica de otros métodos

No use un explícito for bucle para una operación que se puede hacer en una sola línea (las comprensiones de la lista están bien).

A continuación, el uso sorted(df) no conserva el orden original de las columnas. Para eso, debes usarlist(df) en lugar.

A continuación, list(df.columns)y list(df.columns.values)son sugerencias pobres (a partir de la versión actual, v0.24). Ambas matrices Index(devueltas de df.columns) y NumPy (devueltas por df.columns.values) definen.tolist() método que es más rápido y más idiomático.

Por último, la enumeración, es decir, list(df)solo debe usarse como una alternativa concisa a los métodos antes mencionados para python <= 3.4 donde el desembalaje extendido no está disponible.

Eso está disponible como my_dataframe.columns.

Es interesante, pero df.columns.values.tolist()es casi 3 veces más rápido, df.columns.tolist()pero pensé que son lo mismo:

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

Un DataFrame sigue la convención tipo dict de iterar sobre las "claves" de los objetos.

my_dataframe.keys()

Crear una lista de claves / columnas: método de objeto to_list()y forma pitónica

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

La iteración básica en un DataFrame devuelve etiquetas de columna

[column for column in my_dataframe]

No convierta un DataFrame en una lista, solo para obtener las etiquetas de columna. No deje de pensar mientras busca ejemplos de códigos convenientes.

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)

En el cuaderno

Para la exploración de datos en el cuaderno de IPython, mi forma preferida es esta:

sorted(df)

Lo que producirá una lista ordenada alfabéticamente fácil de leer.

En un repositorio de código

En el código me parece más explícito hacer

df.columns

Porque le dice a otros que leen tu código lo que estás haciendo.

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

como respondió Simeon Visser ... podrías hacer

list(my_dataframe.columns.values) 

o

list(my_dataframe) # for less typing.

Pero creo que el mejor punto es:

list(my_dataframe.columns)

Es explícito, al mismo tiempo, no innecesariamente largo.

Para una verificación visual rápida, ordenada, intente esto:

for col in df.columns:
    print col

Esto nos da los nombres de las columnas en una lista:

list(my_dataframe.columns)

También se puede usar otra función llamada tolist ():

my_dataframe.columns.tolist()

Siento que la pregunta merece una explicación adicional.

Como señaló @fixxxer, la respuesta depende de la versión de pandas que esté utilizando en su proyecto. Que puedes conseguir conpd.__version__ comando.

Si por alguna razón como yo (en Debian Jessica uso 0.14.1) usando una versión anterior de pandas que no sea 0.16.0, entonces necesita usar:

df.keys().tolist() porque no hay df.columns método implementado.

La ventaja de este método de teclas es que funciona incluso en la versión más reciente de los pandas, por lo que es más universal.

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

Aunque la solución que se proporcionó anteriormente es buena. También esperaría que algo como frame.column_names () sea una función en pandas, pero como no lo es, tal vez sería bueno usar la siguiente sintaxis. De alguna manera, conserva la sensación de que está utilizando los pandas de manera adecuada llamando a la función "tolist": frame.columns.tolist ()

frame.columns.tolist() 

Si el DataFrame tiene un índice o MultiIndex y desea incluirlos también como nombres de columna:

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

Evita llamar a reset_index () que tiene un impacto de rendimiento innecesario para una operación tan simple.

Me he encontrado con que necesito esto más a menudo porque estoy transfiriendo datos de bases de datos donde el índice del marco de datos se asigna a una clave primaria / única, pero en realidad es solo otra "columna" para mí. Probablemente tendría sentido que los pandas tengan un método incorporado para algo como esto (totalmente posible, me lo he perdido).

Esta solución enumera todas las columnas de su objeto my_dataframe:

print(list(my_dataframe))