Datarensning med pandas 3.0: Byg reproducerbare pipelines med pipe(), pd.col() og Copy-on-Write

Hvorfor skal du opgradere din datarensning til pandas 3.0?

Lad os være ærlige: datarensning er den del af ethvert dataprojekt, som ingen rigtig taler om til festerne – men som sluger op mod 80 % af din tid. Manglende værdier, duplikerede rækker, kolonner med forkerte datatyper, tekst formateret på fem forskellige måder i samme kolonne. Du kender det. Vi kender det alle.

Men med pandas 3.0 (udgivet januar 2026) er der faktisk sket noget interessant. Tre store ændringer gør hverdagen markant lettere:

• Copy-on-Write (CoW) er nu standard – du kan ikke længere komme til at overskrive dine originaldata ved et uheld. Det er enormt.
• pd.col() giver en ny, elegant måde at referere til kolonner på, uden at du skal rode med lambda-funktioner overalt.
• Ny string-dtype – tekstkolonner genkendes automatisk som str frem for det langsomme object-format.

I denne guide bygger vi en komplet, reproducerbar datarensningspipeline fra bunden. Alt kode kan genbruges direkte i dine egne projekter.

Opsætning: Installer pandas 3.0 og opret testdata

Først og fremmest – sørg for at du kører den nyeste version. Opdater med pip:

pip install --upgrade pandas pyarrow

Vi installerer også PyArrow, fordi pandas 3.0 bruger det som backend til den nye string-dtype. I mine egne tests har det givet 5-10x hurtigere strengoperationer sammenlignet med det gamle object-format. Det er svært at argumentere imod den slags forbedringer.

Nå, men lad os oprette et realistisk, rodet datasæt som vi kan rense gennem hele guiden:

import pandas as pd
import numpy as np

print(f"pandas version: {pd.__version__}")

# Simuler rodet kundedata fra en CSV-eksport
np.random.seed(42)
n = 500

raa_data = pd.DataFrame({
    "kunde_id": np.random.choice(range(1, 401), size=n),
    "navn": np.random.choice(
        ["Anna Hansen", "bo møller", "CLARA JENSEN", "David  Sørensen",
         "Eva Nielsen", None, "finn  olsen", "Gitte LARSEN"],
        size=n
    ),
    "email": np.random.choice(
        ["[email protected]", "[email protected]", "[email protected]", "invalid-email",
         "[email protected]", None, "[email protected]", "[email protected]"],
        size=n
    ),
    "alder": np.random.choice(
        [25, 30, 35, -5, 42, 150, None, 28],
        size=n
    ),
    "koebsbeloeb": np.random.choice(
        [199.95, 0, 4999.00, None, 89.50, 1250.00, -50, 349.99],
        size=n
    ),
    "kategori": np.random.choice(
        ["Elektronik", "elektronik", "ELEKTRONIK", "Tøj", "tøj",
         "Bolig", None, "Sport"],
        size=n
    ),
    "dato": np.random.choice(
        ["2025-03-15", "15/03/2025", "2025.03.15", None,
         "2025-06-01", "01-12-2025", "2025-09-20"],
        size=n
    )
})

print(raa_data.head(10))
print(f"\nShape: {raa_data.shape}")
print(f"\nDatatyper:\n{raa_data.dtypes}")

Det her datasæt har alle de klassiske problemer: manglende værdier, duplikerede kunder, inkonsistent formatering, ugyldige værdier og blandede datoformater. Perfekt til vores formål.

Trin 1: Forstå dine data, før du renser

Her er en fejl, jeg ser ret tit (og ærligt talt også selv har begået): man kaster sig direkte ud i rensningen uden at forstå, hvad man arbejder med. Tag dig de ekstra to minutter. Det betaler sig.

# Overblik over manglende værdier
print("Manglende værdier per kolonne:")
print(raa_data.isnull().sum())
print(f"\nSamlet antal manglende: {raa_data.isnull().sum().sum()}")

# Procentvis manglende data
pct_manglende = (raa_data.isnull().sum() / len(raa_data) * 100).round(1)
print(f"\nProcent manglende:\n{pct_manglende}")

# Tjek for duplikater
print(f"\nDuplikerede rækker: {raa_data.duplicated().sum()}")
print(f"Duplikerede kunde_id: {raa_data['kunde_id'].duplicated().sum()}")

