Čištění dat v Pandas 3.0: Průvodce (2026)

Proč je čištění dat tak důležité

Datový vědci se vesměs shodují na jedné nepříjemné věci — čištění dat spolehlivě zabere zhruba 80 % času stráveného na jakémkoliv datovém projektu. Zbývajících 20 % pak připadá na samotnou analýzu, modelování a vizualizaci. Zní to frustrující? Jo, je to frustrující. Ale je to realita. Špinavá data vedou ke špatným výsledkům — garbage in, garbage out, jak se říká.

Pokud pracujete s reálnými daty (a kdo ne?), setkáváte se s chybějícími hodnotami, duplicitami, nekonzistentními formáty, překlepy a odlehlými hodnotami prakticky pokaždé. Není to výjimka — je to standard. A právě knihovna Pandas je v Pythonu tím hlavním nástrojem, kterým tyto problémy řešíte.

V tomto průvodci si projdeme celý proces čištění dat od začátku do konce. Použijeme aktuální verzi Pandas 3.0 (leden 2026) a ukážeme si funkční příklady kódu, které můžete rovnou použít ve svých projektech. Žádná zbytečná teorie navíc — jen praktické techniky, které opravdu potřebujete znát.

Příprava prostředí a instalace

Než začneme, ujistěte se, že máte nainstalovanou aktuální verzi Pandas. Verze 3.0 přinesla několik důležitých změn, které ovlivňují i práci s čištěním dat — především režim Copy-on-Write jako výchozí nastavení a změny v chování metody fillna(). O těch se pobavíme později.

# Instalace nebo aktualizace
pip install pandas --upgrade

# Ověření verze
import pandas as pd
import numpy as np

print(pd.__version__)  # 3.0.x

Pro příklady v tomto článku si vytvoříme ukázkový dataset, který simuluje typická „špinavá" data z reálného světa. Věřte mi, tohle není nic přehnaného — v praxi bývá situace ještě horší.

import pandas as pd
import numpy as np

# Simulace reálných špinavých dat
data = {
    "jmeno": ["Jan Novák", "  Marie Svobodová ", "jan novák", "Petr Dvořák",
              "Marie Svobodová", "Anna ČERNÁ", None, "Tomáš Procházka",
              "petr dvorak", "Jana Králová"],
    "vek": [28, 35, 28, None, 35, 42, 31, "dvacet pět", 45, 29],
    "email": ["[email protected]", "[email protected]", "[email protected]",
              "petr@email", "[email protected]", "[email protected]",
              "[email protected]", "[email protected]", "[email protected]",
              "[email protected]"],
    "plat": [45000, 52000, 45000, 61000, 52000, None, 38000,
             55000, 62000, 41000],
    "mesto": ["Praha", "brno", "Praha", "Ostrava", "Brno",
              "Praha", "plzeň", "Liberec", "ostrava", "Praha"],
    "datum_nastupu": ["2023-01-15", "2022-06-01", "2023-01-15",
                      "15.3.2024", "2022-06-01", "2021/12/10",
                      "2024-03-20", "1.1.2023", "2024-06-15",
                      "2025-02-01"]
}

df = pd.DataFrame(data)
print(df)

Tento dataset obsahuje prakticky všechny typické problémy, se kterými se v praxi setkáte — chybějící hodnoty, duplicity, nekonzistentní formáty, překlepy a špatné datové typy. Hezky pohromadě na jednom místě.

Krok 1: První průzkum dat

Než se pustíte do čištění, potřebujete pochopit, s čím vlastně pracujete. Pandas nabízí několik metod, které vám dají rychlý přehled o stavu vašich dat.

# Základní informace o datasetu
print(df.info())

# Statistický souhrn
print(df.describe())

# Prvních pár řádků
print(df.head())

# Rozměry datasetu
print(f"Řádků: {df.shape[0]}, Sloupců: {df.shape[1]}")

# Počet chybějících hodnot v každém sloupci
print(df.isnull().sum())

# Procentuální zastoupení chybějících hodnot
print((df.isnull().sum() / len(df) * 100).round(1))

Metoda info() je vaše první zastávka — vždy. Ukáže vám datové typy jednotlivých sloupců, počet nenulových hodnot a paměťovou náročnost. Pokud vidíte sloupec vek jako object místo int64, hned víte, že tam něco nesedí. Tohle jednoduché zjištění vám může ušetřit hodiny ladění.

Na co se zaměřit při průzkumu

