Obtenir la liste des en-têtes de colonne pandas DataFrame
Je veux obtenir une liste des en-têtes de colonnes d'un DataFrame Pandas. Le DataFrame proviendra d'une entrée utilisateur, je ne saurai donc pas combien de colonnes il y aura ni 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
J'aimerais avoir une liste comme celle ci-dessous:
>>> header_list
[y, gdp, cap]
Vous pouvez obtenir les valeurs sous forme de liste en faisant:
list(my_dataframe.columns.values)
Aussi, vous pouvez simplement utiliser:
list(my_dataframe)
Il existe une méthode intégrée qui est la plus performante:
my_dataframe.columns.values.tolist()
.columns renvoie Index, .columns.values renvoie array et dispose d'une fonction d'assistance pour renvoyer list.
MODIFIER
Pour ceux qui détestent taper, c'est probablement la méthode la plus courte:
list(df)
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 toujours beaucoup la list(dataframe) cependant, alors merci EdChum!)
Cela devient encore plus simple (par pandas 0.16.0):
df.columns.tolist()
vous donnera les noms des colonnes dans une liste de Nice.
>>> list(my_dataframe)
['y', 'gdp', 'cap']
Pour lister les colonnes d'un dataframe en mode débogueur, utilisez une liste à comprendre:
>>> [c for c in my_dataframe]
['y', 'gdp', 'cap']
En passant, vous pouvez obtenir une liste triée simplement en utilisant sorted:
>>> sorted(my_dataframe)
['cap', 'gdp', 'y']
C'est disponible en tant que my_dataframe.columns.
C'est intéressant mais df.columns.values.tolist() est presque 3 fois plus rapide que df.columns.tolist() mais je pensais qu'ils étaient identiques
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
A DataFrame suit la convention d'itération du type dict sur les "clés" des objets.
my_dataframe.keys()
Créer une liste de clés/colonnes - méthode d'objet to_list() et façon Pythonic
my_dataframe.keys().to_list()
list(my_dataframe.keys())
Itération de base sur un DataFrame renvoie les étiquettes de colonne
[column for column in my_dataframe]
Ne convertissez pas un DataFrame en une liste, uniquement pour obtenir les libellés des colonnes. N'arrêtez pas de penser en cherchant 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
En code je trouve plus explicite de le faire
df.columns
Parce que cela dit aux autres lecteurs de votre code ce que vous faites.
Surpris de ne pas avoir vu ceci posté jusqu'à présent, je vais donc laisser ça ici.
Déballage itéré étendu (python3.5 +): [*df] et amis
Les généralisations de décompression (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 une list....
[*df]
# ['A', 'B', 'C']
Ou, si vous voulez une set,
{*df}
# {'A', 'B', 'C'}
Ou, si vous voulez une Tuple,
*df, # Please note the trailing comma
# ('A', 'B', 'C')
Ou, si vous voulez 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 dactylographie, eh bien, cela consommera votre café plus efficacement;)
P.S .: si la performance est importante, vous voudrez abandonner les solutions ci-dessus en faveur de
df.columns.to_numpy().tolist() # ['A', 'B', 'C']Ceci est similaire à la réponse de Ed Chum , mais mise à jour pour la v0.24 où
.to_numpy()est préféré à l'utilisation de.values. Voir cette réponse (par moi) pour plus d'informations.
Contrôle visuel
Depuis que j'ai vu cela discuté dans d'autres réponses, vous pouvez utiliser le décompression itérable (pas besoin de boucles explicites).
print(*df)
A B C
print(*df, sep='\n')
A
B
C
Critique d'autres méthodes
N'utilisez pas de boucle for explicite pour une opération pouvant être effectuée sur une seule ligne (la compréhension de la liste est correcte).
Ensuite, utiliser sorted(df) ne conserve pas l'ordre d'origine des colonnes. Pour cela, vous devriez utiliser list(df) à la place.
Ensuite, list(df.columns) et list(df.columns.values) sont de mauvaises suggestions (à partir de la version actuelle, v0.24). Les deux tableaux Index (renvoyés de df.columns) et NumPy (renvoyés par df.columns.values) définissent la méthode .tolist() qui est plus rapide et plus idiomatique.
Enfin, la listification, à savoir, list(df), ne doit être utilisée que comme une alternative concise aux méthodes susmentionnées.
comme l'a répondu Simeon Visser ... vous pourriez le faire
list(my_dataframe.columns.values)
ou
list(my_dataframe) # for less typing.
Mais je pense que l'essentiel est:
list(my_dataframe.columns)
C'est explicite, mais pas trop long en même temps.
Cela nous donne les noms des colonnes dans une liste:
list(my_dataframe.columns)
Une autre fonction appelée tolist () peut aussi être utilisée:
my_dataframe.columns.tolist()
Pour un contrôle visuel rapide et soigné, essayez ceci:
for col in df.columns:
print col
n = []
for i in my_dataframe.columns:
n.append(i)
print n
Je pense que la question mérite une explication supplémentaire.
Comme @fixxxer l'a noté, la réponse dépend de la version de pandas que vous utilisez dans votre projet . Ce que vous pouvez obtenir avec la commande pd.__version__.
Si pour une raison quelconque, vous êtes comme moi (avec Debian Jessie, j'utilise la version 0.14.1) qui utilise une version plus ancienne des pandas que la version 0.16.0, vous devez utiliser:
df.keys().tolist() car il n'y a pas encore de méthode df.columns implémentée.
L’avantage de cette méthode est qu’elle fonctionne même dans les versions les plus récentes des pandas, elle est donc plus universelle.
%%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)
Même si la solution proposée ci-dessus est bien Nice. Je m'attendrais aussi à ce que quelque chose comme frame.column_names () soit une fonction dans les pandas, mais comme ce n'est pas le cas, il serait peut-être agréable d'utiliser la syntaxe suivante. Cela 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()
Cette solution répertorie toutes les colonnes de votre objet my_dataframe:
print(list(my_dataframe))