Pandas: divide el dataframe en múltiples marcos de datos por número de filas

Bastante nuevo para los pandas, así que tengan paciencia conmigo …

Tengo un csv enorme con muchas tablas con muchas filas. Me gustaría simplemente dividir cada dataframe en 2 si contiene más de 10 filas.

Si es verdadero, me gustaría que el primer dataframe contenga los primeros 10 y el rest en el segundo dataframe.

¿Hay una función conveniente para esto? He mirado a mi alrededor pero no he encontrado nada útil …

es decir, split_dataframe (df, 2 (if> 10))?

Esto devolverá los DataFrames divididos si se cumple la condición; de lo contrario, devuelva el original y None (que luego deberá manejar por separado). Tenga en cuenta que esto supone que la división solo tiene que suceder una vez por df y que la segunda parte de la división (si es más larga que 10 filas (lo que significa que el original era más larga que 20 filas)) está bien.

 df_new1, df_new2 = df[:10, :], df[10:, :] if len(df) > 10 else df, None 

Tenga en cuenta que también puede usar df.head(10) y df.tail(len(df) - 10) para obtener la parte delantera y trasera según sus necesidades. También puede usar varios enfoques de indexación: puede proporcionar el primer índice de dimensiones si lo desea, como df[:10] lugar de df[:10, :] (aunque me gusta codificar explícitamente las dimensiones que está tomando) . También puede usar df.iloc y df.ix para indexar de manera similar.

df.loc embargo, tenga cuidado al usar df.loc , ya que está basado en tags y la entrada nunca se interpretará como una posición entera . .loc solo funcionaría “accidentalmente” en el caso de que tenga tags de índice que sean enteros que comiencen en 0 sin espacios.

Pero también debe considerar las diversas opciones que ofrecen los pandas para volcar el contenido del DataFrame en HTML y posiblemente también en LaTeX para crear tablas mejor diseñadas para la presentación (en lugar de solo copiar y pegar). Simplemente al buscar en Google la forma de convertir el DataFrame a estos formatos se encuentran muchos tutoriales y consejos para esta aplicación.

No hay una función de conveniencia específica.

Tendrías que hacer algo como:

 first_ten = pd.DataFrame() rest = pd.DataFrame() if df.shape[0] > 10: # len(df) > 10 would also work first_ten = df[:10] rest = df[10:] 

Utilicé esta Lista de Comprensiones para cortar un enorme df en bloques de 100’000:

 size = 100000 list_of_dfs = [df.loc[i:i+size-1,:] for i in range(0, len(df),size)] 

o como generador:

 list_of_dfs = (df.loc[i:i+size-1,:] for i in range(0, len(df),size)) 

Puede utilizar los métodos de cabeza y cola de DataFrame como azúcar sintáctica en lugar de rebanar / loc aquí. Yo uso un tamaño de división de 3; para su ejemplo use headSize = 10

 def split(df, headSize) : hd = df.head(headSize) tl = df.tail(len(df)-headSize) return hd, tl df = pd.DataFrame({ 'A':[2,4,6,8,10,2,4,6,8,10], 'B':[10,-10,0,20,-10,10,-10,0,20,-10], 'C':[4,12,8,0,0,4,12,8,0,0], 'D':[9,10,0,1,3,np.nan,np.nan,np.nan,np.nan,np.nan]}) # Split dataframe into top 3 rows (first) and the rest (second) first, second = split(df, 3) 

Un método basado en np.split :

 df = pd.DataFrame({ 'A':[2,4,6,8,10,2,4,6,8,10], 'B':[10,-10,0,20,-10,10,-10,0,20,-10], 'C':[4,12,8,0,0,4,12,8,0,0], 'D':[9,10,0,1,3,np.nan,np.nan,np.nan,np.nan,np.nan]}) listOfDfs = [df.loc[idx] for idx in np.split(df.index,5)] 

Una pequeña función que utiliza un módulo podría ocuparse de los casos en que la división no es uniforme (por ejemplo, np.split(df.index,4) generará un error).

( Sí, soy consciente de que la pregunta original era algo más específica que esto. Sin embargo, se supone que esto responde a la pregunta en el título ) .

A continuación se muestra una implementación de una función simple que divide un DataFrame en fragmentos y algunos ejemplos de código:

 import pandas as pd def split_dataframe_to_chunks(df, n): df_len = len(df) count = 0 dfs = [] while True: if count > df_len-1: break start = count count += n #print("%s : %s" % (start, count)) dfs.append(df.iloc[start : count]) return dfs # Create a DataFrame with 10 rows df = pd.DataFrame([i for i in range(10)]) # Split the DataFrame to chunks of maximum size 2 split_df_to_chunks_of_2 = split_dataframe_to_chunks(df, 2) print([len(i) for i in split_df_to_chunks_of_2]) # prints: [2, 2, 2, 2, 2] # Split the DataFrame to chunks of maximum size 3 split_df_to_chunks_of_3 = split_dataframe_to_chunks(df, 3) print([len(i) for i in split_df_to_chunks_of_3]) # prints [3, 3, 3, 1] 

Si tiene un dataframe grande y necesita dividirse en un número variable de filas de marcos de datos secundarios, como por ejemplo, cada dataframe secundario tiene un máximo de 4500 filas, esta secuencia de comandos puede ayudar

 max_rows = 4500 dataframes = [] while len(df) > max_rows: top = df[:max_rows] dataframes.append(top) df = df[max_rows:] else: dataframes.append(df) 

A continuación, puede guardar estos marcos de datos:

 for _, frame in enumerate(dataframes): frame.to_csv(str(_)+'.csv', index=False) 

¡Espero que esto ayude a alguien!

El método basado en la lista de comprensión y groupby , que almacena todos los marcos de datos divididos en una variable de lista y se puede acceder utilizando el índice.

Ejemplo:

 ans = [pd.DataFrame(y) for x, y in DF.groupby('column_name', as_index=False)]*** ans[0] ans[0].column_name