Obtenir la liste de pandas DataFrame en-têtes de colonne

Je veux obtenir une liste des en-têtes de colonne à partir d'une pandas DataFrame. Le DataFrame viendra de la saisie de l'utilisateur de sorte que je ne sais pas combien de colonnes il y aura ou qu'ils seront appelés.

Par exemple, si je me suis donné 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 ceci:

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

InformationsquelleAutor natsuki_2002 | 2013-10-20

1523

Vous pouvez obtenir les valeurs d'une liste par:
```
list(my_dataframe.columns.values)
```
Aussi, vous pouvez simplement utiliser: (comme indiqué dans Ed Chum répondre):
```
list(my_dataframe)
```
- Pourquoi ne ce document pas columns comme un attribut?
- Je ne suis pas sûr, il peut avoir à faire avec la façon dont ils génèrent automatiquement leur documentation. Il est mentionné dans d'autres endroits bien: pandas.pydata.org/pandas-docs/stable/...
- J'aurais attendre à quelque chose comme df.column_names(). Est-ce la réponse juste ou est-il obsolète?
- il existe plusieurs autres façons de le faire (voir les autres réponses sur cette page), mais pour autant que je sache, il n'existe pas une méthode sur le dataframe directement pour produire de la liste.
- Surtout, cela préserve l'ordre des colonnes.
- J'ai essayé d'utiliser cette avec unittest assertListEqual pour vérifier les en-têtes dans un df assorti d'une attendue liste, et il me dit qu'il n'est pas une liste, mais plutôt une séquence, il ressemble à array(['colBoolean','colTinyint', 'colSmallnt', ...], dtype=object)
- df.keys().tolist() est plus universelle, car elle fonctionne aussi pour les anciennes versions de pandas que 0.16.0
- Même si la solution qui a été prévu ci-dessus est agréable. Je voudrais également s'attendre à quelque chose comme cadre.column_names() est une fonction dans les pandas, mais comme il n'est pas, peut-être qu'il serait bien d'utiliser la syntaxe suivante. C'est en quelque sorte préserve le sentiment que vous êtes à l'aide de pandas, de manière adéquate, par l'appel de la "tolist" la fonction de l'image.les colonnes.tolist()
- Notez que dataframe[column_name].to_numpy() est la méthode suggérée pour obtenir les valeurs d'une colonne comme des pandas 0.24.1
- Cette première option est terrible (à compter de la version actuelle de pandas - v0.24), parce qu'il est le mélange des idiomes. Si vous allez par le biais de la difficulté à accéder au tableau numpy, veuillez utiliser le .tolist() méthode au lieu de cela, il est plus rapide et plus idiomatique.
InformationsquelleAutor Simeon Visser
374

Il y a une méthode intégrée qui est le plus performant:
```
my_dataframe.columns.values.tolist()
```
.columns retourne un Index, .columns.values retourne un tableau, ce qui a une fonction d'assistance .tolist de revenir une liste.

Si la performance n'est pas aussi important pour vous, Index objets de définir un .tolist() méthode que vous pouvez appeler directement:
```
my_dataframe.columns.tolist()
```
La différence de performance 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 tapant, vous pouvez les appeler list sur df, de la manière suivante:
```
list(df)
```
- Ne pas voter, mais vous voulez expliquer: ne comptez pas sur les détails de mise en œuvre, l'utilisation publique "interface" de DataFrame. Pensez à la beauté de df.les touches()
- la mise en œuvre de la DataFrame itérable n'a pas changé depuis le premier jour: pandas.pydata.org/pandas-docs/stable/basics.html#iteration. L'objet iterable retourné à partir d'un DataFrame a toujours été des colonnes afin de faire for col in df: doit toujours se comporter de la même sauf que les développeurs ont un effondrement de sorte list(df) est et devrait toujours être une méthode valable. Notez que df.keys() est l'appel à la mise en œuvre interne de la dict-comme la structure remettre les clés, qui sont les colonnes. Inexplicable downvotes est la garantie des dommages attendus sur DONC ne vous inquiétez pas
- J'ai été en parler des détails de mise en œuvre de columns attribut. Il ya une heure, j'ai lu au sujet de la Loi de Déméter promotion que l'appelant ne devrait pas dépendre de la navigation à l'intérieur du modèle objet. list(df) fait une conversion de type explicite. Secondaires notables: en effet, les temps d'exécution et la mémoire de l'augmentation de la consommation avec dataframe taille df.keys() méthode fait partie de la dict-comme la nature d'un DataFrame. Notables fait: temps d'exécution pour df.keys() est plutôt constant indépendamment de la dataframe de la taille de la partie de la responsabilité des pandas développeurs.
- Je peux ajouter à ma réponse et de crédit de vous, vu que personne n'a compris ce
- Je peux voir de la valeur dans la réponse qui est donnée ainsi que dans les commentaires - pas besoin de changer quoi que ce soit.
- est df.columns.tolist() le même que df.columns.values.tolist()? l'appel de .values se désintègre à numpy ce qui explique pourquoi il a été plus rapide à l'origine
InformationsquelleAutor EdChum - Reinstate Monica

