Ik heb gegevens in verschillende kolommen, maar ik weet niet hoe ik deze moet extraheren om ze in een andere variabele op te slaan.
index a b c
1 2 3 4
2 3 4 5
Hoe selecteer ik 'a', 'b'en sla het op in df1?
Ik heb het geprobeerd
df1 = df['a':'b']
df1 = df.ix[:, 'a':'b']
Geen enkele lijkt te werken.
Antwoord 1, autoriteit 100%
De kolomnamen (die strings zijn) kunnen niet worden gesegmenteerd op de manier die u heeft geprobeerd.
Hier heb je een aantal opties. Als u uit de context weet welke variabelen u wilt uitsplitsen, kunt u een weergave van alleen die kolommen retourneren door een lijst door te geven aan de __getitem__syntaxis(de []’s).
df1 = df[['a', 'b']]
Als het van belang is om ze numeriek te indexeren en niet op hun naam (stel dat uw code dit automatisch zou moeten doen zonder de namen van de eerste twee kolommen te kennen), dan kunt u dit in plaats daarvan doen:
df1 = df.iloc[:, 0:2] # Remember that Python does not slice inclusive of the ending index.
Bovendien moet u vertrouwd raken met het idee van een blik in een Pandas-object versus een kopie van dat object. De eerste van de bovenstaande methoden retourneert een nieuwe kopie in het geheugen van het gewenste subobject (de gewenste plakjes).
Soms zijn er echter indexeringsconventies in Panda’s die dit niet doen en u in plaats daarvan een nieuwe variabele geven die alleen verwijst naar hetzelfde stuk geheugen als het subobject of segment in het oorspronkelijke object. Dit gebeurt met de tweede manier van indexeren, dus je kunt deze aanpassen met de .copy()methode om een normale kopie te krijgen. Wanneer dit gebeurt, kan het wijzigen van wat u denkt dat het gesegmenteerde object is, soms het oorspronkelijke object veranderen. Altijd goed om hier naar uit te kijken.
df1 = df.iloc[0, 0:2].copy() # To avoid the case where changing df1 also changes df
Om ilocte gebruiken, moet u de kolomposities (of indices) weten. Aangezien de kolomposities kunnen veranderen, kunt u in plaats van hardcoderende indices de ilocsamen met de functie get_locvan de methode columnsvan het dataframe-object gebruiken om verkrijg kolomindexen.
{df.columns.get_loc(c): c for idx, c in enumerate(df.columns)}
Je kunt dit woordenboek nu gebruiken om toegang te krijgen tot kolommen via namen en met behulp van iloc.
Antwoord 2, autoriteit 9%
Vanaf versie 0.11.0 kunnen kolommen wordengesegmenteerd op de manier die u probeerde met behulp van de .locindexer:
df.loc[:, 'C':'E']
is gelijk aan
df[['C', 'D', 'E']] # or df.loc[:, ['C', 'D', 'E']]
en retourneert de kolommen ctot en met E.
Een demo op een willekeurig gegenereerd DataFrame:
import pandas as pd
import numpy as np
np.random.seed(5)
df = pd.DataFrame(np.random.randint(100, size=(100, 6)),
columns=list('ABCDEF'),
index=['R{}'.format(i) for i in range(100)])
df.head()
Out:
A B C D E F
R0 99 78 61 16 73 8
R1 62 27 30 80 7 76
R2 15 53 80 27 44 77
R3 75 65 47 30 84 86
R4 18 9 41 62 1 82
Om de kolommen van C naar E te krijgen (merk op dat in tegenstelling tot integer slicing, ‘E’ is opgenomen in de kolommen):
df.loc[:, 'C':'E']
Out:
C D E
R0 61 16 73
R1 30 80 7
R2 80 27 44
R3 47 30 84
R4 41 62 1
R5 5 58 0
...
Hetzelfde werkt voor het selecteren van rijen op basis van labels. Haal de rijen ‘R6’ tot ‘R10’ uit die kolommen:
df.loc['R6':'R10', 'C':'E']
Out:
C D E
R6 51 27 31
R7 83 19 18
R8 11 67 65
R9 78 27 29
R10 7 16 94
.locaccepteert ook een Booleaanse array, zodat je de kolommen kunt selecteren waarvan de corresponderende invoer in de array Trueis. df.columns.isin(list('BCD'))retourneert bijvoorbeeld array([False, True, True, True, False, False], dtype=bool)– True als de kolomnaam in de lijst staat ['B', 'C', 'D']; Onwaar, anders.
df.loc[:, df.columns.isin(list('BCD'))]
Out:
B C D
R0 78 61 16
R1 27 30 80
R2 53 80 27
R3 65 47 30
R4 9 41 62
R5 78 5 58
...
Antwoord 3, autoriteit 6%
Ervan uitgaande dat uw kolomnamen (df.columns) ['index','a','b','c']zijn, dan zijn de gewenste gegevens is in de
derde en vierde kolom. Als u hun namen niet weet wanneer uw script wordt uitgevoerd, kunt u dit doen
newdf = df[df.columns[2:4]] # Remember, Python is zero-offset! The "third" entry is at slot two.
Zoals EMS aangeeft in zijn antwoord, df.ixsnijdt kolommen iets beknopter, maar de .columnsslicing-interface kan natuurlijker zijn, omdat deze de vanille-eendimensionale Python-lijst-indexering/slicing-syntaxis gebruikt .
Waarschuwing: 'index'is een slechte naam voor een DataFrame-kolom. Datzelfde label wordt ook gebruikt voor het echte df.indexattribuut, een Indexarray. Dus uw kolom wordt geretourneerd door df['index']en de echte DataFrame-index wordt geretourneerd door df.index. Een Indexis een speciaal soort Seriesdie is geoptimaliseerd voor het opzoeken van de waarden van de elementen. Voor df.index is het voor het opzoeken van rijen op hun label. Dat df.columns-kenmerk is ook een pd.Index-array, voor het opzoeken van kolommen aan de hand van hun labels.
Antwoord 4, autoriteit 4%
In de nieuwste versie van Panda’s is er een eenvoudige manier om precies dit te doen. Kolomnamen (dit zijn tekenreeksen) kunnenworden gesegmenteerd op elke gewenste manier.
columns = ['b', 'c']
df1 = pd.DataFrame(df, columns=columns)
Antwoord 5, autoriteit 3%
In [39]: df
Out[39]:
index a b c
0 1 2 3 4
1 2 3 4 5
In [40]: df1 = df[['b', 'c']]
In [41]: df1
Out[41]:
b c
0 3 4
1 4 5
Antwoord 6, autoriteit 2%
Met Panda’s,
met kolomnamen
dataframe[['column1','column2']]
om te selecteren op iloc en specifieke kolommen met indexnummer:
dataframe.iloc[:,[1,2]]
met loc kunnen kolomnamen worden gebruikt als
dataframe.loc[:,['column1','column2']]
Antwoord 7
U kunt een lijst met te verwijderen kolommen opgeven en het DataFrame terugsturen met alleen de benodigde kolommen met behulp van de functie drop()op een Pandas DataFrame.
Gewoon zeggen
colsToDrop = ['a']
df.drop(colsToDrop, axis=1)
zou een DataFrame retourneren met alleen de kolommen ben c.
De drop-methode is gedocumenteerd hier.
Antwoord 8
Ik vond deze methode erg handig:
# iloc[row slicing, column slicing]
surveys_df.iloc [0:3, 1:4]
Meer details vindt u hier.
Antwoord 9
Vanaf 0.21.0 wordt het gebruik van .locof []met een lijst met een of meer ontbrekende labels afgeschaft ten gunste van .reindex. Het antwoord op uw vraag is dus:
df1 = df.reindex(columns=['b','c'])
In eerdere versies zou het gebruik van .loc[list-of-labels]werken zolang ten minste één van de sleutels werd gevonden (anders zou het een KeyError). Dit gedrag is verouderd en geeft nu een waarschuwingsbericht weer. Het aanbevolen alternatief is om .reindex()te gebruiken.
Lees meer op Indexeren en selecteren van gegevens.
Antwoord 10
U kunt de methode pandas.DataFrame.filtergebruiken om kolommen als volgt te filteren of opnieuw te ordenen:
df1 = df.filter(['a', 'b'])
Dit is ook erg handig als je methoden aan het koppelen bent.
Antwoord 11
Je kunt panda’s gebruiken.
Ik maak het DataFrame:
import pandas as pd
df = pd.DataFrame([[1, 2,5], [5,4, 5], [7,7, 8], [7,6,9]],
index=['Jane', 'Peter','Alex','Ann'],
columns=['Test_1', 'Test_2', 'Test_3'])
Het DataFrame:
Test_1 Test_2 Test_3
Jane 1 2 5
Peter 5 4 5
Alex 7 7 8
Ann 7 6 9
Om een of meer kolommen op naam te selecteren:
df[['Test_1', 'Test_3']]
Test_1 Test_3
Jane 1 5
Peter 5 5
Alex 7 8
Ann 7 9
U kunt ook het volgende gebruiken:
df.Test_2
En je krijgt kolom Test_2:
Jane 2
Peter 4
Alex 7
Ann 6
Je kunt ook kolommen en rijen uit deze rijen selecteren met .loc(). Dit wordt “slicing”genoemd. Merk op dat ik van kolom Test_1naar Test_3:
df.loc[:, 'Test_1':'Test_3']
De “Plak” is:
Test_1 Test_2 Test_3
Jane 1 2 5
Peter 5 4 5
Alex 7 7 8
Ann 7 6 9
En als je gewoon Peteren Annuit de kolommen Test_1en Test_3wilt:
df.loc[['Peter', 'Ann'], ['Test_1', 'Test_3']]
Je krijgt:
Test_1 Test_3
Peter 5 5
Ann 7 9
Antwoord 12
Als je één element per rij-index en kolomnaam wilt krijgen, kun je dat op dezelfde manier doen als df['b'][0]. Het is zo eenvoudig als je je kunt voorstellen.
Of je kunt df.ix[0,'b']gebruiken – gemengd gebruik van index en label.
Opmerking:Sinds v0.20 is ixafgeschaft ten gunste van loc/ iloc.
Antwoord 13
Een andere en gemakkelijke aanpak: rijen herhalen
Iterows gebruiken
df1 = pd.DataFrame() # Creating an empty dataframe
for index,i in df.iterrows():
df1.loc[index, 'A'] = df.loc[index, 'A']
df1.loc[index, 'B'] = df.loc[index, 'B']
df1.head()
Antwoord 14
De verschillende benaderingen die in de vorige antwoorden zijn besproken, zijn gebaseerd op de veronderstelling dat de gebruiker kolomindexen kent om op te droppen of subsets op te zetten, of dat de gebruiker een dataframe wil subsetten met behulp van een reeks kolommen (bijvoorbeeld tussen ‘C’ : ‘E’).
pandas.DataFrame.drop()is zeker een optie om gegevens te subsetten op basis van een lijst met kolommen die door de gebruiker zijn gedefinieerd (hoewel u erop moet letten dat u altijd een kopie van het dataframe en inplaceparameters mogen niet worden ingesteld op True!!)
Een andere optie is om pandas.columns.difference()te gebruiken, wat een set verschil maakt voor kolomnamen, en een indextype array retourneert met de gewenste kolommen. Hier volgt de oplossing:
df = pd.DataFrame([[2,3,4], [3,4,5]], columns=['a','b','c'], index=[1,2])
columns_for_differencing = ['a']
df1 = df.copy()[df.columns.difference(columns_for_differencing)]
print(df1)
De uitvoer zou zijn:
b c
1 3 4
2 4 5
Antwoord 15
df[['a', 'b']] # Select all rows of 'a' and 'b'column
df.loc[0:10, ['a', 'b']] # Index 0 to 10 select column 'a' and 'b'
df.loc[0:10, 'a':'b'] # Index 0 to 10 select column 'a' to 'b'
df.iloc[0:10, 3:5] # Index 0 to 10 and column 3 to 5
df.iloc[3, 3:5] # Index 3 of column 3 to 5
Antwoord 16
U kunt ook df.pop gebruiken ():
>>> df = pd.DataFrame([('falcon', 'bird', 389.0),
... ('parrot', 'bird', 24.0),
... ('lion', 'mammal', 80.5),
... ('monkey', 'mammal', np.nan)],
... columns=('name', 'class', 'max_speed'))
>>> df
name class max_speed
0 falcon bird 389.0
1 parrot bird 24.0
2 lion mammal 80.5
3 monkey mammal
>>> df.pop('class')
0 bird
1 bird
2 mammal
3 mammal
Name: class, dtype: object
>>> df
name max_speed
0 falcon 389.0
1 parrot 24.0
2 lion 80.5
3 monkey NaN
Gebruik a.u.b. df.pop(c).
Antwoord 17
Probeer pandas.DataFrame.gette gebruiken (zie de documentatie):
import pandas as pd
import numpy as np
dates = pd.date_range('20200102', periods=6)
df = pd.DataFrame(np.random.randn(6, 4), index=dates, columns=list('ABCD'))
df.get(['A', 'C'])
Antwoord 18
Om meerdere kolommen te selecteren, extraheert u ze en bekijkt u ze daarna: dfheette voorheen dataframe, maak vervolgens een nieuw dataframe df1en selecteer de kolommen A t/m D die u wilt uitpakken en bekijken.
df1 = pd.DataFrame(data_frame, columns=['Column A', 'Column B', 'Column C', 'Column D'])
df1
Alle vereiste kolommen worden weergegeven!
Antwoord 19
Ik heb daar verschillende antwoorden op gezien, maar één bleef me onduidelijk. Hoe zou u die kolommen van interesse selecteren?
Het antwoord daarop is dat als je ze in een lijst hebt verzameld, je gewoon naar de kolommen kunt verwijzen met behulp van de lijst.
Voorbeeld
print(extracted_features.shape)
print(extracted_features)
(63,)
['f000004' 'f000005' 'f000006' 'f000014' 'f000039' 'f000040' 'f000043'
'f000047' 'f000048' 'f000049' 'f000050' 'f000051' 'f000052' 'f000053'
'f000054' 'f000055' 'f000056' 'f000057' 'f000058' 'f000059' 'f000060'
'f000061' 'f000062' 'f000063' 'f000064' 'f000065' 'f000066' 'f000067'
'f000068' 'f000069' 'f000070' 'f000071' 'f000072' 'f000073' 'f000074'
'f000075' 'f000076' 'f000077' 'f000078' 'f000079' 'f000080' 'f000081'
'f000082' 'f000083' 'f000084' 'f000085' 'f000086' 'f000087' 'f000088'
'f000089' 'f000090' 'f000091' 'f000092' 'f000093' 'f000094' 'f000095'
'f000096' 'f000097' 'f000098' 'f000099' 'f000100' 'f000101' 'f000103']
Ik heb de volgende lijst/NumPy-array extracted_features, met 63 kolommen. De originele dataset heeft 103 kolommen, en ik zou precies die willen extraheren, dan zou ik
dataset[extracted_features]
En je krijgt dit
Dit zou je vaak gebruiken in machine learning(meer specifiek, bij het selecteren van functies ). Ik zou ook andere manieren willen bespreken, maar ik denk dat dat al is behandeld door andere Stack Overflower-gebruikers.
Antwoord 20
def get_slize(dataframe, start_row, end_row, start_col, end_col):
assert len(dataframe) > end_row and start_row >= 0
assert len(dataframe.columns) > end_col and start_col >= 0
list_of_indexes = list(dataframe.columns)[start_col:end_col]
ans = dataframe.iloc[start_row:end_row][list_of_indexes]
return ans
Gebruik gewoon deze functie
Antwoord 21
Om sommige kolommen uit te sluiten, kunt u ze in de kolomindex neerzetten. Bijvoorbeeld:
A B C D
0 1 10 100 1000
1 2 20 200 2000
Selecteer alle kolommen behalve één:
df[df.columns.drop('C')]
Uitvoer:
A B D
0 1 10 1000
1 2 20 2000
Selecteer alles behalve twee:
df[df.columns.drop(['B', 'D'])]
Uitvoer:
A C
0 1 100
1 2 200