Polars read_csv(): Läs in CSV-data snabbt i Python

Om du regelbundet använder Python för dataanalys, precis som jag, märker du snart att läsning av CSV-filer är en av de vanligaste uppgifterna. Men i takt med att dina datamängder växer kan den här metoden bli långsam eller minneskrävande.

Polars är ett snabbt, modernt DataFrame-bibliotek för Python som är utformat som ett högpresterande alternativ till Pandas. Det kan hantera stora datamängder betydligt smidigare än traditionella verktyg eftersom det är byggt med fokus på hastighet och låg minnesanvändning.

Polars grundfunktion pl.read_csv() ger en enkel lösning för att läsa in CSV-filer till en DataFrame, med inbyggda alternativ för att styra parsning, datatyper och minnesanvändning.

I den här guiden visar jag hur du läser CSV-filer, styr parsning och hanterar stora datamängder med Polars pl.read_csv()-funktionen. Om du precis har börjat kan du kolla in vår kurs Introduction to Polars för att lära dig att manipulera data och få insikter med Polars.

Grundläggande användning av pl.read_csv()

Innan vi går vidare, kolla in vår handledning om Python Polars för att lära dig hur du ställer in din miljö. 

Låt oss nu titta på hur funktionen pl.read_csv() fungerar: 

# import the module
import polars as pl

# Load CSV into a Polars DataFrame
fuel_data = pl.read_csv("Fuel_Consumption_2000-2022.csv")  

# Preview first few rows
print(fuel_data.head())  

I exemplet ovan läser Polars filen och läser in den i en DataFrame. Funktionen returnerar en Polars DataFrame, som är en tabellstruktur liknande det du får i pandas.

Som standard gör pl.read_csv() följande:

• Antar att första raden innehåller kolumnnamn (has_header=True)

• Identifierar automatiskt kolumndatatyper

• Använder komma (,) som avgränsare

• Läser in hela filen i minnet

Vanliga parametrar i pl.read_csv()

Nu när du har lärt dig hur pl.read_csv() läser in data, låt oss titta på hur du kan använda följande parametrar för att anpassa hur Polars tolkar din data.

Sökväg och källa

Polars låter dig läsa in data från olika källor. Du kan skicka en lokal strängsökväg, ett Pathlib-objekt eller till och med en URL. Följande kod läser till exempel en stor csv-fil från webben med BNP för olika länder under olika år.

# Reading from a URL
url = "https://raw.githubusercontent.com/datasets/gdp/master/data/gdp.csv"
gdp_data = pl.read_csv(url)

Avgränsare och separatorer

Alla CSV-filer använder inte kommatecken. Du kan använda argumentet separator för att hantera tabbar, semikolon, lodstreck eller andra tecken. Exemplet nedan visar hur du anger avgränsare när du läser filer

# Reading a Semicolon-separated file
sales_data = pl.read_csv("2024_sales.csv", separator=";")

# Reading a Tab-separated file (TSV)
orders_data = pl.read_csv("all_orders.tsv", separator="\t")

Hantering av header

Som vi såg tidigare antar Polars att den första raden i datat innehåller kolumnnamn. Om din fil inte har en header-rad använder du parametern has_header=False som visas nedan. Polars tilldelar då automatiskt kolumnnamn som column_1, column_2, column_3 och så vidare.

# Load file without a header
orders_data = pl.read_csv("all_orders.csv", has_header=False)

Du kan också byta namn på kolumner genom att ange specifika kolumnnamn. Till exempel:

# Providing specific column names
sales_data = pl.read_csv("sales_April.csv", new_columns=[
    "OrderDate", "OrderNumber", "ProductKey", "SalespersonKey", "Salesperson"])

Teckenkodning

Olika CSV-filer kan använda olika teckenkodningar. Om du stöter på konstiga tecken eller fel, ange kodningen:

# Load CSV into a Polars DataFrame
fuel_data = pl.read_csv("Fuel_Consumption_2000-2022.csv", encoding="utf8")  

Andra vanliga kodningsalternativ inkluderar "latin1" och "utf8-lossy", som hanterar ogiltiga tecken på ett lämpligt sätt.