Datové typy — odpovídají tomu, co byste čekali? Čísla uložená jako text jsou častý problém.
Chybějící hodnoty — kolik jich je a v kterých sloupcích? Je vzorec náhodný, nebo systematický?
Unikátní hodnoty — df["mesto"].unique() vám ukáže, jestli máte „Brno" a „brno" jako dva různé záznamy.
Statistický souhrn — jsou minima a maxima rozumná? Věk 250 let signalizuje problém.

Krok 2: Řešení chybějících hodnot

Chybějící hodnoty (NaN, None) jsou nejčastějším problémem v reálných datech. Pandas je reprezentuje jako NaN (Not a Number) a nabízí několik způsobů, jak s nimi naložit. Který způsob zvolit záleží na situaci — a tady se začínají lišit junioři od seniorů.

Detekce chybějících hodnot

# Kde přesně chybí data?
print(df.isnull())

# Souhrn po sloupcích
print(df.isnull().sum())

# Řádky, které mají alespoň jednu chybějící hodnotu
print(df[df.isnull().any(axis=1)])

Strategie 1: Odstranění řádků s chybějícími hodnotami

Nejjednodušší přístup — ale ne vždy nejlepší. Pokud máte málo dat, ztráta každého řádku je bolestivá.

# Odstranit řádky, kde chybí jakákoliv hodnota
df_cisteny = df.dropna()

# Odstranit řádky, kde chybí hodnota v konkrétním sloupci
df_cisteny = df.dropna(subset=["plat"])

# Odstranit řádky, kde chybí více než 2 hodnoty
df_cisteny = df.dropna(thresh=df.shape[1] - 2)

Kdy dropna() používat? Když je procento chybějících hodnot nízké (pod 5 %) a chybění je náhodné. Pokud chybí data systematicky (například všem ženám chybí plat), jejich odstranění by zkreslilo vaši analýzu. To je pak problém, který vás může pronásledovat i po týdnech.

Strategie 2: Doplnění chybějících hodnot

Metoda fillna() je vaším hlavním nástrojem pro náhradu chybějících hodnot. V Pandas 3.0 přibyla podpora pro value=None u ne-objektových typů a metoda s parametrem inplace=True nově vrací self místo None.

# Doplnit konstantní hodnotou
df["plat"] = df["plat"].fillna(0)

# Doplnit průměrem
df["plat"] = df["plat"].fillna(df["plat"].mean())

# Doplnit mediánem — robustnější vůči odlehlým hodnotám
df["plat"] = df["plat"].fillna(df["plat"].median())

# Doplnit nejčastější hodnotou (modus) — vhodné pro kategorické sloupce
df["mesto"] = df["mesto"].fillna(df["mesto"].mode()[0])

# Dopředné vyplnění — použije předchozí platnou hodnotu
df["plat"] = df["plat"].ffill()

# Zpětné vyplnění — použije následující platnou hodnotu
df["plat"] = df["plat"].bfill()

# Interpolace — výpočet hodnoty na základě okolních bodů
df["plat"] = df["plat"].interpolate(method="linear")

Jak vybrat správnou strategii

Průměr/medián — pro numerické sloupce, kde chybění je náhodné. Medián je lepší volba, pokud máte odlehlé hodnoty.
Modus — pro kategorické sloupce (město, pohlaví, kategorie).
Dopředné/zpětné vyplnění — pro časové řady, kde má smysl použít předchozí nebo následující hodnotu.
Interpolace — pro spojitá data, kde chcete odhadnout hodnotu na základě trendu.
Odstranění — když chybí příliš mnoho dat v řádku a doplnění by bylo zavádějící.

Důležité pravidlo: pokud připravujete data pro strojové učení, statistiky pro doplnění (průměr, medián) počítejte pouze z trénovací sady. Jinak dochází k úniku informací z testovací sady. To je jedna z těch chyb, které se dělají dost tiše — žádná chybová hláška, jen zkreslené výsledky.

Krok 3: Odstranění duplicitních záznamů

Duplicity zkreslují analýzu a můžou způsobit vážné problémy, pokud je přehlédnete. V našem ukázkovém datasetu máme třeba dva záznamy pro „Jan Novák" a dva pro „Marie Svobodová".

# Detekce duplicit — vrátí booleovskou masku
print(df.duplicated())

# Počet duplicitních řádků
print(f"Počet duplicit: {df.duplicated().sum()}")

# Zobrazit duplicitní řádky
print(df[df.duplicated(keep=False)])

