Ik wil een lijst met de kolomkoppen van een Pandas Dataframe krijgen. Het dataframe komt uit de gebruikersinvoer, dus ik weet niet hoeveel kolommen er zullen zijn of wat ze zullen worden genoemd.
Bijvoorbeeld, als ik een dataframe als volgt heb:
>>> 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
Ik zou een lijst als volgt krijgen:
>>> header_list
['y', 'gdp', 'cap']
Antwoord 1, Autoriteit 100%
U kunt de waarden als een lijst krijgen door:
list(my_dataframe.columns.values)
Ook kunt u gewoon gebruiken: (zoals weergegeven in ED CHULS ANTWOORD ):
list(my_dataframe)
Antwoord 2, Autoriteit 25%
Er is een ingebouwde methode die de meest performant is:
my_dataframe.columns.values.tolist()
.columnsRetourneert een index, .columns.valuesRetourneert een array en dit heeft een helperfunctie .tolistom een lijst te retourneren.
Als de uitvoering niet zo belangrijk is voor u, Indexobjecten definiëren een .tolist()-methode die u rechtstreeks kunt bellen:
my_dataframe.columns.tolist()
Het verschil in prestaties is duidelijk:
%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)
Voor degenen die een hekel hebben aan typen, je kunt gewoon listbellen op df, als volgt:
list(df)
Antwoord 3, autoriteit 5%
Heb wat snelle tests gedaan en het is misschien niet verwonderlijk dat de ingebouwde versie met dataframe.columns.values.tolist()de snelste is:
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
(Ik vind de list(dataframe)echter nog steeds erg leuk, dus bedankt EdChum!)
Antwoord 4, autoriteit 3%
Het wordt nog eenvoudiger (door panda’s 0.16.0):
df.columns.tolist()
geeft u de kolomnamen in een mooie lijst.
Antwoord 5, autoriteit 2%
>>> list(my_dataframe)
['y', 'gdp', 'cap']
Gebruik een lijstbegrip om de kolommen van een dataframe weer te geven in de foutopsporingsmodus:
>>> [c for c in my_dataframe]
['y', 'gdp', 'cap']
Trouwens, je kunt een gesorteerde lijst krijgen door simpelweg sortedte gebruiken:
>>> sorted(my_dataframe)
['cap', 'gdp', 'y']
Antwoord 6, autoriteit 2%
Het verbaast me dat ik dit tot nu toe niet heb gezien, dus ik laat het hier maar achter.
Extended Iterable Unpacking (python3.5+): [*df]en vrienden
Uitpakken van generalisaties (PEP 448)is geïntroduceerd met Python 3.5. De volgende bewerkingen zijn dus allemaal mogelijk.
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
Als je een listwilt….
[*df]
# ['A', 'B', 'C']
Of, als je een setwilt,
{*df}
# {'A', 'B', 'C'}
Of, als je een tuplewilt,
*df, # Please note the trailing comma
# ('A', 'B', 'C')
Of, als u het resultaat ergens wilt opslaan,
*cols, = df # A wild comma appears, again
cols
# ['A', 'B', 'C']
… als jij het soort persoon bent dat koffie omzet in typgeluiden, nou, dit gaat je koffie efficiënter consumeren;)
P.S.: als prestaties belangrijk zijn, wil je de
oplossingen hierboven in het voordeel vandf.columns.to_numpy().tolist() # ['A', 'B', 'C']Dit is vergelijkbaar met Ed Chum’s
antwoord, maar bijgewerkt voor
v0.24 waarbij.to_numpy()de voorkeur heeft boven het gebruik van.values. Zien
dit antwoord(door mij)
voor meer informatie.
Visuele controle
Aangezien ik heb gezien dat dit in andere antwoorden is besproken, kunt u iterable uitpakken gebruiken (geen behoefte aan expliciete lussen).
print(*df)
A B C
print(*df, sep='\n')
A
B
C
Kritiek van andere methoden
Gebruik geen expliciete for-lus voor een bewerking die in een enkele regel kan worden uitgevoerd (Lijstbegrippen zijn oké).
Vervolgens blijft het gebruik van sorted(df)de oorspronkelijke volgordevan de kolommen niet behouden. Gebruik daarvoor in plaats daarvan list(df).
Vervolgens zijn list(df.columns)en list(df.columns.values)slechte suggesties (vanaf de huidige versie, v0.24). Zowel Index(geretourneerd door df.columns) als NumPy-arrays (geretourneerd door df.columns.values) definiëren .tolist()methode die sneller en meer idiomatisch is.
Ten slotte mag lijstvorming, d.w.z. list(df)alleen worden gebruikt als een beknopt alternatief voor de bovengenoemde methoden voor python <= 3.4 waar uitgebreid uitpakken niet beschikbaar is.
Antwoord 7
Dat is beschikbaar als my_dataframe.columns.
Antwoord 8
Het is interessant, maar df.columns.values.tolist()is bijna 3 keer sneller dan df.columns.tolist()maar ik dacht dat ze hetzelfde zijn :
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
Antwoord 9
Een DataFramevolgt de dict-achtige conventie van itereren over de “sleutels” van de objecten.
my_dataframe.keys()
Maak een lijst met sleutels/kolommen – objectmethode to_list()en pythonische manier
my_dataframe.keys().to_list()
list(my_dataframe.keys())
Basisiteratieop een DataFrame geeft kolomlabels terug
[column for column in my_dataframe]
Converteer een DataFrame niet naar een lijst, alleen om de kolomlabels te krijgen. Stop niet met nadenken terwijl u op zoek bent naar handige codevoorbeelden.
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)
Antwoord 10
In de notebook
Voor gegevensverkenning in de IPython-notebook is dit mijn voorkeursmanier:
sorted(df)
die een eenvoudig te lezen alfabetisch bestelde lijst produceert.
in een code-repository
in code Ik vind het meer expliciet om te doen
df.columns
Omdat het vertelt dat anderen uw code lezen wat u aan het doen bent.
Antwoord 11
%%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)
Antwoord 12
Dit geeft ons de namen van kolommen in een lijst:
list(my_dataframe.columns)
Een andere functie genaamd Tolist () kan ook worden gebruikt:
my_dataframe.columns.tolist()
Antwoord 13
Zoals beantwoord door Simeon Visser … kunt u
list(my_dataframe.columns.values)
of
list(my_dataframe) # for less typing.
Maar ik denk dat de beste plek is:
list(my_dataframe.columns)
Het is expliciet, en tegelijkertijd niet onnodig lang.
Antwoord 14
Probeer dit voor een snelle, nette, visuele controle:
for col in df.columns:
print col
Antwoord 15
Ik vind dat een vraag extra uitleg verdient.
Zoals @fixxxer opmerkte, hangt het antwoord af van de panda-versie die je in je project gebruikt.
Die je kunt krijgen met de opdracht pd.__version__.
Als je om de een of andere reden zoals ik (op debian jessie gebruik ik 0.14.1) een oudere versie van panda’s dan 0.16.0 gebruikt, dan moet je het volgende gebruiken:
df.keys().tolist()omdat er nog geen df.columnsmethode is geïmplementeerd.
Het voordeel van deze methode met sleutels is dat het zelfs werkt in nieuwere versies van panda’s, dus het is universeler.
Antwoord 16
list(df.columns)
Dit geeft je de lijst met kolomnamen van een dataframe df.
Antwoord 17
n = []
for i in my_dataframe.columns:
n.append(i)
print n
Antwoord 18
Ook al is de oplossing die hierboven werd gegeven leuk. Ik zou ook verwachten dat iets als frame.column_names() een functie is in panda’s, maar aangezien dit niet het geval is, zou het misschien leuk zijn om de volgende syntaxis te gebruiken. Het behoudt op de een of andere manier het gevoel dat je panda’s op de juiste manier gebruikt door de functie “tolist” aan te roepen: frame.columns.tolist()
frame.columns.tolist()
Antwoord 19
Als het dataframe toevallig een index of multiindex heeft en u wilt dat die ook als kolomnamen zijn:
names = list(filter(None, df.index.names + df.columns.values.tolist()))
Het vermijdt bellen Reset_Index () die een onnodige prestatie-treffer heeft voor een dergelijke eenvoudige bediening.
Ik heb dit vaker ondervinden omdat ik gegevens uit databases shuttled, waar de Dataframe-index kaarten naar een primaire / unieke sleutel kaarten, maar is echt gewoon een andere “kolom” voor mij. Het zou waarschijnlijk logisch zijn voor Panda’s om een ingebouwde methode te hebben voor zoiets (totaal mogelijk dat ik het heb gemist).
Antwoord 20
Deze oplossing vermeldt alle kolommen van uw object My_Dataframe:
print(list(my_dataframe))