Wie lese ich eine große CSV-Datei mit Pandas?

Ich versuche, eine große CSV-Datei (ca. 6 GB) in Pandas zu lesen, und es wird ein Speicherfehler angezeigt:

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

...

MemoryError: 

Hilfe dazu?

Der Fehler zeigt, dass der Computer nicht über genügend Speicher verfügt, um die gesamte CSV gleichzeitig in einen DataFrame einzulesen. Angenommen, Sie benötigen nicht den gesamten Datensatz auf einmal im Speicher. Eine Möglichkeit, das Problem zu vermeiden, besteht darin , die CSV in Blöcken zu verarbeiten (durch Angabe des chunksizeParameters):

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

Der chunksizeParameter gibt die Anzahl der Zeilen pro Block an. (Der letzte Block kann chunksizenatürlich weniger als Zeilen enthalten .)

Chunking sollte nicht immer die erste Anlaufstelle für dieses Problem sein.

1. Ist die Datei aufgrund wiederholter nicht numerischer Daten oder unerwünschter Spalten groß?

   In diesem Fall können Sie manchmal massive Speichereinsparungen feststellen, indem Sie Spalten als Kategorien einlesen und die erforderlichen Spalten über denusecols Parameter pd.read_csv auswählen .

2. Erfordert Ihr Workflow das Schneiden, Bearbeiten und Exportieren?

   In diesem Fall können Sie dask.dataframe verwenden , um zu schneiden, Ihre Berechnungen durchzuführen und iterativ zu exportieren. Das Chunking wird stillschweigend von dask ausgeführt, das auch eine Teilmenge der Pandas-API unterstützt.

3. Wenn alles andere fehlschlägt, lesen Sie Zeile für Zeile über Chunks.

   Chunk via Pandas oder via CSV-Bibliothek als letztes Mittel.

Ich ging so vor:

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)

Für große Datenmengen empfehle ich die Verwendung der Bibliothek "dask",
z.

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

Weitere Informationen finden Sie hier in der Dokumentation .

Eine weitere gute Alternative wäre die Verwendung von Modin, da alle Funktionen mit Pandas identisch sind, jedoch verteilte Datenrahmenbibliotheken wie dask genutzt werden.

Die obige Antwort erfüllt das Thema bereits. Wenn Sie alle Daten im Speicher benötigen, schauen Sie sich bcolz an . Es komprimiert die Daten im Speicher. Ich habe wirklich gute Erfahrungen damit gemacht. Aber es fehlen viele Pandas-Funktionen

Bearbeiten: Ich habe Komprimierungsraten bei etwa 1/10 oder Originalgröße, denke ich, natürlich abhängig von der Art der Daten. Wichtige fehlende Merkmale waren Aggregate.

Sie können die Daten als Chunks einlesen und jeden Chunk als Pickle speichern.

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)

Im nächsten Schritt lesen Sie die Gurken ein und hängen jede Gurke an Ihren gewünschten Datenrahmen an.

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)

Die Funktionen read_csv und read_table sind nahezu identisch. Sie müssen jedoch das Trennzeichen "，" zuweisen, wenn Sie die Funktion read_table in Ihrem Programm verwenden.

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)

Lösung 1:

Verwenden von Pandas mit großen Datenmengen

Lösung 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)

Hier folgt ein Beispiel:

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)

Sie können sframe ausprobieren, das dieselbe Syntax wie pandas hat, aber Sie können Dateien bearbeiten, die größer als Ihr RAM sind.

Wenn Sie Pandas verwenden, lesen Sie eine große Datei in Chunk und geben Sie dann Zeile für Zeile nach. Hier ist, was ich getan habe

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))

Ich möchte eine umfassendere Antwort geben, die auf den meisten potenziellen Lösungen basiert, die bereits bereitgestellt werden. Ich möchte auch auf eine weitere mögliche Hilfe hinweisen, die den Lesevorgang unterstützen kann.

Option 1: dtypes

"dtypes" ist ein ziemlich leistungsfähiger Parameter, mit dem Sie den Speicherdruck von readMethoden reduzieren können. Siehe diese und diese Antwort. Pandas versuchen standardmäßig, d-Typen der Daten abzuleiten.