Hur du väljer kolumner när du läser CSV i Polars

När du arbetar med stora CSV-filer behöver du ofta inte varje kolumn. Polars låter dig läsa in bara de kolumner du behöver med parametern columns.

# Load only specific columns
fuel_data = pl.read_csv("Fuel_Consumption_2000-2022.csv",
    columns=["YEAR", "MAKE", "MODEL"]
)

När du väljer nödvändiga kolumner vid inläsning minskar minnesanvändningen genom att onödig data inte läses in. Denna metod påskyndar också filinläsningen och förbättrar den övergripande prestandan i pipelinen.

Hur du hanterar datatyper (schema) i Polars CSV

Polars är ett starkt typat bibliotek, vilket betyder att varje kolumn måste ha en konsekvent datatyp, till exempel alla heltal eller alla strängar.

Automatisk typinferens

Som standard inspekterar Polars din data och bestämmer automatiskt kolumntyper. Standardmetoden fungerar bra i de flesta fall men kan ibland misstolka kolumner, till exempel behandla ID som heltal i stället för strängar.

Ange schema manuellt

När du vill ha konsekvens i din DataFrame bör du ange dataschemat manuellt. Detta säkerställer konsekvens över flera filer och hjälper dig undvika typerelaterade fel i efterföljande bearbetning. 

I de flesta fall använder du schema_overrides för att ange datatyp för specifika kolumner samtidigt som Polars får inferera resterande kolumner

import polars as pl

# Manually overriding specific data types
empl_data = pl.read_csv(
    "all_employees.csv",
    schema_overrides={
        "id": pl.Int64,
        "name": pl.String,
        "age": pl.Int64,
        "salary": pl.Float64
    }
)

Eller använd schema för att definiera hela strukturens DataFrame.

# Manually define the full schema
empl_data = pl.read_csv(
    "all_employees.csv",
    schema={
        "id": pl.Int64,
        "name": pl.String,
        "age": pl.Int64,
        "salary": pl.Float64
    }
)

Hur du hanterar saknade värden i Polars CSV

Som standard upptäcker Polars automatiskt dessa saknade värden och representerar dem som null. Ibland representeras saknade värden av specifika strängar, såsom "NA", "N/A" eller "missing". Du kan ange dessa med null_values för att behandla dem som null. 

# Treating "N/A" and "EMPTY" as nulls
survey_data = pl.read_csv(
    "survey_results.csv",
    null_values=["N/A", "EMPTY", "null"]
)

När du hanterar saknade värden korrekt säkerställer du konsekventa datatyper och förhindrar felaktiga beräkningar, vilket minskar fel under analys och modellering.

Läsa stora CSV-filer i Polars

När du arbetar med stora datamängder som överskrider tillgängligt RAM-minne briljerar Polars genom att bearbeta data utan att läsa in hela filen på en gång.

Lazy loading med scan_csv()

I stället för att omedelbart läsa in data i minnet som read_csv() gör, erbjuder Polars ett lazy-alternativ, scan_csv(), som bygger en optimerad frågeplan och utför endast nödvändiga operationer.

I exemplet nedan skannar pl.scan_csv CSV-filen utan att läsa in den, bygger en fråga för att hämta endast kolumnerna ”YEAR”, ”MAKE” och ”MODEL” där bilmärket är ”ACURA”, och kör sedan den frågan. Den här åtgärden läser endast in det filtrerade datautdraget i minnet, i stället för hela filen.

# Lazily reference the file (no data loaded yet)
fuel_consumption = pl.scan_csv("Fuel_Consumption_2000-2022.csv")  

fuel_consumption_filtered = fuel_consumption.select(
    ["YEAR", "MAKE", "MODEL"]).filter(pl.col("MAKE") == "ACURA")

# Execute the query and load only the required data
fuel_consumption_acura = fuel_consumption_filtered.collect()  

Jag rekommenderar att du använder scan_csv() när:

• Du arbetar med stora filer som inte får plats bekvämt i minnet
• Du tillämpar flera transformationer, såsom filtrering, val av kolumner och aggregering
• Du vill ha frågeoptimering före körning

Streaming och minneseffektivitet

