¿Cómo soltar una lista de filas del marco de datos de Pandas?

Tengo un marco de datos 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

Entonces quiero soltar filas con ciertos números de secuencia que se indican en una lista, supongamos que aquí se [1,2,4],deja:

                  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

¿Cómo o qué función puede hacer eso?

Use DataFrame.drop y páselo una serie de etiquetas de índice:

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

Tenga en cuenta que puede ser importante utilizar el comando "en el lugar" cuando desee hacer la línea desplegable.

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

Debido a que su pregunta original no devuelve nada, se debe usar este comando. http://pandas.pydata.org/pandas-docs/version/0.17.0/generated/pandas.DataFrame.drop.html

Si el DataFrame es enorme, y el número de filas que se deben eliminar también es grande, entonces la eliminación simple por índice df.drop(df.index[])lleva demasiado tiempo.

En mi caso, tengo un DataFrame de índices múltiples con flotadores 100M rows x 3 colsy necesito eliminar 10kfilas de él. El método más rápido que encontré es, bastante contradictorio, a takelas filas restantes.

Deje indexes_to_dropser una matriz de índices posicionales para soltar ( [1, 2, 4]en la pregunta).

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

En mi caso esto tomó 20.5s, mientras que el simple df.droptomó 5min 27sy consumió mucha memoria. El DataFrame resultante es el mismo.

También puedes pasar a DataFrame.drop la etiqueta en sí (en lugar de Series de etiquetas de índice):

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

Lo que es equivalente a:

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

Resolví esto de una manera más simple, solo en 2 pasos.

Paso 1: Primero forme un marco de datos con filas / datos no deseados.

Paso 2: utilice el índice de este marco de datos no deseado para descartar las filas del marco de datos original.

Ejemplo:

Supongamos que tiene un marco de datos df que tiene tantas columnas como 'Edad', que es un número entero. Ahora supongamos que desea eliminar todas las filas con 'Edad' como número negativo.

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

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

Espero que esto sea mucho más simple y te ayude.

Si quiero soltar una fila que tiene un índice x, digamos , haría lo siguiente:

df = df[df.index != x]

Si quisiera eliminar varios índices (digamos que estos índices están en la lista unwanted_indices), haría:

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

Aquí hay un ejemplo un poco específico que me gustaría mostrar. Supongamos que tiene muchas entradas duplicadas en algunas de sus filas. Si tiene entradas de cadena, podría usar fácilmente los métodos de cadena para encontrar todos los índices que soltar.

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

Y ahora para soltar esas filas usando sus índices

new_df = df.drop(ind_drop)

En un comentario a la respuesta de @ theodros-zelleke, @ j-jones preguntó qué hacer si el índice no es único. Tuve que lidiar con tal situación. Lo que hice fue renombrar los duplicados en el índice antes de llamar drop(), a la:

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

donde rename_duplicates()es una función que definí que pasó por los elementos del índice y renombró los duplicados. Usé el mismo patrón de cambio de nombre que el que se pd.read_csv()usa en las columnas, es decir, "%s.%d" % (name, count)dónde nameestá el nombre de la fila y countcuántas veces se ha producido anteriormente.

Determinar el índice del booleano como se describió anteriormente, por ejemplo

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

puede usar más memoria que determinar el índice usando este método

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

aplicado así

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

Este método es útil cuando se trata de grandes marcos de datos y memoria limitada.

Use solo el argumento Índice para soltar la fila: -

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

Para varias filas: -

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

Considere un marco de datos de ejemplo

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

queremos soltar las filas de índice segunda y tercera.

Enfoque 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

Enfoque 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.