# Unikke værdier i kategoriske kolonner
for col in ["kategori", "navn"]:
    print(f"\nUnikke værdier i '{col}': {raa_data[col].dropna().unique()}")

Denne hurtige inspektion afslører omfanget af problemerne. Du vil typisk se, at kategori-kolonnen har varianter som "Elektronik", "elektronik" og "ELEKTRONIK" – tre skrivemåder for det samme. Det er præcis den slags, der skal ryddes op.

Trin 2: Copy-on-Write – den nye standard

I pandas 3.0 er Copy-on-Write (CoW) nu den eneste tilstand. Det er en fundamental ændring i måden, pandas håndterer data på, og den påvirker al kode du skriver fremover.

Hvad betyder det helt konkret?

Reglen er simpel: ethvert subset af en DataFrame opfører sig altid som en kopi. Ændrer du et subset, ændrer du kun kopien – aldrig originalen.

# I pandas 3.0: dette ændrer IKKE raa_data
subset = raa_data[raa_data["kategori"] == "Elektronik"]
subset["kategori"] = "Elektronik & IT"  # Ændrer kun subset

print(raa_data["kategori"].unique())  # Originalen er uændret

Chained assignment virker ikke længere

Det gamle mønster, som rigtigt mange har brugt i årevis, er helt væk nu:

# VIRKER IKKE i pandas 3.0 – rejser ChainedAssignmentError:
# raa_data["alder"][raa_data["alder"] < 0] = None

# BRUG I STEDET .loc:
raa_data.loc[raa_data["alder"] < 0, "alder"] = None

Ja, det kan føles irriterende i starten. Men ærligt? Det er en kæmpe forbedring. Slut med SettingWithCopyWarning og det forvirrende gætteri om du arbejder med en kopi eller en view. Koden bliver mere forudsigelig, og du kan droppe alle de defensive .copy()-kald.

Trin 3: Byg rensningsfunktioner med pd.col()

Den nye pd.col()-syntaks er, efter min mening, den mest spændende nyhed i pandas 3.0 for datarensning. Den erstatter de verbose lambda-funktioner og gør method chaining væsentligt mere læsbart.

pd.col() vs. lambda – sammenligning

# Gammel stil med lambda:
df_gammel = raa_data.assign(
    alder_ok=lambda df: df["alder"].between(0, 120),
    hoej_vaerdi=lambda df: df["koebsbeloeb"] > 1000
)

# Ny stil med pd.col():
df_ny = raa_data.assign(
    alder_ok=pd.col("alder").between(0, 120),
    hoej_vaerdi=pd.col("koebsbeloeb") > 1000
)

print(df_ny[["alder", "alder_ok", "koebsbeloeb", "hoej_vaerdi"]].head())

Fordelen er ikke bare kortere kode. pd.col() undgår også et klassisk Python-problem med lambda-funktioner i løkker, hvor alle lambdaer ender med at referere til den samme variabel. Det problem har nok kostet mange af os timer af debugging.

Rens tekstkolonner med pd.col()

# Standardisér tekstkolonner i ét kald
renset = raa_data.assign(
    navn_renset=pd.col("navn").str.strip().str.title(),
    email_renset=pd.col("email").str.strip().str.lower(),
    kategori_renset=pd.col("kategori").str.strip().str.capitalize()
)

print(renset[["navn", "navn_renset"]].dropna().head())
print(renset[["kategori", "kategori_renset"]].dropna().head())

Du kan kæde strengmetoder direkte uden lambda. str.strip() fjerner overflødige mellemrum, str.title() konverterer til "Stort Forbogstav", og str.capitalize() sikrer ensartet formatering. Simpelt og læsbart – sådan bør det være.

Trin 4: Håndtér manglende værdier strategisk

Manglende værdier er uundgåelige. Den rigtige strategi afhænger af kolonnetypen, og der findes ikke ét rigtigt svar. Men her er en systematisk tilgang, der fungerer i de fleste situationer.

Numeriske kolonner: Median slår ofte gennemsnit

# Gennemsnit påvirkes af outliers – median er mere robust
print(f"Gennemsnit alder: {raa_data['alder'].mean():.1f}")
print(f"Median alder: {raa_data['alder'].median():.1f}")

# Fyld manglende alder med median
raa_data["alder"] = raa_data["alder"].fillna(raa_data["alder"].median())

# For købsbeløb: 0 giver mening som standardværdi
raa_data["koebsbeloeb"] = raa_data["koebsbeloeb"].fillna(0)

