I 5 modi più veloci per caricare dati in Python

Lo sappiamo, le aziende adorano Excel. Eppure caricare in Python un dataset in formato excel o csv non è proprio un’operazione rapidissima.

In questo articolo vedremo i 5 modi più veloci per caricare dati in Python.

Se vuoi fare una prova, inizia configurando il tuo dataset.

Mettiamo di voler caricare dei dati transazionali da un gestionale come SAP in Python, perché vogliamo fare le nostre analisi.

Quindi, dovrai popolare di dati fittizi 10 file Excel con 20000 righe e 25 colonne ciascuno (circa 70MB in totale). 

Dopodiché, importa le librerie necessarie. 

Adesso possiamo iniziare con la nostra sperimentazione!

5 modi per caricare dati in Python (in ordine di velocità)

1) Carica un file Excel in Python

È decisamente il modo più semplice e il più lento (quasi 1 minuto di tempo!). 

Crea un dataframe in Pandas e poi caricaci i tuoi file in formato .xlsx.

start = time.time()
df = pd.read_excel("Dummy 0.xlsx")
per file_numero in range(1,10):
 df.append(pd.read_excel(f "Dummy {file_number}.xlsx"))
fine = tempo.tempo()
print("Excel:", end - start)

>> Excel: 53.4

53 secondi sono un bel po’ di tempo. Soluzione bocciata!

2) Carica i dati con un CSV 

I gestionali SAP consentono anche di scaricare i dati in formato .csv. Un metodo più rapido, come vedremo tra pochissimo, anche se i dati .csv sono più pesanti dei dati Execel.

Vediamo quanto tempo ci mettiamo a caricarli in Python:

start = time.time()
df = pd.read_csv("Dummy 0.csv")
per file_numero in range(1,10):
 df.append(pd.read_csv(f "Dummy {file_number}.csv"))
end = time.time()
print("CSV:", end - start)

>> CSV: 0.632

0,63 secondi. Vediamo se si può fare di meglio.

3) Migliora i tuoi DataFrame in Pandas 

Come hai creato i tuoi dataframe in Pandas? Prova, invece di aggiungere ogni file a un DataFrame esistente, a caricare ogni dataframe indipendentemente in una lista.

Poi concatena l’intera lista in un singolo DataFrame.

start = time.time()
df = []
per file_numero in range(10):
 temp = pd.read_csv(f "Dummy {file_number}.csv")
 df.append(temp)
df = pd.concat(df, ignore_index=True)
end = time.time()
print("CSV2:", end - start)

>> CSV2: 0.619

Recuperi qualche punto percentuale, che fa la differenza solo quando hai a che fare con set di dati più grandi. 

4) Parallelizzare le importazioni CSV con Joblib

Invece di caricare ognuno dei 20 file che abbiamo separatamente, possiamo caricarli tutti insieme, in parallelo. Basta usare nel modo giusto Joblib.

start = time.time()
def loop(file_numero):
 return pd.read_csv(f "Dummy {file_number}.csv")
df = Parallelo(n_jobs=-1, verbose=10)(delayed(loop)(file_number) per file_number in range(10))
df = pd.concat(df, ignore_index=True)
end = time.time()
print("CSV//:", end - start)

>> CSV//: 0.386

Qui il recupero di tempo comincia a essere sostanziale: ci stiamo mettendo la metà del tempo rispetto alla soluzione precedente!

Se non hai mai usato Joblib: è una libreria in Python che consente una sorta di comprensione intelligente delle liste. In Joblib puoi eseguire una funzione in parallelo, dove ogni iterazione è eseguita da un thread diverso. Ecco un esempio:

def loop(file_number):
 return pd.read_csv(f "Dummy {file_number}.csv")
df = Parallelo(n_jobs=-1, verbose=10)(delayed(loop)(file_number) per file_number in range(10))
#equivalente a
df = [loop(file_numero) for file_numero in range(10)]

5) Usare file Pickle

Mai usato Pickle? È un modulo di Python (e solo di Python, quindi non puoi aprire il file e guardarci dentro, per intenderci).

start = time.time()
def loop(file_number):
 return pd.read_pickle(f "Dummy {file_number}.pickle")
df = Parallelo(n_jobs=-1, verbose=10)(delayed(loop)(file_number) per file_number in range(10))
df = pd.concat(df, ignore_index=True)
end = time.time()
print("Pickle//:", end - start)
>> Pickle//: 0.072

A fronte del fatto che un file pickle occupa molto più spazio nel disco rispetto a un .csv, qui abbiamo tagliato il tempo di esecuzione dell’80%.

Purtroppo non si possono estrarre i dati da un sistema direttamente nei file pickle.

Casi d’uso di Pickle

1. Vuoi salvare i dati da uno dei tuoi processi Python e non hai intenzione di aprirli su Excel per trasferirli da un’altra parte. In tal caso, è sufficiente salvare i tuoi Dataframe come pickles invece di .csv
2. Ti serve ricaricare un file più volte. Dovrai salvare il file come pickle la prima volta che lo apri. La volta successiva, potrai caricare direttamente la versione pickle.

Se hai a disposizione solo file Excel: caricali in parallelo

Caricare file Excel in parallelo è possibile, grazie a Joblib. Rispetto al nostro codice pickle di cui sopra, abbiamo solo bisogno di aggiornare la funzione di loop.

start = time.time()
def loop(file_numero):
    return pd.read_excel(f "Dummy {file_number}.xlsx")
df = Parallelo(n_jobs=-1, verbose=10)(delayed(loop)(file_number) per file_number in range(10))
df = pd.concat(df, ignore_index=True)
end = time.time()
print("Excel//:", end - start)

>> Excel//: 13.45

Il tempo di caricamento rispetto alla nostra soluzione 1 è nettamente calato, passando da 50 secondi a poco più di 13 secondi.

Da qui puoi anche partire per creare un file pickle, utile per la prossima volta che decidi di caricare questi file. 

def loop(file_number):
    temp = pd.read_excel(f "Dummy {file_number}.xlsx")
    temp.to_pickle(f "Dummy {file_number}.pickle")
    ritorno temp

Cambiare “prefer=threads” con “parallel”

Joblib permette di cambiare il backend di parallelizzazione: basta sostituire prefer=”threads” con “parallel”:

def loop(file_number):
      return pd.read_pickle(f"Dummy {file_number}.pickle")
  df = Parallel(n_jobs=-1, verbose=0, prefer="threads")(delayed(loop)(file_number) for file_number in range(10))
  df = pd.concat(df, ignore_index=True)

La velocità misurata per Parallel è di circa 0,0096 secondi, con 51,07 secondi da file Excel, 0,26 da .csv e 0,01 da pickle (rispetto agli originari 16,54-0,43-0,07 con prefer=”threads”).

Se con Excel c’è un peggioramento, con csv un lieve miglioramento, e con pickle un risultato ottimo. 

Conclusione

Ecco i nostri classificati:

Excel: 50 secondi

CSV: 0,63 secondi

Smarter CSV: 0,62 secondi

CSV in //: 0.34 secondi

Pickle in //: 0.07 secondi

Excel in //: 13,5 secondi

A ognuno la sua scelta!