Pandas & NumPy Academy · leksjon

Finne og fjerne duplikater

Finn eksakte og delvise duplikater med duplicated() og drop_duplicates(), og avgjør hvilken duplikatpost som skal beholdes.

Leksjon 1 av 413 trinn

Finne og fjerne duplikater er en gratis leksjon i Pandas & NumPy Academy på CoddyKit. Dette er leksjon 1 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.

Hvorfor duplikater er viktige

Duplikate rader blåser ubemerket opp antall, inntektssummer og gjennomsnitt uten at det vises noen feilmelding. Et salgsdatasett med 500 duplikate ordreposter vil overvurdere inntekten med nøyaktig summen av disse 500 ordrene. Å oppdage og fjerne duplikater er et av de første trinnene i datarensingen, før aggregering eller modellering, fordi feilene nedstrøms forsterkes fra denne ene korrupsjonskilden.

import pandas as pd

df = pd.read_csv('orders.csv')
print('Shape before dedup:', df.shape)
print('Exact duplicates:', df.duplicated().sum())

Finne eksakte duplikater

df.duplicated() returnerer en boolsk serie der verdien er True for hver rad som er en nøyaktig kopi av en tidligere rad. Standardverdien keep='first' markerer alle forekomster unntatt den første. Hvis De sender inn keep=False, markeres alle forekomster av et duplikat – nyttig når De vil undersøke alle kopiene av en duplisert post før De bestemmer hvilken som skal beholdes.

# Mark only the second+ occurrences
partial_dups = df[df.duplicated(keep='first')]
print('Rows to remove:', len(partial_dups))

# Mark ALL copies of any duplicate
all_dups = df[df.duplicated(keep=False)]
print('Rows involved in duplicates:', len(all_dups))

Fjerne eksakte duplikater

Fjern eksakte duplikatrader med df.drop_duplicates(). Som standard beholdes den første forekomsten, mens alle andre fjernes. Send inn keep='last' for å beholde den nyeste posten hvis dataene har et tidsstempel og senere rader anses som mer pålitelige. Kontroller alltid radantallet før og etter for å bekrefte at forventet antall rader ble fjernet.

df_clean = df.drop_duplicates(keep='first')

print('Rows removed:', len(df) - len(df_clean))
print('Shape after dedup:', df_clean.shape)

Delvise duplikater: nøkkelbaserte

Rader kan være delvise duplikater: De deler en forretningsnøkkel (for eksempel order_id), men skiller seg i andre kolonner på grunn av en feil oppstrøms som opprettet to versjoner av samme post. Bruk df.duplicated(subset=['order_id']) for å finne rader med samme nøkkel, men potensielt ulike verdier i andre kolonner. Undersøk disse radene før De avgjør hvordan de skal avstemmes.

key_dups = df[df.duplicated(subset=['order_id'], keep=False)]
print('Orders with duplicate IDs:')
print(key_dups.sort_values('order_id').head(10))

Velge hvilket duplikat som skal beholdes

Når det finnes delvise duplikater, må De avgjøre hvilken post som er den autoritative. Vanlige strategier er å beholde raden med nyeste tidsstempel (seneste oppdatering), raden med flest ikke-null-verdier eller raden med høyest beløp hvis én post inneholder korrigeringer. Sorter etter kriteriet som skal avgjøre valget, og fjern deretter duplikatene ved å beholde den første (eller siste) forekomsten.

# Keep the record with the latest update timestamp
df_sorted = df.sort_values('updated_at', ascending=False)
df_dedup = df_sorted.drop_duplicates(subset=['order_id'], keep='first')

print('Kept:', len(df_dedup), 'unique orders')

Oppdage nesten-duplikater

Nesten-duplikater er rader som representerer samme entitet, men som skiller seg litt fra hverandre – for eksempel samme kundenavn med en skrivefeil eller samme transaksjon med en avrundingsforskjell på 1 cent. Oppdagelse av eksakte duplikater finner ikke disse. Én fremgangsmåte er å gruppere etter nøkkelkolonnen og telle: Hvis et kundenavn forekommer med små variasjoner, kan De bruke .str.strip().str.lower() til å normalisere det før deduplisering.

df['customer_normalized'] = df['customer_name'].str.strip().str.lower()

near_dups = df.groupby('customer_normalized').size().sort_values(ascending=False)
print(near_dups[near_dups > 1].head())

Deduplisering med GroupBy-aggregering

