Início / coding / Perguntas / 79585543
Accepted
rysch
Asked: 2025-04-22 09:01:35 +0800 CST

Como processar eficientemente um arquivo CSV grande com o Pandas quando a memória é limitada?

  • 772

Estou trabalhando com um arquivo CSV muito grande (cerca de 10 GB) que não cabe na memória do meu computador. Quando tento carregá-lo em um DataFrame do Pandas usando pd.read_csv(), recebo um MemoryError.

Qual é a maneira mais eficiente de processar este arquivo usando o Pandas sem carregar tudo na memória de uma vez? Preciso realizar operações como:

  • Calculando a soma de uma coluna específica.
  • Filtragem de linhas com base em determinadas condições.
  • Agrupamento e agregação de dados.

Meu código:

import pandas as pd
import numpy as np

# Simulate a large CSV file
with open('large_file.csv', 'w') as f:
    for i in range(10000000):  # 10 million rows
        f.write(f'{i},{np.random.rand()},{np.random.randint(0, 10)}\n')


# This line causes a MemoryError
df = pd.read_csv('large_file.csv', names=['id', 'value', 'category'])

# Desired operations (example)
# total_value = df['value'].sum()
# filtered_df = df[df['category'] > 5]
# grouped_df = df.groupby('category')['value'].mean()

print("Processing Complete") # Never Reaches Here.

Tentei usar chunksizein pd.read_csv(), mas não tenho certeza de como executar com eficiência as operações desejadas nos blocos e combinar os resultados. Há outras técnicas ou bibliotecas que eu deva considerar?

python

2 respostas

  1. Best Answer

    Talvez faça assim:

    import pandas as pd
import numpy as np
from collections import defaultdict
np.random.seed(0)  # Use same random numbers for testing

# Simulate a large CSV file
with open('large_file.csv', 'w') as f:
    for i in range(10000000):  # 10 million rows
        f.write(f'{i},{np.random.rand()},{np.random.randint(0, 10)}\n')

# Read in chunks of 100
chunk_iter = pd.read_csv('large_file.csv', names=['id', 'value', 'category'], chunksize=100)

# Update these for each chunk
value_sums = defaultdict(float)
value_counts = defaultdict(int)
total_value = 0.0

for chunk in chunk_iter:
    total_value += chunk['value'].sum()
    filtered = chunk[chunk['category'] > 5]
    # Group by and update running sums and counts
    group = filtered.groupby('category')['value'].agg(['sum', 'count'])
    for cat, row in group.iterrows():
        value_sums[cat] += row['sum']
        value_counts[cat] += row['count']

# Compute final mean per category
grouped_mean = {cat: value_sums[cat] / value_counts[cat] for cat in value_sums}

print(f'{total_value=}')
print(f'{grouped_mean=}')
print("Processing Complete")
    • 2

  2. Se o seu objetivo é garantir baixo uso de memória, eu usaria o csvpacote apenas para transmitir, ler e gravar os dados de interesse. Durante a leitura, eu monitoraria os dados necessários para construir os resultados finais que você busca.

    import csv
import numpy    # for random
import json     # for nice printing

## ---------------------------------
## Simulate a CSV file with arbitrary number of rows
## ---------------------------------
def get_next_row(limit):
    for i in range(limit):
        yield f"{i},{numpy.random.rand()},{numpy.random.randint(0, 10)}\n"
## ---------------------------------

FIELDNAMES = ["id", "value", "category"]
FILTERED_FILENAME = "filtered.csv"

## ---------------------------------
## The values you seek
## ---------------------------------
total_value = 0
grouped_data = {}
## ---------------------------------

## ---------------------------------
## A reader that reads from the simulated CSV file
## the generator here allows you to test with almost
## any size of data
## ---------------------------------
reader = csv.reader(get_next_row(100_000)) # lots of rows. feel free to set to 10m
## ---------------------------------

with open(FILTERED_FILENAME, "w", newline="") as filtered_file:
    ## ---------------------------------
    ## Open the filtered file and write the header
    ## ---------------------------------
    writer = csv.writer(filtered_file)
    writer.writerow(FIELDNAMES)
    ## ---------------------------------

    ## ---------------------------------
    ## Stream read the CSV file
    ## ---------------------------------
    for row in reader:
        _, value, category = map(float, row)

        ## ---------------------------------
        ## construct our running total
        ## ---------------------------------
        total_value += value
        ## ---------------------------------

        ## ---------------------------------
        ## Construct grouping on the fly
        ## ---------------------------------
        target = grouped_data.setdefault(category, {"sum":0, "count":0})
        target["sum"] += value
        target["count"] += 1
        ## ---------------------------------

        ## ---------------------------------
        ## Stream write filtered data to a new CSV file
        ## ---------------------------------
        if category > 5:
            writer.writerow(row)
        ## ---------------------------------
    ## ---------------------------------

print("Example Results:")

print(f"\tTotal: {total_value}")

print("\tGrouped Totals:")
for key, value in grouped_data.items():
    print(f"\t\t{key}: {value["sum"] /value["count"]}")

print("\tFiltered:")
with open(FILTERED_FILENAME, "r") as filtered_file:
    reader = csv.reader(filtered_file)
    for row in reader:
        print(f"\t\t{row}{ " " * 20 }", end="\r")
    print("\n")

    Dando a você algo como:

    Example Results:
        Total: 49901.74831312535
        Grouped Totals:
                7.0: 0.5040226167253907
                6.0: 0.49718272454103724
                0.0: 0.49830374656445003
                4.0: 0.5020429187707787
                3.0: 0.4945115761171055
                9.0: 0.4959816647030425
                1.0: 0.49440301035945405
                8.0: 0.5026981953484214
                2.0: 0.49715019019186407
                5.0: 0.5038847853189612
        Filtered:
                ['99999', '0.26387763159374467', '7']
    • 0

relate perguntas