Bezugnehmend auf Datenstrukturen findet für alle gespeicherten Daten eine Speicherzuordnung statt. Grundsätzlich beziehen Sie sich auf die folgenden Werte (Die folgende Tabelle zeigt Werte für die Programmiersprache 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

Auf dieser Seite finden Sie die Übereinstimmung zwischen den Typen NumPy und C.

Angenommen, Sie haben eine Reihe von Ganzzahlen mit Ziffern . Sie können sowohl theoretisch als auch praktisch ein Array vom Typ 16-Bit-Ganzzahl zuweisen, aber Sie würden dann mehr Speicher zuweisen, als Sie tatsächlich zum Speichern dieses Arrays benötigen. Um dies zu verhindern, können Sie die dtypeOption aktivieren read_csv. Sie möchten die Array-Elemente nicht als lange Ganzzahl speichern, wo Sie sie tatsächlich mit einer 8-Bit-Ganzzahl ( np.int8oder np.uint8) versehen können.

Beachten Sie die folgende dtype-Karte.

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

Sie können dtypeParameter als Parameter für Pandas-Methoden übergeben, readwie dies unter {column: type} vorgeschrieben ist.

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)

Option 2: Von Chunks gelesen

Durch das Lesen der Daten in Blöcken können Sie auf einen Teil der Daten im Speicher zugreifen, und Sie können eine Vorverarbeitung auf Ihre Daten anwenden und die verarbeiteten Daten anstelle von Rohdaten beibehalten. Es wäre viel besser, wenn Sie diese Option mit der ersten Option, dtypes , kombinieren würden .

Ich möchte auf die Pandas-Kochbuchabschnitte für diesen Prozess hinweisen, die Sie hier finden . Beachten Sie diese beiden Abschnitte dort;

• Lesen einer CSV-Datei Stück für Stück
• Nur bestimmte Zeilen einer CSV-Datei Stück für Stück lesen

Option 3: Dask

Dask ist ein Framework, das auf der Dask-Website wie folgt definiert ist :

Dask bietet erweiterte Parallelität für die Analyse und ermöglicht eine skalierbare Leistung für die Tools, die Sie lieben

Es wurde geboren, um die notwendigen Teile abzudecken, die Pandas nicht erreichen können. Dask ist ein leistungsstarkes Framework, mit dem Sie viel mehr auf Daten zugreifen können, indem Sie es auf verteilte Weise verarbeiten.

Sie können dask verwenden, um Ihre Daten als Ganzes vorzuverarbeiten. Dask kümmert sich um den Chunking-Teil. Im Gegensatz zu Pandas können Sie also einfach Ihre Verarbeitungsschritte definieren und Dask die Arbeit erledigen lassen. Dask wendet die Berechnungen nicht an, bevor sie explizit von computeund / oder gepusht werden persist(siehe die Antwort hier für den Unterschied).

Andere Hilfsmittel (Ideen)

• ETL-Fluss für die Daten ausgelegt. Behalten Sie nur das bei, was aus den Rohdaten benötigt wird.
  • Wenden Sie zunächst ETL auf ganze Daten mit Frameworks wie Dask oder PySpark an und exportieren Sie die verarbeiteten Daten.
  • Überprüfen Sie dann, ob die verarbeiteten Daten in den gesamten Speicher passen.
• Erwägen Sie, Ihren RAM zu erhöhen.
• Arbeiten Sie mit diesen Daten auf einer Cloud-Plattform.

Zusätzlich zu den obigen Antworten ist d6tstack eine weitere gute Option für diejenigen, die CSV verarbeiten und dann nach CSV, Parkett oder SQL exportieren möchten . Sie können mehrere Dateien laden und es werden Datenschemaänderungen (hinzugefügte / entfernte Spalten) behandelt. Chunked out of Core-Unterstützung ist bereits eingebaut.

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

Für den Fall, dass noch jemand nach so etwas sucht, habe ich festgestellt, dass diese neue Bibliothek namens modin helfen kann. Es verwendet verteiltes Computing, das beim Lesen helfen kann. Hier ist ein schöner Artikel , der seine Funktionalität mit Pandas vergleicht. Es verwendet im Wesentlichen die gleichen Funktionen wie Pandas.

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

Bevor Sie die Option chunksize verwenden möchten, können Sie einfach die Option nrows verwenden, wenn Sie sicher sein möchten, welche Prozessfunktion Sie in die von @unutbu erwähnte Chunking-for-Schleife schreiben möchten.

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

Sobald Sie sicher sind, dass der Prozessblock bereit ist, können Sie ihn in die Chunking-for-Schleife für den gesamten Datenrahmen einfügen.