Come faccio a leggere un file CSV di grandi dimensioni con Panda?

Sto cercando di leggere un file CSV di grandi dimensioni (circa 6 GB) in Panda e ricevo un errore di memoria:

MemoryError                               Traceback (most recent call last)
<ipython-input-58-67a72687871b> in <module>()
----> 1 data=pd.read_csv('aphro.csv',sep=';')

...

MemoryError: 

Qualche aiuto su questo?

L'errore mostra che la macchina non ha memoria sufficiente per leggere l'intero CSV in un DataFrame contemporaneamente. Supponendo che non sia necessario l'intero set di dati in memoria contemporaneamente, un modo per evitare il problema sarebbe quello di elaborare il CSV in blocchi (specificando il chunksizeparametro):

chunksize = 10 ** 6
for chunk in pd.read_csv(filename, chunksize=chunksize):
    process(chunk)

Il chunksizeparametro specifica il numero di righe per blocco. (L'ultimo pezzo può contenere meno di chunksizerighe, ovviamente.)

Chunking non dovrebbe essere sempre il primo punto di riferimento per questo problema.

1. Il file è grande a causa di dati non numerici ripetuti o colonne indesiderate?

   In tal caso, a volte puoi vedere enormi risparmi di memoria leggendo le colonne come categorie e selezionando le colonne richieste tramite il parametro pd.read_csv usecols .

2. Il tuo flusso di lavoro richiede suddivisione, manipolazione, esportazione?

   In tal caso, è possibile utilizzare dask.dataframe per suddividere , eseguire i calcoli ed esportare iterativamente. Il chunking viene eseguito silenziosamente da dask, che supporta anche un sottoinsieme di API panda.

3. Se tutto il resto fallisce, leggi riga per riga tramite blocchi.

   Chunk via panda o via libreria CSV come ultima risorsa.

Ho proceduto così:

chunks=pd.read_table('aphro.csv',chunksize=1000000,sep=';',\
       names=['lat','long','rf','date','slno'],index_col='slno',\
       header=None,parse_dates=['date'])

df=pd.DataFrame()
%time df=pd.concat(chunk.groupby(['lat','long',chunk['date'].map(lambda x: x.year)])['rf'].agg(['sum']) for chunk in chunks)

Per dati di grandi dimensioni ti consiglio di utilizzare la libreria "dask",
ad esempio:

# Dataframes implement the Pandas API
import dask.dataframe as dd
df = dd.read_csv('s3://.../2018-*-*.csv')

Puoi leggere di più dalla documentazione qui .

Un'altra ottima alternativa sarebbe quella di utilizzare modin perché tutte le funzionalità sono identiche a quelle dei panda ma sfruttano le librerie di dataframe distribuite come dask.

La risposta sopra sta già soddisfacendo l'argomento. Ad ogni modo, se hai bisogno di tutti i dati in memoria, dai un'occhiata a bcolz . Comprime i dati in memoria. Ho avuto un'esperienza davvero positiva. Ma manca molte funzionalità dei panda

Modifica: ho ottenuto tassi di compressione intorno a 1/10 o dimensioni dell'orig, credo, ovviamente a seconda del tipo di dati. Le caratteristiche importanti mancanti erano aggregati.

Puoi leggere i dati come blocchi e salvare ogni blocco come pickle.

import pandas as pd 
import pickle

in_path = "" #Path where the large file is
out_path = "" #Path to save the pickle files to
chunk_size = 400000 #size of chunks relies on your available memory
separator = "~"

reader = pd.read_csv(in_path,sep=separator,chunksize=chunk_size, 
                    low_memory=False)    


for i, chunk in enumerate(reader):
    out_file = out_path + "/data_{}.pkl".format(i+1)
    with open(out_file, "wb") as f:
        pickle.dump(chunk,f,pickle.HIGHEST_PROTOCOL)

Nel passaggio successivo leggi i sottaceti e aggiungi ogni sottaceto al frame di dati desiderato.

import glob
pickle_path = "" #Same Path as out_path i.e. where the pickle files are

data_p_files=[]
for name in glob.glob(pickle_path + "/data_*.pkl"):
   data_p_files.append(name)


df = pd.DataFrame([])
for i in range(len(data_p_files)):
    df = df.append(pd.read_pickle(data_p_files[i]),ignore_index=True)

La funzione read_csv e read_table è quasi la stessa. Ma devi assegnare il delimitatore “，” quando usi la funzione read_table nel tuo programma.

def get_from_action_data(fname, chunk_size=100000):
    reader = pd.read_csv(fname, header=0, iterator=True)
    chunks = []
    loop = True
    while loop:
        try:
            chunk = reader.get_chunk(chunk_size)[["user_id", "type"]]
            chunks.append(chunk)
        except StopIteration:
            loop = False
            print("Iteration is stopped")

    df_ac = pd.concat(chunks, ignore_index=True)

Soluzione 1:

Utilizzo di Panda con dati di grandi dimensioni

Soluzione 2:

TextFileReader = pd.read_csv(path, chunksize=1000)  # the number of rows per chunk

dfList = []
for df in TextFileReader:
    dfList.append(df)

df = pd.concat(dfList,sort=False)

Ecco un esempio:

chunkTemp = []
queryTemp = []
query = pd.DataFrame()

for chunk in pd.read_csv(file, header=0, chunksize=<your_chunksize>, iterator=True, low_memory=False):

    #REPLACING BLANK SPACES AT COLUMNS' NAMES FOR SQL OPTIMIZATION
    chunk = chunk.rename(columns = {c: c.replace(' ', '') for c in chunk.columns})

    #YOU CAN EITHER: 
    #1)BUFFER THE CHUNKS IN ORDER TO LOAD YOUR WHOLE DATASET 
    chunkTemp.append(chunk)

    #2)DO YOUR PROCESSING OVER A CHUNK AND STORE THE RESULT OF IT
    query = chunk[chunk[<column_name>].str.startswith(<some_pattern>)]   
    #BUFFERING PROCESSED DATA
    queryTemp.append(query)

#!  NEVER DO pd.concat OR pd.DataFrame() INSIDE A LOOP
print("Database: CONCATENATING CHUNKS INTO A SINGLE DATAFRAME")
chunk = pd.concat(chunkTemp)
print("Database: LOADED")

#CONCATENATING PROCESSED DATA
query = pd.concat(queryTemp)
print(query)

Puoi provare sframe, che ha la stessa sintassi dei panda ma ti consente di manipolare file più grandi della tua RAM.

Se usi i panda leggi file di grandi dimensioni in blocchi e poi produci riga per riga, ecco cosa ho fatto

import pandas as pd

def chunck_generator(filename, header=False,chunk_size = 10 ** 5):
   for chunk in pd.read_csv(filename,delimiter=',', iterator=True, chunksize=chunk_size, parse_dates=[1] ): 
        yield (chunk)

def _generator( filename, header=False,chunk_size = 10 ** 5):
    chunk = chunck_generator(filename, header=False,chunk_size = 10 ** 5)
    for row in chunk:
        yield row

if __name__ == "__main__":
filename = r'file.csv'
        generator = generator(filename=filename)
        while True:
           print(next(generator))

Voglio fare una risposta più completa basata sulla maggior parte delle potenziali soluzioni che sono già fornite. Voglio anche sottolineare un ulteriore potenziale aiuto che può aiutare il processo di lettura.

Opzione 1: tipi

"dtypes" è un parametro abbastanza potente che puoi usare per ridurre la pressione di memoria dei readmetodi. Vedi questa e questa risposta. I panda, per impostazione predefinita, provano a dedurre i tipi di dati.

Facendo riferimento alle strutture di dati, ad ogni dato archiviato, avviene un'allocazione di memoria. A livello base fare riferimento ai valori seguenti (La tabella seguente illustra i valori per il linguaggio di programmazione C):

The maximum value of UNSIGNED CHAR = 255                                    
The minimum value of SHORT INT = -32768                                     
The maximum value of SHORT INT = 32767                                      
The minimum value of INT = -2147483648                                      
The maximum value of INT = 2147483647                                       
The minimum value of CHAR = -128                                            
The maximum value of CHAR = 127                                             
The minimum value of LONG = -9223372036854775808                            
The maximum value of LONG = 9223372036854775807

Fare riferimento a questa pagina per vedere la corrispondenza tra i tipi NumPy e C.

Supponiamo che tu abbia una matrice di numeri interi di cifre . È possibile assegnare sia teoricamente che praticamente, diciamo array di tipo intero a 16 bit, ma allocare più memoria di quella necessaria per archiviare tale array. Per evitare ciò, è possibile attivare l' dtypeopzione read_csv. Non si desidera archiviare gli elementi dell'array come numeri interi lunghi in cui effettivamente è possibile adattarli con numeri interi a 8 bit ( np.int8o np.uint8).

Osservare la seguente mappa del tipo.

Fonte: https://pbpython.com/pandas_dtypes.html

Puoi passare un dtypeparametro come parametro sui metodi Panda come dict su readcome {colonna: tipo}.

import numpy as np
import pandas as pd

df_dtype = {
        "column_1": int,
        "column_2": str,
        "column_3": np.int16,
        "column_4": np.uint8,
        ...
        "column_n": np.float32
}

df = pd.read_csv('path/to/file', dtype=df_dtype)

Opzione 2: lettura di blocchi

La lettura dei dati in blocchi consente di accedere a una parte dei dati in memoria e di applicare la preelaborazione sui dati e preservare i dati elaborati anziché i dati non elaborati. Sarebbe molto meglio se combinassi questa opzione con il primo, i tipi .

Voglio sottolineare le sezioni del libro di cucina di Panda per quel processo, dove puoi trovarlo qui . Nota quelle due sezioni lì;

• Leggere un csv pezzo per pezzo
• Leggendo solo alcune righe di un csv pezzo per pezzo

Opzione 3: Dask

Dask è un framework definito nel sito Web di Dask come:

Dask offre un parallelismo avanzato per l'analisi, consentendo prestazioni su vasta scala per gli strumenti che ami

È nato per coprire le parti necessarie dove i panda non possono raggiungere. Dask è un potente framework che ti consente di accedere molto più ai dati elaborandoli in modo distribuito.

Puoi usare dask per preelaborare i tuoi dati nel loro insieme, Dask si occupa della parte di chunking, quindi a differenza dei panda puoi semplicemente definire le tue fasi di elaborazione e lasciare che Dask faccia il lavoro. Dask non applica i calcoli prima di essere esplicitamente spinto da computee / o persist(vedere la risposta qui per la differenza).

Altri aiuti (idee)

• Flusso ETL progettato per i dati. Mantenere solo ciò che è necessario dai dati grezzi.
  • Innanzitutto, applicare ETL a interi dati con framework come Dask o PySpark ed esportare i dati elaborati.
  • Quindi verifica se i dati elaborati possono essere inseriti nella memoria nel suo insieme.
• Valuta di aumentare la tua RAM.
• Prendi in considerazione l'idea di lavorare con quei dati su una piattaforma cloud.

Oltre alle risposte di cui sopra, per coloro che vogliono elaborare CSV e quindi esportare in CSV, parquet o SQL, d6tstack è un'altra buona opzione. È possibile caricare più file e si occupa delle modifiche allo schema dei dati (colonne aggiunte / rimosse). Chunked fuori dal supporto core è già integrato.

def apply(dfg):
    # do stuff
    return dfg

c = d6tstack.combine_csv.CombinerCSV([bigfile.csv], apply_after_read=apply, sep=',', chunksize=1e6)

# or
c = d6tstack.combine_csv.CombinerCSV(glob.glob('*.csv'), apply_after_read=apply, chunksize=1e6)

# output to various formats, automatically chunked to reduce memory consumption
c.to_csv_combine(filename='out.csv')
c.to_parquet_combine(filename='out.pq')
c.to_psql_combine('postgresql+psycopg2://usr:pwd@localhost/db', 'tablename') # fast for postgres
c.to_mysql_combine('mysql+mysqlconnector://usr:pwd@localhost/db', 'tablename') # fast for mysql
c.to_sql_combine('postgresql+psycopg2://usr:pwd@localhost/db', 'tablename') # slow but flexible

Nel caso in cui qualcuno stia ancora cercando qualcosa di simile, ho scoperto che questa nuova libreria chiamata modin può aiutare. Utilizza il calcolo distribuito che può aiutare con la lettura. Ecco un bell'articolo che confronta la sua funzionalità con i panda. Utilizza essenzialmente le stesse funzioni dei panda.

import modin.pandas as pd
pd.read_csv(CSV_FILE_NAME)

Prima di usare l'opzione chunksize se vuoi essere sicuro della funzione di processo che vuoi scrivere all'interno del chunking for-loop come menzionato da @unutbu puoi semplicemente usare l'opzione nrows.

small_df = pd.read_csv(filename, nrows=100)

Una volta che si è sicuri che il blocco di processo sia pronto, è possibile inserirlo nel loop di chunking per l'intero frame di dati.