Pandas: split dataframe en plusieurs dataframes par le nombre de lignes

assez nouvelle pour les pandas afin de garder avec moi...

J'ai un énorme csv avec beaucoup de tables avec le nombre de lignes. Je voudrais simplement diviser chaque dataframe en 2 si elle contient plus de 10 lignes.

Si c'est vrai, j'aimerais que le premier dataframe pour contenir les 10 premiers et le reste dans la deuxième dataframe.

Est-il une fonction pratique? J'ai regardé mais rien trouvé d'utile...

c'est à dire split_dataframe(df, 2 (> 10))?

Puis-je vous demander pourquoi?
Im la construction d'un PowerPoint pont et coller les données à partir de la df pour un graphique sur chaque diapositive, et des graphiques avec plus de 10 lignes devenir illisible.

OriginalL'auteur Boosted_d16 | 2014-08-13

  1. 14

    Ce sera le retour de la scission DataFrames si la condition est remplie, sinon retour à l'original et None (qui vous serait alors nécessaire de gérer séparément). Notez que cela suppose la séparation n'a qu'à se produire une fois par df et que la deuxième partie de la division (si elle est plus longue de 10 lignes (ce qui signifie que l'original était de plus de 20 lignes)) est OK.

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

    Remarque vous pouvez également utiliser df.head(10) et df.tail(len(df) - 10) pour obtenir l'avant et à l'arrière selon vos besoins. Vous pouvez également utiliser différentes approches d'indexation: vous pouvez simplement fournir les premières dimensions de l'indice si vous le souhaitez, comme df[:10] au lieu de df[:10, :] (bien que j'aime code explicitement sur les dimensions que vous prenez). Vous pouvez également utiliser df.iloc et df.ix à l'index de la même façon.

    Être prudent quant à l'utilisation df.loc cependant, depuis il est basé sur les libellés et l'entrée ne sera jamais interprété comme une position de type entier. .loc fonctionnerait seulement "accidentellement" dans le cas où vous arrive d'avoir des étiquettes d'index qui sont des nombres entiers commençant à 0 avec pas de lacunes.

    Mais vous devriez également considérer les différentes options que les pandas prévoit verser le contenu du DataFrame en HTML et éventuellement de LaTeX pour faire mieux conçu des tableaux pour la présentation (au lieu de simplement copier et coller). Simplement une recherche sur Google comment convertir le DataFrame de ces formats tourne beaucoup de tutoriels et de conseils pour cette application.

    belle, grande, de mal faire plus de recherche!
    df[:10] fonctionne très bien mais lorsque j'essaie df[:10, :] j'ai eu cette erreur: TypeError: unhashable type
    Qui sonne comme une autre erreur à cette question, Vous devriez poster une nouvelle question et de montrer comment le DataFrame que vous utilisez est créé et ce que certains de ces données qu'il ressemble.
    utiliser df.loc[:10,:] au lieu
    Ce n'est pas réellement de bons conseils. loc est intentionnellement une labelà base d'indexation, de sorte que ce qui est passé, c'est jamais interprété comme une position de type entier. Ce ne serait qu'travail "accidentellement" si votre indice de l'étiquette qui est arrivé à être une fourchette de nombres entiers, sans lacunes et sans à partir de 0. Plutôt, à l'aide de iloc est préféré, peut-être aussi .ix si attentif à la force de la position de type entier comportement. Depuis régulière getitem syntaxe fait déjà, c'est pourquoi il est OK.

    OriginalL'auteur ely

  2. 12

    Il n'existe aucune fonction de commodité.

    Que vous avez à faire quelque chose comme:

    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:]
    Cela a très bien fonctionné, merci mec. souhaite que je pourrais accepter à la fois les réponses!

    OriginalL'auteur EdChum

  3. 1

    Vous pouvez utiliser le DataFrame la tête et la queue méthodes de sucre syntaxique au lieu de trancher/loc ici. J'utilise une fraction de la taille de 3; pour votre exemple de l'utilisation 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)

    OriginalL'auteur Tom Walker

  4. 1

    Ci-dessous est une fonction simple de mise en œuvre qui se fend d'un DataFrame de morceaux et quelques exemples de code:

    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]

    OriginalL'auteur Roei Bahumi

  5. 0

    Si vous avez un grand bloc de données et la nécessité de diviser en un nombre variable de sous-trames de données des lignes, comme par exemple, chaque sous dataframe a un max de 4500 lignes, ce script pourrait aider:

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

    Vous pouvez ensuite enregistrer ces trames de données:

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

    Espère que cela aide quelqu'un!

    OriginalL'auteur cheevahagadog

  6. 0

    Une méthode basée sur 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)]

    Une petite fonction qui utilise un modulo pourraient prendre en charge les cas où la séparation n'est pas la même (par exemple, np.split(df.index,4) lèvera une erreur).

    (Oui, je suis conscient que la question initiale a été un peu plus précis que ça. Cependant, ce qui est censé répondre à la question dans le titre.)

    OriginalL'auteur webelo

  7. 0

    J'ai utilisé ce Interprétations De La Liste de couper un énorme df en blocs de 100'000:

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

    ou comme générateur:

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

    OriginalL'auteur agittarius