Como leio um arquivo csv grande com pandas?

Estou tentando ler um arquivo csv grande (aprox. 6 GB) no pandas e estou recebendo um erro de memória:

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

...

MemoryError: 

Alguma ajuda nisso?

O erro mostra que a máquina não possui memória suficiente para ler o CSV inteiro em um DataFrame de uma só vez. Supondo que você não precise do conjunto de dados inteiro na memória de uma só vez, uma maneira de evitar o problema seria processar o CSV em partes (especificando o chunksizeparâmetro):

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

O chunksizeparâmetro especifica o número de linhas por bloco. (O último pedaço pode conter menos de chunksizelinhas, é claro.)

Chunking nem sempre deve ser a primeira porta de escala para esse problema.

1. O arquivo é grande devido a dados não numéricos repetidos ou a colunas indesejadas?

   Nesse caso, às vezes você pode obter uma economia de memória massiva lendo as colunas como categorias e selecionando as colunas necessárias por meio do usecols parâmetro pd.read_csv .

2. Seu fluxo de trabalho exige fatiar, manipular e exportar?

   Nesse caso, você pode usar o dask.dataframe para fatiar, executar seus cálculos e exportar iterativamente. O chunking é executado silenciosamente pelo dask, que também suporta um subconjunto da API do pandas.

3. Se tudo mais falhar, leia linha por linha através de blocos.

   Pedaço via pandas ou via biblioteca csv como último recurso.

Eu procedi assim:

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)

Para dados grandes, recomendo que você use a biblioteca "dask",
por exemplo:

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

Você pode ler mais na documentação aqui .

Outra ótima alternativa seria usar o modin, porque toda a funcionalidade é idêntica à dos pandas, mas aproveita as bibliotecas de quadros de dados distribuídos, como o dask.

A resposta acima já está satisfazendo o tópico. De qualquer forma, se você precisar de todos os dados da memória - dê uma olhada no bcolz . Está comprimindo os dados na memória. Eu tive uma experiência muito boa com isso. Mas faltam muitos recursos de pandas

Edit: Eu tenho taxas de compressão em torno de 1/10 ou tamanho orig, eu acho, é claro, dependendo do tipo de dados. Recursos importantes ausentes foram agregados.

Você pode ler os dados como pedaços e salvar cada pedaço como picles.

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)

Na próxima etapa, você lerá os picles e anexará cada picles ao quadro de dados desejado.

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)

As funções read_csv e read_table são quase as mesmas. Mas você deve atribuir o delimitador “，” ao usar a função read_table no seu programa.

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)

Solução 1:

Usando pandas com grandes dados

Solução 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)

Segue um exemplo:

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)

Você pode tentar o sframe, que tem a mesma sintaxe que os pandas, mas permite manipular arquivos maiores que a sua RAM.

Se você usa pandas, lê grandes arquivos em partes e depois produz linha por linha, eis o que eu fiz

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

Desejo fazer uma resposta mais abrangente com base na maioria das soluções possíveis que já são fornecidas. Também quero apontar mais uma ajuda potencial que pode ajudar no processo de leitura.

Opção 1: tipos

"dtypes" é um parâmetro bastante poderoso que você pode usar para reduzir a pressão de memória dos readmétodos. Veja esta e esta resposta. Os pandas, por padrão, tentam inferir tipos de dados.

Referindo-se a estruturas de dados, todos os dados armazenados, uma alocação de memória ocorre. Em um nível básico, consulte os valores abaixo (A tabela abaixo ilustra os valores da linguagem de programação 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

Consulte esta página para ver a correspondência entre os tipos NumPy e C.

Vamos dizer que você tem um array de inteiros de dígitos . Você pode atribuir teoricamente e praticamente, por exemplo, matriz do tipo inteiro de 16 bits, mas alocaria mais memória do que realmente precisa para armazenar essa matriz. Para evitar isso, você pode ativar a dtypeopção read_csv. Você não deseja armazenar os itens da matriz como um número inteiro longo onde, na verdade, você pode ajustá-los com um número inteiro de 8 bits ( np.int8ou np.uint8).

Observe o seguinte mapa de tipo.

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

Você pode passar o dtypeparâmetro como um parâmetro nos métodos de pandas como ditado readcomo {column: type}.

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)

Opção 2: Leia por Chunks

A leitura dos dados em partes permite acessar uma parte dos dados na memória e você pode aplicar o pré-processamento aos dados e preservar os dados processados ​​em vez dos dados brutos. Seria muito melhor se você combinar essa opção com o primeiro, dtypes .

Quero destacar as seções do livro de receitas dos pandas para esse processo, onde você pode encontrá-lo aqui . Observe essas duas seções lá;

• Lendo um pedaço csv por pedaço
• Lendo apenas determinadas linhas de um csv pedaço por pedaço

Opção 3: Dask

O Dask é uma estrutura definida no site da Dask como:

O Dask fornece paralelismo avançado para análises, permitindo desempenho em escala para as ferramentas que você ama

Nasceu para cobrir as partes necessárias onde os pandas não podem alcançar. O Dask é uma estrutura poderosa que permite muito mais acesso a dados, processando-o de maneira distribuída.

Você pode usar o dask para pré-processar seus dados como um todo. O Dask cuida da parte do chunking. Assim, ao contrário dos pandas, você pode apenas definir suas etapas de processamento e deixar o Dask fazer o trabalho. O Dask não aplica os cálculos antes de ser explicitamente enviado por computee / ou persist(veja a resposta aqui para a diferença).

Outras ajudas (ideias)

• Fluxo ETL projetado para os dados. Mantendo apenas o que é necessário a partir dos dados brutos.
  • Primeiro, aplique ETL a dados inteiros com estruturas como Dask ou PySpark e exporte os dados processados.
  • Então veja se os dados processados ​​podem caber na memória como um todo.
• Considere aumentar sua RAM.
• Considere trabalhar com esses dados em uma plataforma em nuvem.

Além das respostas acima, para quem deseja processar CSV e depois exportar para csv, parquet ou SQL, o d6tstack é outra boa opção. Você pode carregar vários arquivos e ele lida com alterações no esquema de dados (colunas adicionadas / removidas). O suporte fragmentado do núcleo já está incorporado.

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

Caso alguém ainda esteja procurando algo assim, descobri que essa nova biblioteca chamada modin pode ajudar. Ele usa computação distribuída que pode ajudar na leitura. Aqui está um bom artigo comparando sua funcionalidade com os pandas. Essencialmente, ele usa as mesmas funções que os pandas.

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

Antes de usar a opção chunksize, se você quiser ter certeza sobre a função do processo que deseja escrever dentro do loop for de chunking, conforme mencionado por @unutbu, basta usar a opção nrows.

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

Depois de ter certeza de que o bloco do processo está pronto, você pode colocá-lo no loop chunking for para todo o quadro de dados.