Når De må slå sammen duplikatrader i stedet for bare å fjerne dem, kan De bruke groupby().agg(). Hvis to rader for eksempel representerer samme ordre, men den ene har leveringsadressen og den andre fakturaadressen, kan De aggregere med 'first' (ikke-null-verdier foretrekkes) eller en egendefinert funksjon som kombinerer ikke-null-verdier på tvers av duplikatene.

def coalesce(*args):
    for a in args:
        if pd.notna(a):
            return a
    return None

df_merged = df.groupby('order_id').agg(
    customer=('customer_name', 'first'),
    amount=('amount', 'max'),
    date=('order_date', 'min')
).reset_index()
print(df_merged.head())

Kontrollere følsomhet for radrekkefølge

Resultatet av drop_duplicates(keep='first') avhenger av radrekkefølgen. Hvis DataFrame-et ble lastet inn fra en databaseforespørsel uten en ORDER BY-klausul, er radrekkefølgen ikke-deterministisk. Det betyr at posten som beholdes, kan variere mellom kjøringer. Sorter alltid etter en stabil nøkkel (for eksempel primærnøkkel eller tidsstempel) før deduplisering, slik at prosessen blir deterministisk og reproduserbar.

# Sort by primary key before deduplication for deterministic results
df = df.sort_values('order_id').reset_index(drop=True)
df_clean = df.drop_duplicates(subset=['order_id'], keep='first')

print('Deterministic dedup complete.')

Verifisere resultatet av dedupliseringen

Etter deduplisering bør De verifisere resultatet med tre kontroller: ingen gjenværende eksakte duplikater (df_clean.duplicated().sum() == 0), ingen dupliserte forretningsnøkler (df_clean.duplicated(subset=['order_id']).sum() == 0) og et forventet radantall som virker rimelig. Skriv disse som assertions, slik at de feiler tydelig hvis fremtidige dataendringer gjør rense-logikken ugyldig.

assert df_clean.duplicated().sum() == 0, 'Exact duplicates remain'
assert df_clean.duplicated(subset=['order_id']).sum() == 0, 'Duplicate order IDs remain'
print('Deduplication verified. Rows:', len(df_clean))

Dokumentere fjernede duplikater

God datarensing er reproduserbar og etterprøvbar. Logg antallet rader som ble fjernet, dedupliseringsnøkkelen og regelen som avgjorde valget, i en ordbok for rense-rapporten. Lagre denne rapporten sammen med den rensede datafilen, slik at alle som kjører pipelinen senere, kan kontrollere rensevalgene uten å lese koden på nytt. Åpenhet i datarensingen skaper tillit til analyseresultatene.

cleaning_log = {
    'original_rows': len(df),
    'dedup_key': 'order_id',
    'tiebreak': 'keep first by updated_at desc',
    'rows_removed': len(df) - len(df_clean),
    'clean_rows': len(df_clean)
}
for k, v in cleaning_log.items():
    print(f'{k}: {v}')

Lagre det dedupliserte datasettet

Lagre den dedupliserte DataFrame-en i en ny fil i stedet for å overskrive originalen. Da bevarer De rådataene for revisjon. Gi filen et tydelig navn med suffikset _clean eller _deduped, og ta med kjøringsdatoen slik at flere rensekjøringer kan identifiseres. Bruk Parquet for rask innlasting i senere trinn i pipelinen.

from datetime import date

output_path = f'orders_clean_{date.today()}.parquet'
df_clean.to_parquet(output_path, index=False)
print(f'Saved {len(df_clean)} rows to {output_path}')

Hurtigsjekk

Test forståelsen Deres av Data Analysis-konsepter fra denne leksjonen.

Oppsummering av leksjonen

I denne leksjonen har De lært: å oppdage eksakte og delvise duplikater med duplicated() og drop_duplicates(), å velge hvilket duplikat som skal beholdes ved hjelp av sorterings- og aggregeringsstrategier og å verifisere resultater med assertions og loggføre rensevalgene. Deretter skal vi se på teknikker for å oppdage og behandle uteliggere.

Gratis å komme i gang

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 «Finne og fjerne duplikater» gratis?

Ja – hele teksten i «Finne og fjerne duplikater» 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 «Finne og fjerne duplikater»?

Finn eksakte og delvise duplikater med duplicated() og drop_duplicates(), og avgjør hvilken duplikatpost som skal beholdes. 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 1 av 4.

Hvor lang tid tar leksjonen «Finne og fjerne duplikater»?

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

  1. Finne og fjerne duplikater
  2. Finne og håndtere uteliggere
  3. Standardisere inkonsekvente kategorier
  4. Skjemavalidering og assertions
← Tilbake til Pandas & NumPy Academy