Fait quelques tests rapides, et peut-être sans surprise, la version intégrée à l'aide de 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

(Je n'aime vraiment le list(dataframe) bien, donc merci EdChum!)

InformationsquelleAutor tegan

46

Son est encore plus simple (par les pandas 0.16.0) :
```
df.columns.tolist()
```
vous donnera les noms de colonne dans une belle liste.

InformationsquelleAutor fixxxer
34
```
>>> list(my_dataframe)
['y', 'gdp', 'cap']
```
À la liste des colonnes d'un dataframe tout en mode débogage, utilisez une compréhension de liste:
```
>>> [c for c in my_dataframe]
['y', 'gdp', 'cap']
```
Par la manière, vous pouvez obtenir une liste triée en utilisant simplement sorted:
```
>>> sorted(my_dataframe)
['cap', 'gdp', 'y']
```
- Serait-ce list(df) de travailler uniquement avec les autoincrement dataframes? Ou faut-il travailler pour tous les dataframes?
- Devrait fonctionner pour tous. Lorsque vous êtes dans le débogueur, cependant, vous avez besoin d'une compréhension de liste [c for c in df].
InformationsquelleAutor Alexander
24

Qui est disponible sous my_dataframe.columns.
- Et, explicitement, comme une liste par header_list = list(my_dataframe.columns)
- ^ Ou mieux encore: df.columns.tolist().
InformationsquelleAutor BrenBarn
18

C'est intéressant mais df.columns.values.tolist() est presque 3 fois plus rapide que df.columns.tolist() mais je pense qu'ils 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
```
- Les Timings ont déjà été abordés dans cette réponse. La raison de cette différence est parce que .values retourne le sous-jacent tableau numpy, et de faire quelque chose avec numpy est presque toujours plus rapide que de faire la même chose avec les pandas directement.
InformationsquelleAutor Anton Protopopov
18

Surpris, je n'ai pas vu cette posté jusqu'à présent, donc je vais juste laisser ça ici.

Étendu Itérable Déballage (python3.5+): [*df] et Amis

Déballage des généralisations (PEP 448) ont été introduites avec Python 3.5. Ainsi, les opérations suivantes sont 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 voulez un set,
```
{*df}
# {'A', 'B', 'C'}
```
Ou, si vous voulez un 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 se convertit à café à la saisie des sons, et bien, cela va consommer votre café de manière plus efficace 😉
P. S.: si la performance est importante, vous voulez le fossé de la
les solutions ci-dessus en faveur de
```
df.columns.to_numpy().tolist()
# ['A', 'B', 'C']
```
Ceci est similaire à Ed Chum
réponse, mais mis à jour pour
v0.24 où .to_numpy() est préférée à l'utilisation de .values. Voir
cette réponse (par moi)
pour plus d'informations.
Contrôle Visuel

Depuis que j'ai vu cette discussion dans d'autres réponses, vous pouvez utiliser l'objet iterable déballage (pas besoin d'explicite dans les boucles).
```
print(*df)
A B C

print(*df, sep='\n')
A
B
C
```
Critique des Autres Méthodes

N'utilisez pas explicite for boucle pour une opération qui peut être fait en une seule ligne (interprétations de la Liste sont d'accord).

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

Prochaine, list(df.columns) et list(df.columns.values) sont mauvaises suggestions (à compter de la version actuelle, v0.24). Les deux Index (renvoyée à partir de df.columns) et des tableaux NumPy (retourné par la df.columns.values) définir .tolist() méthode qui est plus rapide et plus idiomatique.

Enfin, listification c'est à dire, list(df) ne doit être utilisé comme un concis alternative aux méthodes mentionnées ci-dessus.

InformationsquelleAutor cs95
16

Un DataFrame suit le dict-comme la convention de parcourir les “clés” des objets.
```
my_dataframe.keys()
```
Créer une liste de clés/colonnes - méthode de l'objet to_list() et pythonic façon
```
my_dataframe.keys().to_list()
list(my_dataframe.keys())
```
De base itération sur un DataFrame retourne étiquettes de colonne
```
[column for column in my_dataframe]
```
Ne pas convertir un DataFrame dans une liste, juste pour obtenir les étiquettes de colonne. N'arrêtez pas de penser lors de la recherche pour la pratique des exemples de code.
```
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)
```
- Mes tests montrent df.columns est beaucoup plus rapide que df.keys(). Je ne sais pas pourquoi ils ont à la fois une fonction et l'attribut pour la même chose (enfin, ce n'est pas la première fois que je l'ai vu 10 façons différentes de faire quelque chose dans les pandas).
- L'intention de ma réponse était de montrer un couple de façons de requête colonne des étiquettes à partir d'un DataFrame et de mettre en évidence une performance anti-modèle. Néanmoins, j'aime vos commentaires et upvoted votre dernière réponse, car elles donnent de la valeur à partir d'un logiciel point de vue technique.
InformationsquelleAutor Sascha Gottfried
14

Dans le Cahier

Pour l'exploration de données dans le IPython notebook, mon manière préférée est: est-ce
```
sorted(df)
```
Qui va produire un facile à lire par ordre alphabétique de la liste.

Dans un référentiel de code

Dans le code je le trouve plus explicite pour ne
```
df.columns
```
Car il dit à d'autres la lecture de votre code ce que vous faites.
- sorted(df) de modifier l'ordre. À utiliser avec prudence.
- Je ne mentionne cela, même si les", Qui permettra de produire un facile à lire, classés par ordre alphabétique, la liste".
InformationsquelleAutor firelynx

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

InformationsquelleAutor rohit singh

3

comme répondu par Siméon Visser...vous pourriez faire
```
list(my_dataframe.columns.values) 
```
ou
```
list(my_dataframe) # for less typing.
```
Mais je pense que la plupart le sweet spot est:
```
list(my_dataframe.columns)
```
Il est explicite, en même temps pas trop long.
- "Il est clair, en même temps pas trop long." Je suis en désaccord. L'appel de list n'a aucun mérite sauf si vous êtes en l'appelant sur df directement (par exemple, concision). Accéder à la .columns attribut renvoie un Index objet qui a une tolist() méthode définie sur elle, et la vocation qui est la plus idiomatique que listifying la Index. Le mélange des idiomes juste pour le plaisir de l'exhaustivité n'est pas une bonne idée. En va de même pour listifying le tableau que vous obtenez à partir .values.
InformationsquelleAutor Vivek
3

Pour un rapide, soigné, contrôle visuel, essayez ceci:
```
for col in df.columns:
    print col
