Je veux obtenir une liste des en-têtes de colonne d'un pandas DataFrame. Le DataFrame proviendra de l'entrée utilisateur, donc je ne saurai pas combien de colonnes il y aura ou comment elles seront appelées.

Par exemple, si on me donne un DataFrame comme ceci:

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

Je voudrais obtenir une liste comme celle-ci:

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

Vous pouvez obtenir les valeurs sous forme de liste en faisant:

list(my_dataframe.columns.values)

Vous pouvez également simplement utiliser: (comme indiqué dans la réponse d'Ed Chum ):

list(my_dataframe)

Il existe une méthode intégrée qui est la plus performante:

my_dataframe.columns.values.tolist()

.columnsrenvoie un index, .columns.valuesretourne un tableau et cela a une fonction d'aide .tolistpour retourner une liste.

Si les performances ne sont pas aussi importantes pour vous, les Indexobjets définissent une .tolist()méthode que vous pouvez appeler directement:

my_dataframe.columns.tolist()

La différence de performances est évidente:

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

Pour ceux qui détestent taper, vous pouvez simplement appeler listsur df, comme ceci:

list(df)

A fait quelques tests rapides, et sans surprise la version intégrée utilisant dataframe.columns.values.tolist()est la plus rapide:

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

(J'aime quand même vraiment list(dataframe), alors merci EdChum!)

C'est encore plus simple (par pandas 0.16.0):

df.columns.tolist()

vous donnera les noms des colonnes dans une belle liste.

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

Pour répertorier les colonnes d'une trame de données en mode débogueur, utilisez une compréhension de liste:

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

Soit dit en passant, vous pouvez obtenir une liste triée simplement en utilisant sorted:

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

Surpris de ne pas l'avoir vu jusqu'à présent, je vais donc laisser cela ici.

Déballage Iterable étendu (python3.5 +): [*df]et amis

Des généralisations de déballage (PEP 448) ont été introduites avec Python 3.5. Ainsi, les opérations suivantes sont toutes possibles.

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 vous voulez un list....

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

Ou, si vous en voulez un set,

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

Ou, si vous en voulez un tuple,

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

Ou, si vous souhaitez stocker le résultat quelque part,

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

... si vous êtes le genre de personne qui convertit le café en sons de frappe, eh bien, cela va consommer votre café plus efficacement;)

PS: si les performances sont importantes, vous voudrez abandonner les solutions ci-dessus en faveur de

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

Ceci est similaire à la réponse d'Ed Chum , mais mis à jour pour la version 0.24 où il .to_numpy()est préférable à l'utilisation de .values. Voir cette réponse (par moi) pour plus d'informations.

Vérification visuelle
Depuis que j'ai vu cela discuté dans d'autres réponses, vous pouvez utiliser le déballage itérable (pas besoin de boucles explicites).

print(*df)
A B C

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

Critique des autres méthodes

N'utilisez pas de forboucle explicite pour une opération qui peut être effectuée sur une seule ligne (les compréhensions de liste sont correctes).

Ensuite, l'utilisation sorted(df) ne conserve pas l'ordre d'origine des colonnes. Pour cela, vous devez utiliser à la list(df)place.

Ensuite, list(df.columns)et list(df.columns.values)sont de mauvaises suggestions (à partir de la version actuelle, v0.24). Les deux Index(retour de df.columns) et les tableaux numpy (retournées par df.columns.values) définissent la .tolist()méthode qui est plus rapide et plus idiomatiques.

Enfin, la listification, c'est-à-dire list(df)ne doit être utilisée que comme une alternative concise aux méthodes susmentionnées pour python <= 3.4 lorsque le déballage étendu n'est pas disponible.

C'est disponible en tant que my_dataframe.columns.

C'est intéressant mais df.columns.values.tolist()c'est presque 3 fois plus rapide alors df.columns.tolist()mais je pensais que ce sont les mêmes:

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 suit la convention de type dict consistant à itérer sur les «clés» des objets.

my_dataframe.keys()

Créer une liste de clés / colonnes - méthode objet to_list()et manière pythonique

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

L'itération de base sur un DataFrame renvoie des étiquettes de colonne

[column for column in my_dataframe]

Ne convertissez pas un DataFrame en liste, juste pour obtenir les étiquettes de colonne. N'arrêtez pas de penser en recherchant des exemples de code pratiques.

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)

Dans le cahier

Pour l'exploration de données dans le bloc-notes IPython, ma méthode préférée est la suivante:

sorted(df)

Ce qui produira une liste alphabétique facile à lire.

Dans un référentiel de code

Dans le code, je trouve cela plus explicite à faire

df.columns

Parce qu'il dit aux autres qui lisent votre code ce que vous faites.

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

comme l'a répondu Simeon Visser ... vous pourriez faire

list(my_dataframe.columns.values) 

ou

list(my_dataframe) # for less typing.

Mais je pense que la plupart du sweet spot est:

list(my_dataframe.columns)

C'est explicite, en même temps pas inutilement long.

Pour une vérification visuelle rapide et nette, essayez ceci:

for col in df.columns:
    print col

Cela nous donne les noms des colonnes dans une liste:

list(my_dataframe.columns)

Une autre fonction appelée tolist () peut également être utilisée:

my_dataframe.columns.tolist()

Je pense que la question mérite des explications supplémentaires.

Comme l'a noté @fixxxer, la réponse dépend de la version pandas que vous utilisez dans votre projet. Que vous pouvez obtenir avec la pd.__version__commande.

Si vous êtes pour une raison comme moi (sur Debian Jessie, j'utilise 0.14.1) en utilisant une version plus ancienne de pandas que 0.16.0, alors vous devez utiliser:

df.keys().tolist()car il n'y a pas encore de df.columnsméthode implémentée.

L'avantage de cette méthode de touches est qu'elle fonctionne même dans les nouvelles versions de pandas, donc elle est plus universelle.

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

Même si la solution fournie ci-dessus est agréable. Je m'attendrais également à ce que quelque chose comme frame.column_names () soit une fonction dans pandas, mais comme ce n'est pas le cas, il serait peut-être bien d'utiliser la syntaxe suivante. Il préserve en quelque sorte le sentiment que vous utilisez les pandas de manière appropriée en appelant la fonction "tolist": frame.columns.tolist ()

frame.columns.tolist() 

Si le DataFrame possède un index ou un multi-index et que vous souhaitez que ceux-ci soient également inclus en tant que noms de colonne:

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

Il évite d'appeler reset_index () qui a un impact de performance inutile pour une opération aussi simple.

J'ai eu besoin de cela plus souvent parce que je transfère des données à partir de bases de données où l'index de la trame de données correspond à une clé primaire / unique, mais n'est vraiment qu'une autre "colonne" pour moi. Il serait probablement logique pour les pandas d'avoir une méthode intégrée pour quelque chose comme ça (totalement possible, je l'ai raté).

Cette solution répertorie toutes les colonnes de votre objet my_dataframe:

print(list(my_dataframe))