Kategoriske kolonner: Brug mode eller en eksplicit markør

# Fyld manglende kategorier med den hyppigste værdi
mest_hyppig = raa_data["kategori"].mode()[0]
print(f"Mest hyppige kategori: {mest_hyppig}")
raa_data["kategori"] = raa_data["kategori"].fillna(mest_hyppig)

# Alternativt: markér eksplicit som ukendt
# raa_data["kategori"] = raa_data["kategori"].fillna("Ukendt")

Tekstkolonner: Drop eller markér

# For nøglefelter som navn/email: drop rækker uden data
foer_drop = len(raa_data)
raa_data = raa_data.dropna(subset=["navn", "email"])
efter_drop = len(raa_data)
print(f"Fjernede {foer_drop - efter_drop} rækker uden navn eller email")

En vigtig tommelfingerregel her: brug dropna() med omtanke. Hvis du har mange kolonner med manglende værdier, kan du miste en overraskende stor del af dit datasæt. Specificér altid subset for at begrænse, hvilke kolonner der udløser sletning – det har reddet mig mere end én gang.

Trin 5: Fjern duplikater intelligent

Duplikater er sjældent helt identiske rækker. I praksis handler det oftest om at finde rækker, der repræsenterer den samme entitet (f.eks. samme kunde) men med lidt forskellige data.

# Tjek for duplikerede kunde_id
print(f"Rækker før: {len(raa_data)}")
print(f"Unikke kunder: {raa_data['kunde_id'].nunique()}")

# Behold den nyeste transaktion per kunde
raa_data = raa_data.sort_values("koebsbeloeb", ascending=False)
raa_data = raa_data.drop_duplicates(subset=["kunde_id"], keep="first")

print(f"Rækker efter: {len(raa_data)}")

# Nulstil indeks efter sortering og dedup
raa_data = raa_data.reset_index(drop=True)

Bemærk strategien: vi sorterer efter købsbeløb i faldende rækkefølge før vi fjerner duplikater med keep="first". På den måde beholder vi transaktionen med højest værdi for hver kunde. Du kan selvfølgelig tilpasse sorteringen til dit eget use case – det vigtige er at tænke over, hvilken række du vil beholde.

Trin 6: Validér og konvertér datatyper

Pandas 3.0 genkender automatisk tekstkolonner som str i stedet for object. Det er fedt. Men numeriske kolonner og datoer kræver stadig lidt opmærksomhed.

Konvertér datoer med blandede formater

# pandas kan parse mange formater automatisk
raa_data["dato"] = pd.to_datetime(raa_data["dato"], format="mixed", dayfirst=False)

print(raa_data["dato"].dtype)
print(raa_data["dato"].head())

Parameteren format="mixed" er en livredder, når dine datoer kommer i blandede formater. Pandas forsøger at gætte formatet for hver enkelt værdi. Det er ganske vist langsommere end at specificere ét format, men det virker pålideligt i de fleste tilfælde.

Konvertér numeriske kolonner med fejlhåndtering

# Tvang til numerisk – ugyldige værdier bliver NaN
raa_data["alder"] = pd.to_numeric(raa_data["alder"], errors="coerce")
raa_data["koebsbeloeb"] = pd.to_numeric(raa_data["koebsbeloeb"], errors="coerce")

# Fjern ugyldige aldersværdier
raa_data.loc[~raa_data["alder"].between(0, 120), "alder"] = None
raa_data.loc[raa_data["koebsbeloeb"] < 0, "koebsbeloeb"] = 0

print(raa_data.dtypes)

Ny string-dtype i pandas 3.0

# I pandas 3.0 er string-kolonner automatisk str-dtype
print(f"Type af 'navn': {raa_data['navn'].dtype}")
# Output: str (ikke object som i pandas 2.x)

# Strengoperationer er nu 5-10x hurtigere med PyArrow-backend
print(raa_data["navn"].str.contains("sen").sum())

Den nye string-dtype er nok den mest mærkbare forbedring i daglig brug. Du behøver ikke gøre noget særligt – det virker bare ud af boksen. Og hastigheden? Ja, den taler for sig selv.

Trin 7: Saml det hele i en pipe()-pipeline

Okay, nu kommer den del, der virkelig binder det hele sammen. Med pipe()-metoden kan du kæde alle dine rensningsfunktioner sammen i en læsbar, reproducerbar pipeline. Det er her, det hele giver mening.

Definér modulære rensningsfunktioner

