Como conservar um dataframe utilizando Pandas
8 answers
A maneira mais fácil é pickle usandoto_pickle
:
df.to_pickle(file_name) # where to save it, usually as a .pkl
Depois podes carregá-lo de volta usando:
df = pd.read_pickle(file_name)
Nota: Antes de 0.11.1 save
e load
eram a única maneira de fazer isso (eles estão agora depreciados a favor de to_pickle
e read_pickle
respectivamente).
Outra escolha popular é usar HDF5 (pytables que oferece tempos de acesso muito rápidos para grandes conjuntos de Dados:
store = HDFStore('store.h5')
store['df'] = df # save it
store['df'] # load it
mais avançado as estratégias são discutidas no livro de receitas .
Desde 0.13 há também O msgpack que pode ser melhor para a interoperabilidade, como uma alternativa mais rápida ao JSON, ou se você tem objetos python / texto-dados pesados (ver esta pergunta ).
Embora já existam algumas respostas, encontrei uma boa comparação em que eles tentaram várias maneiras de serializar os DataFrames Pandas: eficientemente armazenar os DataFrames Pandas.
Eles comparam:
- pickle: formato original de dados ASCII
- cPickle, uma biblioteca C
- pickle-p2: usa o formato binário mais recente
- json: standardlib JSON library
- json-no-index: como json, mas sem index
- msgpack: JSON binário alternativa
- CSV
- hdfstore: formato de armazenamento HDF5
Em sua experiência eles serializam um DataFrame de 1.000.000 linhas com as duas colunas testadas separadamente: uma com dados de texto, a outra com números. A declaração de exoneração de responsabilidade diz:
Você não deve confiar que o que se segue generaliza aos seus dados. Você deve olhar para os seus próprios dados e executar benchmarks você mesmo
O código-fonte para o teste a que se referem está disponível online . Uma vez que este código não funcionou diretamente, eu fiz algumas pequenas alterações, que você pode obter aqui: serialize.py Tenho os seguintes resultados:
Eles também mencionam que com a conversão de dados de texto para categóricos dados a serialização é muito mais rápida. Em seu teste cerca de 10 vezes mais rápido (também Veja o código de teste).
Edit : as horas mais elevadas para o pickle do que o csv podem ser explicadas pelo formato de dados usado. Por omissão pickle
usa uma representação ASCII imprimível, que gera conjuntos de dados maiores. Como pode ser visto do grafo no entanto, pickle usando o formato de dados binários mais recente (versão 2, pickle-p2
) tem tempos de carga muito mais baixos.
Algumas outras referências:
- na pergunta a biblioteca Python mais rápida a ler um ficheiro CSV existe uma resposta muito detalhada que compara bibliotecas diferentes a ler ficheiros csv com uma referência. O resultado é que para ler csv ficheiros
numpy.fromfile
é o mais rápido. - outro teste de serialização mostra o msgpack-python, ujson , e cPickle para ser o mais rápido em serialização.
Se eu entendi corretamente, você já está usando {[[[0]} mas gostaria de acelerar o processo de desenvolvimento para que você não tenha que carregar o arquivo em cada vez que você editar o seu script, está certo? Tenho algumas recomendações:
Você poderia carregar em apenas uma parte do arquivo CSV usando
pandas.read_csv(..., nrows=1000)
para carregar apenas os bits superior da tabela, enquanto você está fazendo o desenvolvimentoUse ipython para uma sessão interactiva, de modo a manter a tabela pandas em memória enquanto edita e recarrega o seu script.
Converter o csv para uma tabela HDF5
Atualizado use
DataFrame.to_feather()
epd.read_feather()
para armazenar dados no R-compatível pena formato binário que é super rápido (em minhas mãos, ligeiramente mais rápido do quepandas.to_pickle()
em dados numéricos e muito mais rápido em dados de seqüência de caracteres).
Você também pode estar interessado em esta resposta no stackoverflow.
import pandas as pd
df.to_pickle('123.pkl') #to save the dataframe, df to 123.pkl
df1 = pd.read_pickle('123.pkl') #to load 123.pkl back to the dataframe df
Os pandas DataFrames têm a função to_pickle
que é útil para gravar um DataFrame:
import pandas as pd
a = pd.DataFrame({'A':[0,1,0,1,0],'B':[True, True, False, False, False]})
print a
# A B
# 0 0 True
# 1 1 True
# 2 0 False
# 3 1 False
# 4 0 False
a.to_pickle('my_file.pkl')
b = pd.read_pickle('my_file.pkl')
print b
# A B
# 0 0 True
# 1 1 True
# 2 0 False
# 3 1 False
# 4 0 False
Pode usar o ficheiro de formato de penas. É extremamente rápido.
df.to_feather('filename.ft')
Os formatos de ficheiros Numpy são bastante rápidos para os dados numéricos
Eu prefiro usar arquivos numpy, já que eles são rápidos e fáceis de trabalhar. Aqui está uma referência simples para salvar e carregar um dataframe com uma coluna de 1 milhão de pontos.import numpy as np
import pandas as pd
num_dict = {'voltage': np.random.rand(1000000)}
num_df = pd.DataFrame(num_dict)
Usando a função mágica de ipython %%timeit
%%timeit
with open('num.npy', 'wb') as np_file:
np.save(np_file, num_df)
A saída é
100 loops, best of 3: 5.97 ms per loop
Para carregar os dados de volta para um dataframe
%%timeit
with open('num.npy', 'rb') as np_file:
data = np.load(np_file)
data_df = pd.DataFrame(data)
A saída é
100 loops, best of 3: 5.12 ms per loop
NADA MAL!
CONS
Há um problema. se gravar o ficheiro numpy com o python 2 e tentar abrir com o python 3 (ou vice-versa).import pickle
example_dict = {1:"6",2:"2",3:"g"}
pickle_out = open("dict.pickle","wb")
pickle.dump(example_dict, pickle_out)
pickle_out.close()
O código acima irá gravar o ficheiro pickle
pickle_in = open("dict.pickle","rb")
example_dict = pickle.load(pickle_in)
Estas duas linhas irão abrir o ficheiro pickle gravado