# Detekce na základě konkrétních sloupců
print(df.duplicated(subset=["jmeno", "email"]))

Odstranění duplicit

# Odstranit duplicitní řádky — ponechá první výskyt
df_bez_duplicit = df.drop_duplicates()

# Ponechat poslední výskyt
df_bez_duplicit = df.drop_duplicates(keep="last")

# Na základě konkrétních sloupců
df_bez_duplicit = df.drop_duplicates(subset=["email"], keep="first")

# Odstranit všechny výskyty duplicit (i originál)
df_bez_duplicit = df.drop_duplicates(keep=False)

print(f"Před: {len(df)} řádků, Po: {len(df_bez_duplicit)} řádků")

Pozor na jednu věc — duplicity na základě jmen můžou být ošidné. „Jan Novák" a „jan novák" jsou pro Pandas dva různé záznamy. Proto je důležité nejdřív sjednotit formát textu a teprve pak hledat duplicity. Tohle pořadí kroků si zapamatujte, ušetří vám to nejedno překvapení.

Krok 4: Oprava datových typů

Špatné datové typy jsou tichý zabiják — váš kód běží bez chyby, ale výsledky jsou nesmyslné. Typický příklad: sloupec vek uložený jako text, protože někdo zapsal „dvacet pět" místo čísla. Stává se to víc, než by člověk čekal.

# Zjistit aktuální datové typy
print(df.dtypes)

# Převod na číslo — chyby nahradí NaN
df["vek"] = pd.to_numeric(df["vek"], errors="coerce")

# Převod na celé číslo (s podporou NaN v Pandas 3.0)
df["vek"] = df["vek"].astype("Int64")

# Převod sloupce plat na float
df["plat"] = pd.to_numeric(df["plat"], errors="coerce")

Práce s datumy

Datumy bývají jeden z nejproblematičtějších datových typů. V našem datasetu máme tři různé formáty: „2023-01-15", „15.3.2024" a „2021/12/10". Klasika.

# Automatická detekce formátu
df["datum_nastupu"] = pd.to_datetime(df["datum_nastupu"], dayfirst=True)

# Pokud automatická detekce selže, zadejte formát explicitně
# df["datum"] = pd.to_datetime(df["datum"], format="%d.%m.%Y")

# Kontrola výsledku
print(df["datum_nastupu"].dtype)  # datetime64[ns]
print(df["datum_nastupu"])

# Extrakce užitečných informací z data
df["rok_nastupu"] = df["datum_nastupu"].dt.year
df["mesic_nastupu"] = df["datum_nastupu"].dt.month

