Ik heb een dataframe DF:
>>> df
sales discount net_sales cogs
STK_ID RPT_Date
600141 20060331 2.709 NaN 2.709 2.245
20060630 6.590 NaN 6.590 5.291
20060930 10.103 NaN 10.103 7.981
20061231 15.915 NaN 15.915 12.686
20070331 3.196 NaN 3.196 2.710
20070630 7.907 NaN 7.907 6.459
Dan wil ik rijen dalen met bepaalde sequentienummers die in een lijst zijn aangegeven, verstaat hier [1,2,4],dan links:
sales discount net_sales cogs
STK_ID RPT_Date
600141 20060331 2.709 NaN 2.709 2.245
20061231 15.915 NaN 15.915 12.686
20070630 7.907 NaN 7.907 6.459
Hoe of welke functie kan dat doen?
Antwoord 1, Autoriteit 100%
Gebruik dataframe.drop en passeer het een reeks index Labels:
In [65]: df
Out[65]:
one two
one 1 4
two 2 3
three 3 2
four 4 1
In [66]: df.drop(df.index[[1,3]])
Out[66]:
one two
one 1 4
three 3 2
Antwoord 2, Autoriteit 30%
Merk op dat het belangrijk kan zijn om de opdracht “Inlave” te gebruiken wanneer u de druppel in de rij wilt doen.
df.drop(df.index[[1,3]], inplace=True)
Omdat uw oorspronkelijke vraag niets teruggeeft, moet dit commando worden gebruikt.
http://pandas.pydata.org/pandas-docs/ versie/0.17.0/generated/pandas.DataFrame.drop.html
Antwoord 3, autoriteit 15%
Als het DataFrame enorm is, en het aantal te verwijderen rijen is ook groot, dan kost het eenvoudig neerzetten door index df.drop(df.index[])te veel tijd.
In mijn geval heb ik een multi-geïndexeerd DataFrame van floats met 100M rows x 3 cols, en ik moet er 10krijen uit verwijderen. De snelste methode die ik heb gevonden, is, nogal contra-intuïtief, om de resterende rijen take.
Laat indexes_to_dropeen reeks positionele indexen zijn om te laten vallen ([1, 2, 4]in de vraag).
indexes_to_keep = set(range(df.shape[0])) - set(indexes_to_drop)
df_sliced = df.take(list(indexes_to_keep))
In mijn geval kostte dit 20.5s, terwijl het simpele df.drop5min 27skostte en veel geheugen in beslag nam. Het resulterende DataFrame is hetzelfde.
Antwoord 4, autoriteit 11%
U kunt ook doorgeven aan DataFrame.drophet label zelf(in plaats van Reeks indexlabels):
In[17]: df
Out[17]:
a b c d e
one 0.456558 -2.536432 0.216279 -1.305855 -0.121635
two -1.015127 -0.445133 1.867681 2.179392 0.518801
In[18]: df.drop('one')
Out[18]:
a b c d e
two -1.015127 -0.445133 1.867681 2.179392 0.518801
Wat gelijk is aan:
In[19]: df.drop(df.index[[0]])
Out[19]:
a b c d e
two -1.015127 -0.445133 1.867681 2.179392 0.518801
Antwoord 5, autoriteit 8%
Ik heb dit op een eenvoudigere manier opgelost – slechts in 2 stappen.
-
Maak een dataframe met ongewenste rijen/gegevens.
-
Gebruik de index van dit ongewenste dataframe om de rijen uit het oorspronkelijke dataframe te verwijderen.
Voorbeeld:
Stel dat je een dataframe df hebt met evenveel kolommen, inclusief ‘Leeftijd’, wat een geheel getal is. Stel nu dat u alle rijen met ‘Leeftijd’ als negatief getal wilt laten vallen.
df_age_negative = df[ df['Age'] < 0 ] # Step 1
df = df.drop(df_age_negative.index, axis=0) # Step 2
Ik hoop dat dit veel eenvoudiger is en je helpt.
Antwoord 6, autoriteit 4%
Als ik een rij wil laten vallen die bijvoorbeeld index xheeft, zou ik het volgende doen:
df = df[df.index != x]
Als ik meerdere indices zou willen laten vallen (stel dat deze indices in de lijst unwanted_indicesstaan), zou ik het volgende doen:
desired_indices = [i for i in len(df.index) if i not in unwanted_indices]
desired_df = df.iloc[desired_indices]
Antwoord 7, autoriteit 2%
Hier is een beetje specifiek voorbeeld dat ik graag wil laten zien. Stel dat u veel dubbele vermeldingen in sommige van uw rijen heeft. Als je string-items hebt, kun je gemakkelijk string-methoden gebruiken om alle indexen te vinden die moeten worden verwijderd.
ind_drop = df[df['column_of_strings'].apply(lambda x: x.startswith('Keyword'))].index
En nu om die rijen te verwijderen met behulp van hun indexen
new_df = df.drop(ind_drop)
Antwoord 8
In een reactie op het antwoord van @theodros-zelleke vroeg @j-jones wat te doen als de index niet uniek is. Ik heb met zo’n situatie te maken gehad. Wat ik deed was de duplicaten in de index hernoemen voordat ik drop()riep, a la:
dropped_indexes = <determine-indexes-to-drop>
df.index = rename_duplicates(df.index)
df.drop(df.index[dropped_indexes], inplace=True)
waar rename_duplicates()een functie is die ik heb gedefinieerd en die door de elementen van index ging en de duplicaten hernoemde. Ik gebruikte hetzelfde hernoemingspatroon als pd.read_csv()gebruikt voor kolommen, dwz "%s.%d" % (name, count), waarbij nameis de naam van de rij en countis hoe vaak het eerder is voorgekomen.
Antwoord 9
Bepalen van de index uit de boolean zoals hierboven beschreven, bijv.
df[df['column'].isin(values)].index
kan meer geheugen in beslag nemen dan het bepalen van de index met deze methode
pd.Index(np.where(df['column'].isin(values))[0])
leuk geappt
df.drop(pd.Index(np.where(df['column'].isin(values))[0]), inplace = True)
Deze methode is handig bij het omgaan met grote dataframes en beperkt geheugen.
Antwoord 10
Gebruik alleen de index-arg om de rij te laten vallen: –
df.drop(index = 2, inplace = True)
Voor meerdere rijen: –
df.drop(index=[1,3], inplace = True)
Antwoord 11
Bekijk de volgende dataframe DF
df
column1 column2 column3
0 1 11 21
1 2 12 22
2 3 13 23
3 4 14 24
4 5 15 25
5 6 16 26
6 7 17 27
7 8 18 28
8 9 19 29
9 10 20 30
Laten we alle rijen laten vallen met een oneven getal in kolom1
Maak een lijst met alle elementen in kolom1 en houd alleen die elementen die even getallen zijn (de elementen die u niet wilt laten vallen)
keep_elements = [x for x in df.column1 if x%2==0]
Alle rijen met de waarden [2, 4, 6, 8, 10]in de kolom1 worden behouden of niet gevallen.
df.set_index('column1',inplace = True)
df.drop(df.index.difference(keep_elements),axis=0,inplace=True)
df.reset_index(inplace=True)
We maken de kolom1 als index en vallen alle rijen die niet nodig zijn. Dan resetten we de index terug.
df
column1 column2 column3
0 2 12 22
1 4 14 24
2 6 16 26
3 8 18 28
4 10 20 30
Antwoord 12
Overweeg een voorbeeld dataframe
df =
index column1
0 00
1 10
2 20
3 30
We willen de 2e en 3e indexrijen laten vallen.
benadering 1:
df = df.drop(df.index[2,3])
or
df.drop(df.index[2,3],inplace=True)
print(df)
df =
index column1
0 00
3 30
#This approach removes the rows as we wanted but the index remains unordered
benadering 2
df.drop(df.index[2,3],inplace=True,ignore_index=True)
print(df)
df =
index column1
0 00
1 30
#This approach removes the rows as we wanted and resets the index.
Antwoord 13
Om rijen met indices 1, 2, 4 te laten vallen, kunt u gebruiken:
df[~df.index.isin([1, 2, 4])]
De Tilde-operator ~Ontkent het resultaat van de methode isin. Een andere optie is om indices te laten vallen:
df.loc[df.index.drop([1, 2, 4])]
Antwoord 14
Zoals Dennis Golomazov’s antwoord suggereert, met dropom rijen te laten vallen. U kunt selecteren om rijen in plaats daarvan te houden. Laten we zeggen dat je een lijst met rijindices hebt om te laten vallen genaamd indices_to_drop. U kunt het als volgt naar een masker converteren:
mask = np.ones(len(df), bool)
mask[indices_to_drop] = False
U kunt deze index direct gebruiken:
df_new = df.iloc[mask]
Het leuke van deze methode is dat maskuit elke bron kan komen: het kan een voorwaarde zijn waarbij veel kolommen betrokken zijn, of iets anders.
Het leuke is dat je de index van het originele DataFrame helemaal niet nodig hebt, dus het maakt niet uit of de index uniek is of niet.
Het nadeel is natuurlijk dat je met deze methode de drop-in-place niet kunt doen.