Polars tillåter också streaming för att bearbeta data i segment, vilket håller toppminnet konstant oavsett filstorlek.

För stora CSV-filer, börja med scan_csv() för att skapa en lazy-fråga. Filen läses inte in helt när scan_csv() anropas.

# Read data in chunks
fuel_consumption = pl.scan_csv("Fuel_Consumption_2000-2022.csv",
 low_memory=True)

Eftersom metoden ovan fortfarande använder read_csv är det bästa tillvägagångssättet att kombinera lazy-körning med streaming. 

I exemplet nedan bearbetar Polars filen i en pipeline, rad för rad i batcher, och håller endast de filtrerade raderna (där "CYLINDERS" > 3) i minnet vid varje given tidpunkt. 

# Lazily reference the file (no data loaded yet)
fuel_consumption = pl.scan_csv("Fuel_Consumption_2000-2022.csv")  

result = fuel_consumption.filter(pl.col("CYLINDERS") > 3)

# Stream execution instead of loading everything at once
fuel_consumption_high = result.collect(engine="streaming")

Prestandafördel jämfört med Pandas

Jämfört med pandas presterar Polars ofta bättre för CSV-läsning och -bearbetning, som vi ska se i nästa avsnitt.

Polars read_csv vs Pandas read_csv

Tabellen nedan sammanfattar skillnaden mellan Polars och Pandas när man läser csv i Python.

Jag rekommenderar att läsa vår artikel om skillnaderna mellan Pandas vs. Polars för att avgöra vilket verktyg som bäst passar dina analysbehov.

Läsa CSV från olika källor

Som vi såg tidigare kan du använda Polars för att läsa csv-filer från olika källor. I exemplen ovan har jag visat hur du läser csv från lokala filer och URL:er.

Dessutom kan Polars automatiskt hantera komprimerade CSV-filer. Följande kod läser till exempel data från en .gzip-fil.

# Read gzip-compressed CSV
census_data = pl.read_csv("2018_census.csv.gz")

Vanliga fel och felsökning

Även med en högpresterande motor som Polars kan du ändå stöta på vissa problem, särskilt när du läser en csv-fil. Nedan följer några vanliga problem jag har stött på och hur man åtgärdar dem.

• Kodningsfel: Du kan se ett fel som UnicodeDecodeError, vilket betyder att filen inte använder UTF-8-kodning, ett problem som är vanligt med äldre filer eller CSV:er som exporterats från vissa versioner av Excel. För att lösa detta, ange rätt kodning eller använd "utf8-lossy" om filen har inkonsekventa eller trasiga tecken.

• Problem med avgränsare: Om din DataFrame läses in men all data hamnar i en enda kolumn kände Polars inte igen avgränsaren. Lös detta genom att uttryckligen ange korrekt avgränsare med argumentet separator, till exempel semikolon (;), tabb (\t) eller lodstreck (|).

• Felaktiga datatyper: Ibland kan Polars inferera kolumntyper felaktigt, till exempel läsa numeriska ID som strängar eller stöta på parsningsfel. När detta händer kan du använda schema_overrides för att ange datatyp för vissa kolumner. Om du vill definiera typer för varje kolumn, använd schema. Du kan också öka infer_schema_length så att Polars undersöker fler rader innan schemat infereras.

• Minnesproblem med stora filer: Om din Python-process kraschar när du läser in en stor fil betyder det att du har slut på RAM. För att åtgärda detta, växla från read_csv() till scan_csv() för lazy loading för att minska minnesanvändningen och förbättra prestandan. Du kan också läsa in färre kolumner från datamängden eller använda strömmad körning för att läsa in data i segment.

Slutsats

Funktionen read_csv() i Polars är enkel att använda men tillräckligt kraftfull för verkliga uppgifter. Enligt min mening har Polars ett tydligt övertag när man arbetar med växande datamängder.

Som nästa steg kan du läsa vår blog om Polars GPU-motor för att lära dig mer om dess olika användningsområden. Om du är redo att bli praktisk kan du följa vår Super Bowl Analytics with Polars code-along för att lösa verkliga analytiska frågor, tillämpa beräkningar och använda grundläggande ML-tekniker på sportanalytiska problem.