Jak usunąć listę wierszy ze ramki danych Pandas?

Mam ramkę danych 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

Następnie chcę upuścić wiersze z pewnymi numerami sekwencji, które wskazano na liście, przypuśćmy, że tutaj [1,2,4],pozostało:

                  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

Jak lub jaką funkcję może to zrobić?

Użyj DataFrame.drop i przekaż mu serię etykiet indeksu:

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

Zauważ, że może być ważne użycie polecenia „inplace”, gdy chcesz wykonać drop-line.

df.drop(df.index[[1,3]], inplace=True)

Ponieważ pierwotne pytanie nic nie zwraca, należy użyć tego polecenia. http://pandas.pydata.org/pandas-docs/version/0.17.0/generated/pandas.DataFrame.drop.html

Jeśli DataFrame jest ogromna, a liczba wierszy do upuszczenia jest również duża, zwykłe upuszczanie według indeksu df.drop(df.index[])zajmuje zbyt dużo czasu.

W moim przypadku mam wielokrotnie indeksowaną ramkę danych typu float 100M rows x 3 colsi muszę z niej usunąć 10kwiersze. Najszybszą metodą, jaką znalazłem, jest, całkiem nieintuicyjnie, do takepozostałych wierszy.

Niech indexes_to_dropbędzie tablicą indeksów pozycyjnych do usunięcia ( [1, 2, 4]w pytaniu).

indexes_to_keep = set(range(df.shape[0])) - set(indexes_to_drop)
df_sliced = df.take(list(indexes_to_keep))

W moim przypadku zajęło to 20.5s, podczas gdy proste df.dropzajęło 5min 27si pochłonęło dużo pamięci. Wynikowa ramka danych jest taka sama.

Można również przejść do DataFrame.drop ten sam label (zamiast serii etykiet Index):

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

Co odpowiada:

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

Rozwiązałem to w prostszy sposób - tylko w 2 krokach.

Krok 1: Najpierw utwórz ramkę danych z niechcianymi wierszami / danymi.

Krok 2: Użyj indeksu tej niechcianej ramki danych, aby usunąć wiersze z oryginalnej ramki danych.

Przykład:

Załóżmy, że masz ramkę danych df, która ma tyle kolumn, w tym „Wiek”, który jest liczbą całkowitą. Powiedzmy, że chcesz upuścić wszystkie wiersze z „Wiek” jako liczbą ujemną.

Krok 1: df_age_negative = df [df ['Age'] <0]

Krok 2: df = df.drop (df_age_negative.index, axis = 0)

Mam nadzieję, że jest to o wiele prostsze i pomaga.

Jeśli chcę upuścić wiersz, który powiedzmy indeks x, zrobiłbym następujące:

df = df[df.index != x]

Gdybym chciał usunąć wiele indeksów (powiedzmy, że te indeksy są na liście unwanted_indices), zrobiłbym:

desired_indices = [i for i in len(df.index) if i not in unwanted_indices]
desired_df = df.iloc[desired_indices]

Oto nieco konkretny przykład, który chciałbym pokazać. Powiedz, że masz wiele zduplikowanych wpisów w niektórych swoich wierszach. Jeśli masz wpisy ciągu, możesz łatwo użyć metod ciągu, aby znaleźć wszystkie indeksy do usunięcia.

ind_drop = df[df['column_of_strings'].apply(lambda x: x.startswith('Keyword'))].index

A teraz upuść te wiersze za pomocą ich indeksów

new_df = df.drop(ind_drop)

W komentarzu do odpowiedzi @ theodros-zelleke @ j-jones zapytał, co zrobić, jeśli indeks nie jest unikalny. Musiałem poradzić sobie z taką sytuacją. Przed wywołaniem zmieniłem nazwę duplikatów w indeksie drop()a la:

dropped_indexes = <determine-indexes-to-drop>
df.index = rename_duplicates(df.index)
df.drop(df.index[dropped_indexes], inplace=True)

gdzie rename_duplicates()jest funkcja, którą zdefiniowałem, która przeszła przez elementy indeksu i zmieniła nazwę duplikatów. Użyłem tego samego wzorca zmiany nazwy, co pd.read_csv()w kolumnach, tzn. "%s.%d" % (name, count)Gdzie namejest nazwą wiersza i countile razy poprzednio wystąpił.

Określanie indeksu na podstawie wartości logicznej, jak opisano powyżej, np

df[df['column'].isin(values)].index

może wymagać więcej pamięci niż określanie indeksu przy użyciu tej metody

pd.Index(np.where(df['column'].isin(values))[0])

zastosowane w ten sposób

df.drop(pd.Index(np.where(df['column'].isin(values))[0]), inplace = True)

Ta metoda jest przydatna w przypadku dużych ramek danych i ograniczonej pamięci.

Użyj tylko argumentu Argument, aby upuścić wiersz: -

df.drop(index = 2, inplace = True)

Dla wielu rzędów: -

df.drop(index=[1,3], inplace = True)

Rozważ przykładową ramkę danych

df =     
index    column1
0           00
1           10
2           20
3           30

chcemy upuścić 2. i 3. wiersz indeksu.

Podejście 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

Podejście 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.