def standardiser_tekst(df):
    """Standardisér alle tekstkolonner."""
    return df.assign(
        navn=pd.col("navn").str.strip().str.title(),
        email=pd.col("email").str.strip().str.lower(),
        kategori=pd.col("kategori").str.strip().str.capitalize()
    )

def haandter_manglende(df):
    """Fyld manglende værdier baseret på kolonnetype."""
    return (
        df
        .dropna(subset=["navn", "email"])
        .fillna({
            "alder": df["alder"].median(),
            "koebsbeloeb": 0,
            "kategori": "Ukendt"
        })
    )

def fjern_duplikater(df):
    """Behold den nyeste post per kunde_id."""
    return (
        df
        .sort_values("koebsbeloeb", ascending=False)
        .drop_duplicates(subset=["kunde_id"], keep="first")
        .reset_index(drop=True)
    )

def valider_vaerdier(df):
    """Fjern eller korriger ugyldige værdier."""
    resultat = df.copy()
    resultat.loc[~resultat["alder"].between(0, 120), "alder"] = None
    resultat.loc[resultat["koebsbeloeb"] < 0, "koebsbeloeb"] = 0
    return resultat

def konverter_typer(df):
    """Konvertér kolonner til korrekte datatyper."""
    return df.assign(
        alder=pd.to_numeric(df["alder"], errors="coerce"),
        koebsbeloeb=pd.to_numeric(df["koebsbeloeb"], errors="coerce"),
        dato=pd.to_datetime(df["dato"], format="mixed", errors="coerce")
    )

def valider_email(df):
    """Fjern rækker med ugyldige e-mailadresser."""
    email_moenster = r"^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+$"
    maske = df["email"].str.match(email_moenster, na=False)
    return df[maske].reset_index(drop=True)

Kør hele pipelinen

# Genindlæs rå data (vi har ændret den undervejs)
# ... (brug koden fra opsætningen ovenfor)

renset_data = (
    raa_data
    .pipe(konverter_typer)
    .pipe(standardiser_tekst)
    .pipe(haandter_manglende)
    .pipe(valider_vaerdier)
    .pipe(valider_email)
    .pipe(fjern_duplikater)
)

print(f"Rækker før rensning: {len(raa_data)}")
print(f"Rækker efter rensning: {len(renset_data)}")
print(f"\nManglende værdier efter rensning:")
print(renset_data.isnull().sum())
print(f"\nDatatyper:")
print(renset_data.dtypes)
print(f"\nDe første 5 rækker:")
print(renset_data.head())

Denne pipeline er let at læse, let at teste og let at genbruge. Hver funktion har ét ansvar. Du kan tilføje, fjerne eller ændre rækkefølgen af trin uden at det hele falder fra hinanden. Det er i grunden det, reproducerbar datarensning handler om.

Bonus: Automatisk datavalidering med Pandera

Så du har renset dine data. Godt. Men hvordan ved du, at de faktisk overholder dine forventninger? Her kommer Pandera ind – et valideringsbibliotek der fungerer som en slags kontraktcheck for dine DataFrames.

pip install pandera

import pandera.pandas as pa

# Definér et skema for det rensede datasæt
kunde_skema = pa.DataFrameSchema({
    "kunde_id": pa.Column(int, pa.Check.gt(0), nullable=False),
    "navn": pa.Column(str, nullable=False),
    "email": pa.Column(str, pa.Check.str_matches(
        r"^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+$"
    ), nullable=False),
    "alder": pa.Column(float, pa.Check.between(0, 120), nullable=True),
    "koebsbeloeb": pa.Column(float, pa.Check.ge(0), nullable=False),
    "kategori": pa.Column(str, nullable=False),
})

# Validér det rensede datasæt
try:
    valideret = kunde_skema.validate(renset_data)
    print("Validering bestået! Dine data er klar til analyse.")
except pa.errors.SchemaError as e:
    print(f"Valideringsfejl: {e}")

Med Pandera kan du integrere datavalidering direkte i din pipeline. Hvis data ikke overholder skemaet, fejler pipelinen tidligt og tydeligt. Det er langt bedre end at opdage problemet halvvejs igennem din analyse (det har vi nok alle prøvet).

Komplet pipeline med validering

Her er den endelige version der kombinerer alt fra guiden. Copy-paste den, tilpas funktionerne til dit datasæt, og du er kørende:

import pandas as pd
import numpy as np
import pandera.pandas as pa

