Introduksjon til Dask DataFrames
Erstatt pd.read_csv og pd.DataFrame med tilsvarende Dask-funksjoner, kall compute() for å starte kjøringen, og profiler oppgavegrafene.
Introduksjon til Dask DataFrames er en gratis leksjon i Pandas & NumPy Academy på CoddyKit. Dette er leksjon 3 av 4. Du kan lese hele leksjonen gratis nedenfor – og deretter øve praktisk i nettleseren med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i Pandas & NumPy Academy, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i Pandas & NumPy Academy inneholder totalt 4 leksjoner.
Hva er Dask?
Dask er et bibliotek for parallell databehandling i Python som utvider NumPy og Pandas til datasett som er større enn RAM. Modulen dask.dataframe tilbyr et DataFrame-API som nesten er identisk med Pandas, men i stedet for å utføre operasjoner umiddelbart bygger Dask en oppgavegraf og utfører den utsatt når De kaller .compute(). Dette gjør det mulig for Dask å parallellisere arbeidet på tvers av flere kjerner eller til og med flere maskiner, med minimale kodeendringer.
Installere og importere Dask
Dask installeres med pip install dask[dataframe]. Den vanlige importkonvensjonen er import dask.dataframe as dd. Under panseret er en Dask DataFrame delt opp i mange mindre Pandas DataFrames, som hver behandles uavhengig. Operasjoner på Dask DataFrame oppretter en lat oppgavegraf — ingenting kjøres før .compute() kalles. Dette skillet mellom å beskrive og å utføre beregningen er den sentrale innsikten i Dask.
import dask.dataframe as dd
# Read a large CSV — returns a Dask DataFrame immediately (no data loaded yet)
ddf = dd.read_csv('large_sales.csv')
print(type(ddf)) # dask.dataframe.core.DataFrame
print(ddf.columns.tolist())
print(ddf.dtypes)Dask kontra Pandas: Den viktigste forskjellen
Med Pandas utføres alle operasjoner umiddelbart og ivrig. Med Dask returnerer operasjoner et nytt Dask-objekt som representerer den utsatte beregningen. Først når De kaller .compute(), leser Dask faktisk data og utfører oppgavegrafen. Denne latheten gjør at Dask kan optimalisere planen før utføring — for eksempel kan den slå sammen påfølgende filtre for å unngå å laste inn data flere ganger. Tenk på det som en oppskrift: Dask skriver oppskriften, og .compute() lager måltidet.
import dask.dataframe as dd
ddf = dd.read_csv('sales.csv')
# This does NOT run yet — just builds the task graph
filtered = ddf[ddf['amount'] > 1000]
agg = filtered.groupby('region')['amount'].sum()
print(type(agg)) # dask.dataframe.core.Series
# NOW execute everything
result = agg.compute()
print(result)Partisjoner: Det sentrale konseptet
En Dask DataFrame er delt opp i partisjoner, der hver partisjon er en vanlig Pandas DataFrame. Som standard oppretter dd.read_csv én partisjon per fil (eller én per 128 MB for store filer). De kan styre dette med blocksize. Ved å kontrollere ddf.npartitions ser De hvor mange partisjoner som finnes. Flere partisjoner gir mer parallellitet, men medfører mer overhead; færre partisjoner reduserer overhead, men begrenser parallelliteten. Det optimale punktet er vanligvis noen hundre partisjoner.
import dask.dataframe as dd
ddf = dd.read_csv('data/*.csv') # Read multiple CSV files at once
print('Number of partitions:', ddf.npartitions)
# Access a single partition as a Pandas DataFrame
first_partition = ddf.get_partition(0).compute()
print('Partition 0 shape:', first_partition.shape)Kjente Pandas-operasjoner i Dask
De fleste vanlige Pandas-operasjoner fungerer på samme måte i Dask: .head(), .tail(), .describe(), boolsk indeksering, .groupby(), .merge() og .assign() har alle tilsvarende Dask-operasjoner. Den største forskjellen er at De må kalle .compute() for å materialisere resultatet. Operasjoner som Pandas håndterer på millisekunder, kan ta sekunder i Dask på grunn av overheaden fra oppgavegrafen — bruk derfor Pandas for små datamengder og Dask når dataene ikke får plass i RAM.
import dask.dataframe as dd
ddf = dd.read_csv('transactions.csv')
# Filtering — same syntax as Pandas
high_value = ddf[ddf['amount'] > 500]
# GroupBy aggregation
by_region = high_value.groupby('region')['amount'].mean()
# Execute
result = by_region.compute()
print(result.sort_values(ascending=False))Lese flere filer med glob-mønstre
En av de mest nyttige funksjonene i Dask er å lese flere filer samtidig ved hjelp av glob-mønstre. dd.read_csv('data/2024-*.csv') leser alle samsvarende filer og oppretter én partisjon per fil. Dette passer perfekt for data som er lagret i månedlige eller daglige partisjonerte filer, et vanlig mønster i datasjøer. Dask samordner skjemaene automatisk, noe som tilsvarer å iterere manuelt gjennom filer og sette dem sammen med Pandas, men er langt enklere.
import dask.dataframe as dd
# Read all monthly files at once
ddf = dd.read_csv('sales/2024-*.csv',
dtype={'order_id': 'int32',
'amount': 'float32'})
print(f'Partitions: {ddf.npartitions}') # One per file
print(f'Total rows (lazy): {len(ddf)}') # This triggers a compute!Metoden visualize() for oppg apresentasjoner
Før De utfører en kompleks Dask-pipeline, kan De inspisere oppgavegrafen ved å kalle result.visualize(), som genererer et PNG-diagram over alle beregningstrinnene. Dette er nyttig for å forstå hva Dask kommer til å utføre og for å feilsøke uventet treghet. Grafen viser hvordan partisjoner flyter gjennom trinn for filtrering, groupby og aggregering, slik at det blir enkelt å oppdage overflødige beregninger. Krever pakken graphviz.
import dask.dataframe as dd
ddf = dd.read_csv('orders.csv')
pipeline = (
ddf[ddf['status'] == 'completed']
.groupby('product_id')['revenue']
.sum()
)
# Visualise the task graph (saves to PNG)
# pipeline.visualize('task_graph.png')
# Check number of tasks in the graph
print('Number of tasks:', len(pipeline.__dask_graph__()))Bruke egendefinerte funksjoner med map_partitions
Når De trenger å bruke en egendefinert Pandas-funksjon på en Dask DataFrame, bruker De ddf.map_partitions(func). Dette bruker func på hver partisjon uavhengig og returnerer en ny Dask DataFrame. Funksjonen mottar en vanlig Pandas DataFrame og må returnere en slik. Dette er Dasks tilsvarende løsning til df.apply() og er måten De integrerer Dask med kode som bare forstår Pandas.
import dask.dataframe as dd
import pandas as pd
def normalise_chunk(df):
df = df.copy()
df['amount_norm'] = (df['amount'] - df['amount'].mean()) / df['amount'].std()
return df
ddf = dd.read_csv('data.csv')
normalised = ddf.map_partitions(normalise_chunk)
result = normalised[['order_id', 'amount_norm']].compute()
print(result.head())Alternativer for Dask-planlegger
Dask har flere planleggere som styrer hvordan oppgaver utføres. Planleggeren 'synchronous' kjører oppgaver sekvensielt i den gjeldende tråden (nyttig ved feilsøking). Planleggeren 'threads' bruker en trådpool (egnet for I/O-bundet arbeid). Planleggeren 'processes' starter flere prosesser for CPU-bundet arbeid (omgår Pythons GIL). En distribuert Dask-klynge muliggjør kjøring på flere maskiner. Angi planleggeren med compute(scheduler='threads').
import dask.dataframe as dd
ddf = dd.read_csv('data.csv')
agg = ddf.groupby('category')['sales'].sum()
# Choose scheduler based on workload
result_sync = agg.compute(scheduler='synchronous') # sequential, easy to debug
result_threads = agg.compute(scheduler='threads') # parallel I/O
result_processes = agg.compute(scheduler='processes') # parallel CPUKonvertere mellom Dask og Pandas
Det er vanlig å behandle et stort datasett med Dask og deretter hente det aggregerte resultatet inn i Pandas for den avsluttende analysen eller visualiseringen. Bruk .compute() for å konvertere en Dask DataFrame til Pandas. I motsatt retning konverterer dd.from_pandas(df, npartitions=4) en Pandas DataFrame til en Dask DataFrame, noe som er nyttig for å teste Dask-kode på små datamengder før De skalerer opp til hele datasettet.
import pandas as pd
import dask.dataframe as dd
# Start with a small Pandas DF for testing
df_small = pd.DataFrame({'a': range(100), 'b': range(100, 200)})
# Convert to Dask for development/testing
ddf = dd.from_pandas(df_small, npartitions=4)
result = ddf.groupby('a')['b'].sum().compute()
print(type(result)) # pandas.Series
print(result.head())Når bør De bruke Dask, Pandas eller SQL?
Dask er ikke alltid det riktige verktøyet. Bruk Pandas når dataene får plass i RAM (mindre enn noen få GB) — det er enklere og raskere på grunn av mindre overhead. Bruk Dask når dataene overskrider RAM, men De ønsker Pandas-lignende syntaks og parallellitet på én maskin. Bruk SQL/database når dataene ligger i en relasjonsdatabase og aggregeringer kan sendes til databasemotoren. Bruk Spark eller BigQuery når De trenger distribuert behandling på flere maskiner i petabyteskala.
Hurtigsjekk
Test forståelsen Deres av konseptene innen dataanalyse fra denne leksjonen.
Oppsummering av leksjonen
I denne leksjonen har De lært at Dask DataFrames er late evaluerte samlinger av Pandas-partisjoner med et velkjent API, at .compute() utløser den faktiske utføringen av oppgavegrafen, og at map_partitions lar Dem bruke en hvilken som helst egendefinert Pandas-funksjon på tvers av alle partisjoner. Neste gang ser vi på Parquet-formatet som et raskt, kolonnebasert alternativ til CSV for lagring av store datasett.
Lær deg Python med en AI-veileder – gratis
Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.
- Kurs
- 30
- Leksjoner
- 120
Ofte stilte spørsmål
Er leksjonen «Introduksjon til Dask DataFrames» gratis?
Ja – hele teksten i «Introduksjon til Dask DataFrames» er gratis å lese her på nettet. For å øve interaktivt med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt, og for å låse opp resten av Pandas & NumPy Academy-kurset, kan du oppgradere til CoddyKit PRO. Kurset i Pandas & NumPy Academy inneholder totalt 4 leksjoner.
Hva lærer jeg i «Introduksjon til Dask DataFrames»?
Erstatt pd.read_csv og pd.DataFrame med tilsvarende Dask-funksjoner, kall compute() for å starte kjøringen, og profiler oppgavegrafene. Du øver på Pandas & NumPy Academy med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.
Trenger jeg erfaring for å begynne med Pandas & NumPy Academy?
Ingen tidligere erfaring er nødvendig. Pandas & NumPy Academy på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 3 av 4.
Hvor lang tid tar leksjonen «Introduksjon til Dask DataFrames»?
De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.
Kan jeg skrive og kjøre kode i denne Pandas & NumPy Academy-leksjonen?
Ja. Alle Pandas & NumPy Academy-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.
Alle leksjonene i dette kurset
- Strømming av CSV med chunksize
- Trinnvis aggregering på tvers av blokker
- Introduksjon til Dask DataFrames
- Parquet: rask kolonnelagring