Parametr dayfirst=True říká Pandas, že v nejednoznačných formátech (jako „01/03/2024") je první číslo den, ne měsíc. Pro česká data je to obvykle správné nastavení — bez toho dostanete na první pohled platná data, která ale nesedí.

Krok 5: Čištění textových dat

Textová data jsou ze všech typů nejnáchylnější k nekonzistencím. Přebytečné mezery, různá velikost písmen, překlepy — to všechno musíte řešit. A taky to musíte řešit jako první, před vším ostatním.

Základní textové operace

# Odstranění mezer na začátku a konci
df["jmeno"] = df["jmeno"].str.strip()

# Sjednocení velikosti písmen — každé slovo s velkým počátečním písmenem
df["jmeno"] = df["jmeno"].str.title()

# Sjednocení měst — první písmeno velké
df["mesto"] = df["mesto"].str.strip().str.title()

# Převod na malá písmena (vhodné pro emaily)
df["email"] = df["email"].str.lower().str.strip()

print(df[["jmeno", "mesto", "email"]])

Čištění pomocí regulárních výrazů

Pro složitější čištění textu se neobejdete bez regulárních výrazů (regex). Pandas je podporuje přímo přes přístupový objekt .str — a upřímně, jakmile si na to zvyknete, těžko si představíte, jak jste bez toho dřív vůbec pracovali.

# Odstranění speciálních znaků z textu
df["jmeno"] = df["jmeno"].str.replace(r"[^a-zA-ZáčďéěíňóřšťúůýžÁČĎÉĚÍŇÓŘŠŤÚŮÝŽ\s]", "", regex=True)

# Validace emailových adres
email_pattern = r"^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$"
df["email_validni"] = df["email"].str.match(email_pattern)
print(df[~df["email_validni"]][["jmeno", "email"]])

# Extrakce domény z emailu
df["email_domena"] = df["email"].str.extract(r"@(.+)$")

# Nahrazení více mezer jednou mezerou
df["jmeno"] = df["jmeno"].str.replace(r"\s+", " ", regex=True)

Mapování a nahrazování hodnot

# Sjednocení nekonzistentních hodnot pomocí slovníku
mapovani_mest = {
    "Praha": "Praha",
    "Brno": "Brno",
    "Ostrava": "Ostrava",
    "Plzeň": "Plzeň",
    "Liberec": "Liberec"
}
df["mesto"] = df["mesto"].map(mapovani_mest).fillna(df["mesto"])

# Nahrazení konkrétních hodnot
df["mesto"] = df["mesto"].replace({
    "Prha": "Praha",
    "Brünn": "Brno"
})

Krok 6: Detekce a řešení odlehlých hodnot

Odlehlé hodnoty (outliers) jsou datové body, které se výrazně liší od zbytku datasetu. Můžou být legitimní (CEO s platem 500 000 Kč) nebo chybné (věk 350 let). Klíčové je umět je najít a pak se trochu zamyslet — ne jen slepě mazat.

Metoda IQR (mezikvartilové rozpětí)

# Výpočet IQR pro sloupec plat
Q1 = df["plat"].quantile(0.25)
Q3 = df["plat"].quantile(0.75)
IQR = Q3 - Q1

dolni_hranice = Q1 - 1.5 * IQR
horni_hranice = Q3 + 1.5 * IQR

print(f"Dolní hranice: {dolni_hranice}")
print(f"Horní hranice: {horni_hranice}")

# Identifikace odlehlých hodnot
outliers = df[(df["plat"] < dolni_hranice) | (df["plat"] > horni_hranice)]
print(f"Počet odlehlých hodnot: {len(outliers)}")

# Omezení hodnot na hranice (capping)
df["plat_ocisteny"] = df["plat"].clip(lower=dolni_hranice, upper=horni_hranice)

Metoda Z-skóre

# Z-skóre — kolik směrodatných odchylek od průměru
df["plat_zscore"] = (df["plat"] - df["plat"].mean()) / df["plat"].std()

# Hodnoty s |Z| > 3 jsou obvykle považovány za odlehlé
outliers_z = df[df["plat_zscore"].abs() > 3]
print(f"Odlehlé hodnoty (Z-skóre): {len(outliers_z)}")

Důležitá poznámka: neodstraňujte odlehlé hodnoty automaticky. Vždy se zamyslete, jestli daná hodnota dává smysl v kontextu vašich dat. Plat 200 000 Kč měsíčně může být legitimní hodnota pro manažera, ale věk 350 let legitimní rozhodně není. Kontext je všechno.

Krok 7: Standardizace formátů

Konzistentní formáty dat jsou základem pro spolehlivou analýzu. Tady je kompletní ukázka standardizace různých typů dat — telefonní čísla a PSČ jsou v českém prostředí klasický problém.

# Standardizace telefonních čísel
def standardizuj_telefon(tel):
    if pd.isna(tel):
        return tel
    # Odstranit vše kromě číslic a znaku +
    import re
    tel = re.sub(r"[^\d+]", "", str(tel))
    # Přidat předvolbu, pokud chybí
    if tel.startswith("00420"):
        tel = "+" + tel[2:]
    elif not tel.startswith("+"):
        tel = "+420" + tel
    return tel

# Příklad použití
telefony = pd.Series(["+420 777 123 456", "00420777123456",
                       "777-123-456", "777 123 456"])
telefony_std = telefony.apply(standardizuj_telefon)
print(telefony_std)

# Standardizace PSČ
def standardizuj_psc(psc):
    if pd.isna(psc):
        return psc
    import re
    psc = re.sub(r"\s+", "", str(psc))
    if len(psc) == 5 and psc.isdigit():
        return f"{psc[:3]} {psc[3:]}"
    return psc

psc_data = pd.Series(["11000", "110 00", "602 00", "60200"])
print(psc_data.apply(standardizuj_psc))

Krok 8: Sestavení čisticí pipeline

V praxi nechcete čisticí kroky spouštět ručně jeden po druhém. Mnohem lepší je sestavit si znovupoužitelnou pipeline — funkci, která celý proces automatizuje a vy ji pak jen voláte. Jednou napsat, stokrát použít.

import pandas as pd
import numpy as np
import re

def cistici_pipeline(df: pd.DataFrame) -> pd.DataFrame:
    """Kompletní čisticí pipeline pro zaměstnanecký dataset."""
    df = df.copy()

    # 1. Základní textové čištění
    textove_sloupce = df.select_dtypes(include=["object"]).columns
    for sloupec in textove_sloupce:
        df[sloupec] = df[sloupec].str.strip()

    # 2. Sjednocení jmen
    if "jmeno" in df.columns:
        df["jmeno"] = df["jmeno"].str.title()
        df["jmeno"] = df["jmeno"].str.replace(r"\s+", " ", regex=True)

    # 3. Sjednocení měst
    if "mesto" in df.columns:
        df["mesto"] = df["mesto"].str.title()

    # 4. Oprava datových typů
    if "vek" in df.columns:
        df["vek"] = pd.to_numeric(df["vek"], errors="coerce")
        df["vek"] = df["vek"].astype("Int64")

    if "plat" in df.columns:
        df["plat"] = pd.to_numeric(df["plat"], errors="coerce")

    if "datum_nastupu" in df.columns:
        df["datum_nastupu"] = pd.to_datetime(
            df["datum_nastupu"], dayfirst=True, errors="coerce"
        )

    # 5. Odstranění duplicit
    df = df.drop_duplicates(subset=["jmeno", "email"], keep="first")

    # 6. Doplnění chybějících hodnot
    if "plat" in df.columns:
        df["plat"] = df["plat"].fillna(df["plat"].median())
    if "vek" in df.columns:
        df["vek"] = df["vek"].fillna(df["vek"].median())

    # 7. Odstranění řádků bez klíčových údajů
    df = df.dropna(subset=["jmeno"])

    # 8. Reset indexu
    df = df.reset_index(drop=True)

    return df

# Použití pipeline
df_cisty = cistici_pipeline(df)
print(f"Před čištěním: {len(df)} řádků")
print(f"Po čištění: {len(df_cisty)} řádků")
print(df_cisty)

Výhody tohoto přístupu jsou zřejmé — pipeline je přehledná, testovatelná a snadno rozšiřitelná. Když dostanete novou dávku dat (a dostanete ji, to je jisté), jednoduše ji proženete stejnou funkcí a máte jistotu konzistentního výsledku.

Validace po čištění

Po každém čištění si ověřte, že jste data nepoškodili. Tento krok se lehce přeskakuje, když je člověk v časovém tlaku — ale pak to mrzí.

def validuj_dataset(df: pd.DataFrame) -> None:
    """Základní validace vyčištěného datasetu."""
    print("=== Validace datasetu ===")
    print(f"Počet řádků: {len(df)}")
    print(f"Chybějící hodnoty:\n{df.isnull().sum()}")
    print(f"Duplicitní řádky: {df.duplicated().sum()}")
    print(f"Datové typy:\n{df.dtypes}")

    # Kontrola rozsahů
    if "vek" in df.columns:
        vek_min = df["vek"].min()
        vek_max = df["vek"].max()
        print(f"Rozsah věku: {vek_min} - {vek_max}")
        if vek_max > 120 or vek_min < 0:
            print("VAROVÁNÍ: Neobvyklé hodnoty věku!")

    if "plat" in df.columns:
        plat_min = df["plat"].min()
        print(f"Minimální plat: {plat_min}")
        if plat_min < 0:
            print("VAROVÁNÍ: Záporné hodnoty platu!")

validuj_dataset(df_cisty)

Novinky v Pandas 3.0 pro čištění dat

Pandas 3.0, vydaný v lednu 2026, přinesl několik změn, které přímo ovlivňují práci s čištěním dat. Pojďme si projít ty nejdůležitější.

Copy-on-Write je nyní výchozí

Největší změnou je aktivace režimu Copy-on-Write (CoW) jako výchozího chování. To znamená, že operace jako df2 = df[["sloupec"]] už nevytvářejí pohled (view) na původní data, ale línou kopii. K reálnému kopírování dochází až při pokusu o modifikaci.

# V Pandas 3.0 — toto je bezpečné, žádné nechtěné vedlejší efekty
df_vyber = df[["jmeno", "plat"]]
df_vyber["plat"] = df_vyber["plat"] * 1.1  # Nezmění původní df

# Pokud chcete explicitní kopii, použijte:
df_kopie = df.copy()

Pro čištění dat je to velká výhoda — nemusíte se bát, že operací na výřezu nechtěně modifikujete původní DataFrame. A slavné varování SettingWithCopyWarning, které dokázalo pěkně zamotávat hlavu, je definitivně minulostí.

Změny v metodě fillna()

Metoda fillna() v Pandas 3.0 nově akceptuje value=None pro ne-objektové typy. Navíc s parametrem inplace=True vrací self místo None, což umožňuje řetězení metod i při in-place operacích.

# Nové v Pandas 3.0 — fillna s value=None
# Pro ne-objektové typy se použije odpovídající NA hodnota
df["vek"] = df["vek"].fillna(value=None)  # Použije pd.NA pro Int64

# fillna s inplace=True nově vrací self
vysledek = df["plat"].fillna(0, inplace=True)
# vysledek nyní obsahuje Series, ne None

Časté chyby při čištění dat

I zkušení datoví analytici dělají při čištění dat chyby. Tady jsou ty nejčastější — a jak se jim vyhnout.

Modifikace původních dat — Vždy pracujte s kopií. Začněte každou čisticí funkci řádkem df = df.copy(). V Pandas 3.0 je to díky Copy-on-Write méně kritické, ale stále je to dobrý zvyk, který se vyplatí udržovat.
Doplnění hodnot před rozdělením na trénink/test — Pokud počítáte průměr pro fillna z celého datasetu včetně testovací sady, dochází k úniku dat. Vždy rozdělte data první.
Ignorování kontextu — Chybějící hodnota v sloupci „počet dětí" pravděpodobně znamená 0, ne že údaj chybí. Přemýšlejte o doménové logice.
Příliš agresivní odstranění odlehlých hodnot — Než hodnotu odstraníte, ověřte, jestli není legitimní. Průměrný plat v IT oddělení může být výrazně vyšší než firemní průměr — to není chyba.
Zapomenutí na dokumentaci — Zaznamenejte si, kolik řádků a hodnot jste odstranili nebo modifikovali. Při prezentaci výsledků budete potřebovat vědět, jak se data změnila. Bez toho na vás na prvním review kolegové budou koukat nevěřícně.

Často kladené otázky

Jaký je rozdíl mezi dropna() a fillna() v Pandas?

Metoda dropna() odstraňuje řádky nebo sloupce, které obsahují chybějící hodnoty. Metoda fillna() naopak chybějící hodnoty nahrazuje zadanou hodnotou — průměrem, mediánem, konstantou nebo předchozí/následující hodnotou. Volba závisí na množství chybějících dat a jejich významu. Pokud chybí méně než 5 % dat a chybění je náhodné, dropna() je bezpečná volba. Pro větší procento chybějících hodnot je obvykle lepší fillna().

Jak v Pandas najít a odstranit duplicitní řádky?

Pro detekci duplicit použijte metodu df.duplicated(), která vrátí booleovskou masku. Pro odstranění slouží df.drop_duplicates(). Parametr subset umožňuje kontrolovat duplicity pouze na základě vybraných sloupců a parametr keep určuje, který výskyt ponechat ("first", "last" nebo False pro odstranění všech). Před hledáním duplicit vždy nejdříve sjednoťte formát textu (velikost písmen, mezery).

Jak převést sloupec na správný datový typ v Pandas?

Pro převod na číslo použijte pd.to_numeric(sloupec, errors="coerce"), kde parametr errors="coerce" nahradí nepřeveditelné hodnoty hodnotou NaN. Pro datum slouží pd.to_datetime() s parametrem dayfirst=True pro české formáty. Obecný převod typu zajistí metoda astype() — například df["sloupec"].astype("Int64") pro celá čísla s podporou chybějících hodnot.

Jak automatizovat čištění dat v Pythonu?

Vytvořte si čisticí funkci (pipeline), která přijímá DataFrame a vrací vyčištěný DataFrame. Do funkce postupně přidejte jednotlivé kroky: textové čištění, opravu typů, odstranění duplicit, doplnění chybějících hodnot a validaci. Tuto funkci pak jednoduše voláte na každou novou dávku dat. Pro složitější scénáře zvažte knihovnu scikit-learn a její třídu Pipeline, která umožňuje řetězení transformací.

Co se změnilo v čištění dat s Pandas 3.0?

Pandas 3.0 (leden 2026) přinesl tři hlavní změny pro čištění dat. Zaprvé, režim Copy-on-Write je nyní výchozí — nemusíte se bát nechtěných vedlejších efektů při práci s výřezy DataFramu. Zadruhé, fillna() s parametrem inplace=True nově vrací self místo None, což umožňuje řetězení. Zatřetí, byl opraven bug v groupby().dropna() pro kategorická data.