Strömmande CSV med chunksize

När en CSV-fil är större än det tillgängliga RAM-minnet — till exempel en loggfil på 50 GB på en dator med 16 GB minne — misslyckas anropet pd.read_csv('file.csv') med ett MemoryError, eller så börjar systemet använda växlingsminnet intensivt och blir oanvändbart långsamt. Lösningen är läsning i chunkar: i stället för att läsa in hela filen på en gång bearbetar ni den i delar av fast storlek och samlar resultaten utan att någonsin ha allt i minnet samtidigt.

Om ni skickar chunksize=N till pd.read_csv() returneras en TextFileReader-iterator i stället för en DataFrame. Varje iteration returnerar en DataFrame med högst N rader. Filen läses in lazily — inga data läses in förrän ni begär nästa chunk. Den här iteratorn kan användas i en for-loop eller skickas till pd.concat(). Välj ett chunksize som är tillräckligt stort för effektiv I/O (till exempel 10 000–100 000 rader), men tillräckligt litet för att utan problem få plats i minnet.

Det vanligaste mönstret är att utföra en transformering eller filtrering på varje chunk och samla resultaten i en lista som sedan konkateneras. Ni kan till exempel filtrera rader som matchar ett villkor, beräkna statistik per chunk eller bara välja de kolumner ni behöver. När ni arbetar med delmängder är det bara den aktuella chunken som tar upp minne, medan resten av filen förblir orörd. Efter loopen sammanfogar ett enda pd.concat(results) den slutliga DataFrame-objektet.

Ibland behöver ni inte behålla några rader alls — ni behöver bara en löpande aggregering. Håll reda på en löpande summa, ett antal eller min/max över chunkarna utan att bygga upp en lista med DataFrame-objekt. Det här är det mest minneseffektiva mönstret, eftersom minnesanvändningen förblir konstant oavsett filstorlek. Beräkna den slutliga statistiken från era ackumulatorer när allt är klart.

Som standard härleder Pandas kolumnernas datatyper från data, vilket kräver att varje chunk genomsöks två gånger (en gång för att härleda typen och en gång för att tolka data). Om ni anger argumentet dtype undviker ni denna extrakostnad och förhindrar dessutom inkonsekventa datatyper mellan chunkar. En kolumn som till exempel huvudsakligen innehåller heltal men har en tom cell kan härledas som float64 i en chunk och object i en annan. Genom att uttryckligen ange datatyper säkerställer ni konsekvent och snabbare läsning av alla chunkar.

Använd parametern usecols för att bara läsa in de kolumner som analysen behöver. Om en CSV-fil har 50 kolumner men er aggregering bara använder 3 finns det ingen anledning att tolka de övriga 47. Om ni kombinerar usecols med chunksize minskar ni både I/O-tiden och minnesanvändningen avsevärt. Det här är en av de enklaste och mest effektiva optimeringarna vid bearbetning av stora CSV-filer.

För att utföra en groupby-aggregering över chunkar måste ni samla delresultat. Beräkna groupby inom varje chunk och kombinera sedan resultaten med en andra groupby på de konkatenerade delresultaten. Om ni till exempel vill få fram den totala försäljningen per region i en fil på 10 GB samlar ni regionsummorna från varje chunk i en lista och konkatenerar dem, för att sedan gruppera igen. Det här mönstret med aggregering i två steg kallas ibland för ett map-reduce-tillvägagångssätt.

Stora CSV-filer från externa källor innehåller ofta felaktigt formaterade rader — extra kommatecken, fel kodning eller avkortade rader. Använd on_bad_lines='skip' (Pandas 1.3+) eller error_bad_lines=False (äldre Pandas) för att tyst hoppa över felaktiga rader, och encoding='latin-1' om tolkningen med UTF-8 misslyckas. Håll reda på vilka chunkar som gav fel genom att använda try-except runt bearbetningen av varje chunk. På så sätt kan ni bygga en robust pipeline som inte kraschar på grund av en enda felaktig rad i en fil med 10 miljoner rader.

När den bearbetade utdatan också är stor bör ni skriva resultaten stegvis i stället för att samla allt i minnet och skriva i slutet. Öppna en CSV-fil och lägg till varje bearbetad chunk med mode='a' och header=False för efterföljande chunkar. Då förblir minnesanvändningen i utdatapipelinen konstant, och ni kan granska delresultat innan hela körningen är klar.

Att välja chunksize är en avvägning: ett för litet värde innebär många iterationer i Python-loopen och hög omkostnad, medan ett för stort värde innebär att chunkarna inte får plats i RAM-minnet. Ett praktiskt tillvägagångssätt är att läsa in en chunk, mäta dess minnesanvändning med chunk.memory_usage(deep=True).sum() och ange chunksize så att varje chunk använder ungefär 10–20 % av det tillgängliga RAM-minnet. Pythons psutil.virtual_memory().available ger tillgängligt RAM under körning, vilket möjliggör en adaptiv beräkning av chunksize.

När ni samlar många DataFrame-objekt från chunkar i en lista och sedan konkatenerar dem bör ni tänka på att anrop av pd.concat för hundratals små DataFrame-objekt är långsamt på grund av upprepade minnesallokeringar. Ett bättre mönster är att aggregera inom varje chunk och bara spara det lilla aggregerade resultatet, inte hela chunken. Om ni verkligen behöver alla rader går det snabbare att skriva stegvis till en Parquet-fil (med pyarrow) än att använda pd.concat i slutet.

I den här lektionen har ni lärt er att chunksize i pd.read_csv returnerar en iterator med DataFrame-objekt som möjliggör minneseffektiv bearbetning av stora filer, att argumenten usecols och dtype minskar minnesanvändningen per chunk och snabbar upp tolkningen, samt att löpande ackumulatorer (summa, antal och delresultat) förhindrar att en lista med alla chunkar byggs upp. Nästa steg är att titta närmare på mönster för stegvis aggregering över chunkar.