Voglio ottenere un elenco delle intestazioni di colonna da un DataFrame Panda. DataFrame verrà dall'input dell'utente, quindi non saprò quante colonne ci saranno o come verranno chiamate.

Ad esempio, se mi viene dato un DataFrame come questo:

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

Vorrei ottenere un elenco come questo:

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

È possibile ottenere i valori come elenco facendo:

list(my_dataframe.columns.values)

Inoltre puoi semplicemente usare: (come mostrato nella risposta di Ed Chum ):

list(my_dataframe)

Esiste un metodo integrato che è il più performante:

my_dataframe.columns.values.tolist()

.columnsrestituisce un indice, .columns.valuesrestituisce un array e questo ha una funzione di supporto.tolist per restituire un elenco.

Se le prestazioni non sono così importanti per te, gli Indexoggetti definiscono un .tolist()metodo che puoi chiamare direttamente:

my_dataframe.columns.tolist()

La differenza nelle prestazioni è evidente:

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

Per coloro che odiano la digitazione, si può chiamare listil df, come così:

list(df)

Ha fatto alcuni test rapidi e forse non sorprende che la versione integrata che utilizza dataframe.columns.values.tolist()sia la più veloce:

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

(Mi piace ancora molto il list(dataframe)pensiero, quindi grazie EdChum!)

Diventa ancora più semplice (di Panda 0.16.0):

df.columns.tolist()

ti darà i nomi delle colonne in una bella lista.

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

Per elencare le colonne di un frame di dati mentre si è in modalità debugger, utilizzare una comprensione dell'elenco:

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

A proposito, puoi ottenere un elenco ordinato semplicemente usando sorted:

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

Sorpreso non ho visto questo post finora, quindi lo lascerò qui.

Extended Iterable Unpacking (python3.5 +): [*df]and Friends

Le generalizzazioni di decompressione (PEP 448) sono state introdotte con Python 3.5. Quindi, le seguenti operazioni sono tutte possibili.

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 

Se vuoi un list....

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

Oppure, se vuoi un set,

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

Oppure, se vuoi un tuple,

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

Oppure, se si desidera memorizzare il risultato da qualche parte,

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

... se sei il tipo di persona che converte il caffè in suoni di battitura, beh, questo consumerà il tuo caffè in modo più efficiente;)

PS: se le prestazioni sono importanti, vorrai abbandonare le soluzioni sopra a favore di

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

Questo è simile alla risposta di Ed Chum , ma aggiornato per v0.24 dove .to_numpy()è preferito l'uso di .values. Vedi questa risposta (da me) per maggiori informazioni.

Controllo visivo
Poiché ne ho visto la discussione in altre risposte, è possibile utilizzare la decompressione iterabile (non sono necessari loop espliciti).

print(*df)
A B C

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

Critica ad altri metodi

Non usare un esplicito for ciclo per un'operazione che può essere eseguita su una sola riga (le comprensioni dell'elenco sono corrette).

Successivamente, l'utilizzo sorted(df) non mantiene l'ordine originale delle colonne. Per questo, dovresti usarelist(df) invece.

Quindi, list(df.columns)e list(df.columns.values)suggerimenti scadenti (a partire dalla versione corrente, v0.24). Entrambi Index(tornati da df.columns) e array NumPy (restituiti da df.columns.values) definiscono.tolist() metodo che è più veloce e più idiomatica.

Infine, l'elenco, ad esempio, list(df)dovrebbe essere usato solo come alternativa concisa ai metodi di cui sopra per python <= 3.4 dove non è disponibile il decompressione estesa.

È disponibile come my_dataframe.columns.

È interessante ma df.columns.values.tolist()è quasi 3 volte più veloce di allora, df.columns.tolist()ma ho pensato che fossero uguali:

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 segue la convenzione tipo dict di iterare sulle "chiavi" degli oggetti.

my_dataframe.keys()

Crea un elenco di chiavi / colonne - metodo oggetto to_list()e modo pitonico

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

L'iterazione di base su un DataFrame restituisce le etichette delle colonne

[column for column in my_dataframe]

Non convertire un DataFrame in un elenco, solo per ottenere le etichette delle colonne. Non smettere di pensare mentre cerchi esempi di codice convenienti.

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)

Nel quaderno

Per l'esplorazione dei dati nel notebook IPython, il mio modo preferito è questo:

sorted(df)

Che produrrà un elenco in ordine alfabetico facile da leggere.

In un repository di codice

Nel codice lo trovo più esplicito da fare

df.columns

Perché dice agli altri che leggono il tuo codice cosa stai facendo.

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

come ha risposto Simeon Visser ... potresti farlo

list(my_dataframe.columns.values) 

o

list(my_dataframe) # for less typing.

Ma penso che la cosa migliore sia:

list(my_dataframe.columns)

È esplicito, allo stesso tempo non inutilmente lungo.

Per un controllo visivo rapido e accurato, prova questo:

for col in df.columns:
    print col

Questo ci dà i nomi delle colonne in un elenco:

list(my_dataframe.columns)

È possibile utilizzare anche un'altra funzione chiamata tolist ():

my_dataframe.columns.tolist()

Sento che la domanda merita ulteriori spiegazioni.

Come notato da @fixxxer, la risposta dipende dalla versione di Panda che stai usando nel tuo progetto. Che puoi ottenere con il pd.__version__comando.

Se sei per qualche ragione come me (su Debian Jessie uso 0.14.1) usando una versione precedente di Panda rispetto a 0.16.0, allora devi usare:

df.keys().tolist()perché non esiste ancora un df.columnsmetodo implementato.

Il vantaggio di questo metodo di chiavi è che funziona anche nella versione più recente di Panda, quindi è più universale.

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

Anche se la soluzione fornita sopra è buona. Mi aspetterei anche che qualcosa come frame.column_names () sia una funzione in Panda, ma poiché non lo è, forse sarebbe bello usare la seguente sintassi. In qualche modo conserva la sensazione che stai usando i panda in modo corretto chiamando la funzione "tolist": frame.columns.tolist ()

frame.columns.tolist() 

Se il DataFrame sembra avere un indice o MultiIndex e si desidera includere anche quelli come nomi di colonna:

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

Evita di chiamare reset_index () che ha un impatto sulle prestazioni non necessario per un'operazione così semplice.

Ho avuto bisogno di questo più spesso perché sto spostando i dati dai database in cui l'indice del frame di dati viene mappato su una chiave primaria / unica, ma in realtà è solo un'altra "colonna" per me. Probabilmente avrebbe senso per i panda avere un metodo integrato per qualcosa del genere (totalmente possibile che mi sia perso).

Questa soluzione elenca tutte le colonne dell'oggetto my_dataframe:

print(list(my_dataframe))