```
InformationsquelleAutor Joseph True
3

Cela nous donne les noms de colonnes dans une liste:
```
list(my_dataframe.columns)
```
Une autre fonction appelée tolist() peut être utilisée aussi:
```
my_dataframe.columns.tolist()
```
- Cela a déjà été abordés dans d'autres réponses. Votre première solution mélange aussi les idiomes, qui n'est pas une bonne idée. Voir mon comment sous une autre réponse.
InformationsquelleAutor Harikrishna
2

Je sens la question mérite d'explication supplémentaire.

Comme @fixxxer noté, la réponse dépend des pandas version que vous utilisez dans votre projet.
Que vous pouvez obtenir avec pd.__version__ commande.

Si vous êtes pour une raison quelconque, comme moi (sur debian jessie-je utiliser 0.14.1) utilisez une version plus ancienne de pandas que 0.16.0, alors vous devez utiliser:

df.keys().tolist() car il n'est pas df.columns méthode encore mis en œuvre.

L'avantage de cette méthode de clés, c'est qu'elle fonctionne même dans la version la plus récente de pandas, de sorte qu'il est plus universel.
- Le con de touches() est que c'est un appel de fonction plutôt qu'un attribut de recherche, il est donc toujours plus lente. Bien sûr, avec la constante de temps d'accès, personne ne se soucie vraiment de différences de ce genre, mais je pense qu'il vaut la peine de mentionner toute façon; df.colonnes est maintenant un des plus universellement accepté idiome pour accéder aux en-têtes.
InformationsquelleAutor StefanK
1
```
n = []
for i in my_dataframe.columns:
    n.append(i)
print n
```
- veuillez la remplacer par une compréhension de liste.
- changer vos 3 premières lignes de [n for n in dataframe.columns]
- Pourquoi voudriez-vous passer à travers tout ce mal pour une opération, vous pouvez facilement le faire en une seule ligne?
InformationsquelleAutor user21988
0

Même si la solution qui a été prévu ci-dessus est agréable. Je voudrais également s'attendre à quelque chose comme cadre.column_names() est une fonction dans les pandas, mais comme il n'est pas, peut-être qu'il serait bien d'utiliser la syntaxe suivante. C'est en quelque sorte préserve le sentiment que vous êtes à l'aide de pandas, de manière adéquate, par l'appel de la "tolist" la fonction de l'image.les colonnes.tolist()
```
frame.columns.tolist() 
```
InformationsquelleAutor Igor Jakovljevic
-1

Cette solution de listes de toutes les colonnes de votre objet my_dataframe:
```
print(list(my_dataframe))
```
InformationsquelleAutor Sunitha G

Vous devez vous connecter pour publier un commentaire.

Étendu Itérable Déballage (python3.5+): [*df] et Amis

Critique des Autres Méthodes

Dans le Cahier

Dans un référentiel de code

Étendu Itérable Déballage (python3.5+): `[*df]` et Amis