def komplet_rensning(raa_df):
    """Komplet datarensningspipeline til kundedata."""

    # Definér valideringsskema
    skema = pa.DataFrameSchema({
        "kunde_id": pa.Column(int, pa.Check.gt(0)),
        "navn": pa.Column(str, nullable=False),
        "email": pa.Column(str, nullable=False),
        "koebsbeloeb": pa.Column(float, pa.Check.ge(0)),
    })

    # Kør pipeline
    renset = (
        raa_df
        .pipe(konverter_typer)
        .pipe(standardiser_tekst)
        .pipe(haandter_manglende)
        .pipe(valider_vaerdier)
        .pipe(valider_email)
        .pipe(fjern_duplikater)
    )

    # Validér output
    skema.validate(renset)

    return renset

# Brug pipelinen
resultat = komplet_rensning(raa_data)
print(f"Pipeline fuldført: {len(resultat)} rene rækker")

Denne funktion kan du nu kalde i alle dine projekter. Ændr rensningsfunktionerne, tilpas skemaet – strukturen forbliver den samme. Det er investeret tid, der betaler sig igen og igen.

Opsummering

Her er de vigtigste ting, du bør tage med fra denne guide:

• Copy-on-Write er standard i pandas 3.0. Brug .loc i stedet for chained assignment – ingen vej udenom.
• pd.col() erstatter lambda-funktioner i assign() og gør method chaining langt mere læsbart.
• Den nye string-dtype giver hurtigere strengoperationer uden at du skal konfigurere noget.
• pipe() er nøglen til reproducerbare pipelines. Del din logik op i små, fokuserede funktioner og kæd dem sammen.
• Pandera tilføjer automatisk validering der fanger fejl tidligt.
• Inspicér altid dine data før du renser. Forstå problemernes omfang, før du prøver at løse dem.

Datarensning kommer aldrig til at være den mest glamourøse del af dataarbejdet. Men med de rigtige værktøjer og en solid pipeline behøver det heller ikke være den mest smertefulde.

Ofte stillede spørgsmål

Hvad er forskellen mellem dropna() og fillna() i pandas?

dropna() fjerner rækker eller kolonner med manglende værdier helt fra dit datasæt. fillna() erstatter derimod de manglende værdier med noget du vælger – fx gennemsnittet, medianen eller en fast standardværdi. Brug dropna(), når du har rigeligt med data og de manglende rækker ikke er afgørende. Brug fillna(), når du vil bevare så mange datapunkter som muligt.

Hvordan håndterer pandas 3.0 Copy-on-Write anderledes end pandas 2?

I pandas 2.x var Copy-on-Write valgfrit – du aktiverede det med pd.options.mode.copy_on_write = True. I pandas 3.0 er det den eneste tilstand, og du kan ikke slå det fra. Chained assignment (f.eks. df["col"][mask] = value) virker ikke længere, og du skal bruge df.loc[mask, "col"] = value i stedet. Til gengæld slipper du helt for SettingWithCopyWarning.

Kan pd.col() bruges med groupby i pandas 3.0?

Ikke endnu, desværre. I pandas 3.0 kan pd.col() bruges i metoder som assign(), loc[] og __getitem__, men understøttelsen for groupby() og agg() mangler stadig. Det forventes i en fremtidig version. Indtil da skal du bruge lambda-funktioner eller direkte kolonnereferencer i groupby-operationer.

Hvad er den bedste strategi til at fylde manglende værdier i store datasæt?

Det korte svar: det kommer an på datatypen. For numeriske kolonner er medianen ofte det bedste valg, fordi den ikke påvirkes af outliers. For kategoriske kolonner kan du bruge mode (den hyppigste værdi) eller en eksplicit markør som "Ukendt". For tidsseriedata er interpolate() eller ffill() typisk bedre end statiske værdier. Uanset hvad du vælger: dokumentér din strategi, så andre kan forstå og reproducere dine valg.

Hvordan undgår jeg at miste for mange rækker under datarensning?

Tre konkrete tips: 1) Brug altid subset-parameteren i dropna(), så du kun sletter baseret på de vigtigste kolonner. 2) Tjek datasættets størrelse før og efter hvert trin med len(df) – det fanger uventet datatab hurtigt. 3) Overvej fillna() i stedet for dropna() for kolonner der kan have fornuftige standardværdier. En god praksis er at logge antallet af påvirkede rækker i hvert pipelinetrin.