Pandas & NumPy Academy · Lektion

Kombination og oprydning i tekstkolonner

Sammenkæd flere kolonner til én streng, fjern overflødige mellemrum, og standardisér inkonsistente kategorietiketter.

Lektion 4 af 413 trin

Kombination og oprydning i tekstkolonner er en gratis Pandas & NumPy Academy-lektion på CoddyKit. Dette er lektion 4 af 4. Du kan læse hele lektionen gratis nedenfor — og derefter øve dig praktisk i browseren med en indbygget kodeeditor og en AI-vejleder, der er tilgængelig døgnet rundt. Den er en del af læringsforløbet i Pandas & NumPy Academy, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. Pandas & NumPy Academy-kurset indeholder 4 lektioner i alt.

Sammenkædning af tekstkolonner

En almindelig opgave i dataforberedelse er at oprette en enkelt streng ved at kombinere værdier fra flere kolonner — f.eks. at oprette et fuldt navn ud fra fornavn og efternavn eller en adresse ud fra vej, by og land. I Pandas sammenkæder du strengkolonner ved hjælp af operatoren + på to Series (eller en Series og en strengliteral), efter at du har konverteret numeriske kolonner til strenge med .astype(str).

import pandas as pd

df = pd.DataFrame({
    'first_name': ['Alice', 'Bob', 'Carol'],
    'last_name': ['Smith', 'Jones', 'White']
})

df['full_name'] = df['first_name'] + ' ' + df['last_name']
print(df['full_name'].tolist())
# ['Alice Smith', 'Bob Jones', 'Carol White']

Sammenkædning med kolonner, der ikke indeholder strenge

Når du kombinerer en numerisk kolonne med en strengkolonne, skal du først konvertere den numeriske kolonne til en streng ved hjælp af .astype(str). Pythons +-operator udløser en TypeError, hvis du forsøger at lægge en Series med strenge sammen med en Series med heltal. Det er en almindelig kilde til forvirring, når du opbygger sammensatte nøgler eller etiketter ud fra kolonner med blandede typer.

import pandas as pd

df = pd.DataFrame({
    'product': ['Widget', 'Gadget'],
    'version': [3, 5]
})

# Must convert int to str before concatenating
df['label'] = df['product'] + ' v' + df['version'].astype(str)
print(df['label'].tolist())
# ['Widget v3', 'Gadget v5']

.str.cat() til sammenkædning med separator

Series.str.cat(others, sep=) er Pandas' egen måde at sammenkæde flere Series med en separator på, samtidig med at NaN-værdier håndteres på en hensigtsmæssig måde. Som standard medfører en NaN-værdi i en kolonne, at resultatet for den pågældende række bliver NaN. Angiv na_rep='?' (eller en hvilken som helst tekst) for at erstatte NaN med en pladsholder i stedet for at lade værdien brede sig.

import pandas as pd
import numpy as np

df = pd.DataFrame({
    'city': ['NYC', 'LA', None],
    'state': ['NY', None, 'TX'],
    'country': ['USA', 'USA', 'USA']
})

# Join with ', ' — NaN rows produce NaN by default
df['location'] = df['city'].str.cat(
    [df['state'], df['country']],
    sep=', ',
    na_rep='N/A'
)
print(df['location'].tolist())
# ['NYC, NY, USA', 'LA, N/A, USA', 'N/A, TX, USA']

Normalisering af inkonsistente kategorietiketter

Kategorikolonner fra virkelige datasæt har ofte inkonsistente etiketter på grund af slåfejl, forskelle i store og små bogstaver eller forskellige forkortelser (f.eks. 'US', 'USA', 'United States'). Den almindelige løsning er at oprette en ordbog med afbildninger, der afbilder hver variant til den kanoniske form, og derefter anvende den med .map() eller .replace().

import pandas as pd

df = pd.DataFrame({
    'country': ['US', 'USA', 'United States', 'uk', 'UK', 'United Kingdom']
})

canonical = {
    'US': 'United States', 'USA': 'United States', 'United States': 'United States',
    'uk': 'United Kingdom', 'UK': 'United Kingdom', 'United Kingdom': 'United Kingdom'
}

df['country_clean'] = df['country'].map(canonical)
print(df['country_clean'].tolist())
# ['United States', 'United States', 'United States',
#  'United Kingdom', 'United Kingdom', 'United Kingdom']

Fjernelse af mellemrum og standardisering af store og små bogstaver

Før du sammenligner eller grupperer tekstkolonner, skal du altid fjerne mellemrum og normalisere store og små bogstaver som det første trin i rensningen. To værdier, der ser ens ud for et menneske (' Active' og 'active'), behandles som forskellige af Pandas på grund af det indledende mellemrum og forskellen i store og små bogstaver. En kæde i to trin — fjern mellemrum, og konverter derefter til små bogstaver — fanger begge problemer.

import pandas as pd

df = pd.DataFrame({
    'status': ['  Active', 'INACTIVE', 'active ', ' Pending  ', 'ACTIVE']
})

df['status_clean'] = df['status'].str.strip().str.lower()
print(df['status_clean'].value_counts())
# active      3
# inactive    1
# pending     1

Fuzzy matching til rettelse af slåfejl

Når slåfejl forhindrer nøjagtige match, beregner fuzzy matching lighedsscorer mellem tekststrenge. Biblioteket rapidfuzz (eller det klassiske fuzzywuzzy) tilbyder vektoriseret fuzzy matching. En typisk arbejdsgang er: Find for hver unik uren værdi den nærmeste kanoniske værdi over en lighedstærskel, og opbyg et kort over rettelser.

# Conceptual example (requires: pip install rapidfuzz)
from rapidfuzz import process

canonical_cities = ['New York', 'Los Angeles', 'Chicago', 'Houston']
dirty_values = ['New Yrok', 'Los Angelas', 'Chicagoo']

for dirty in dirty_values:
    best, score, _ = process.extractOne(dirty, canonical_cities)
    print(f'{dirty!r} -> {best!r} (score={score:.0f}%)')
# 'New Yrok'   -> 'New York'    (score=91%)
# 'Los Angelas'-> 'Los Angeles' (score=96%)
# 'Chicagoo'   -> 'Chicago'     (score=94%)

Opdeling af celler med flere værdier med explode()

Nogle gange indeholder en celle flere værdier adskilt af et skilletegn (f.eks. 'python,sql,pandas'). Opdel kolonnen for at få lister, og kald derefter .explode() for at oprette én række pr. værdi. Det omdanner en bred, pakket celle til et ordnet langt format, hvor hver række har præcis én værdi — hvilket er nødvendigt for groupby- og sammenføjningsoperationer på disse værdier.

import pandas as pd

df = pd.DataFrame({
    'user_id': [1, 2, 3],
    'skills': ['python,sql', 'java,kotlin,sql', 'python']
})

df['skills'] = df['skills'].str.split(',')
exploded = df.explode('skills')
print(exploded)
#    user_id   skills
# 0        1   python
# 0        1      sql
# 1        2     java
# 1        2   kotlin
# 1        2      sql
# 2        3   python

Håndtering af blandet tegnkodning i tekst

Tekstdata fra forskellige kilder kan have problemer med tegnkodning — mærkelige tegn som \xa0 (hårdt mellemrum), \u2019 (krøllet apostrof) eller forvanskede tegn med accenter. Brug .str.encode('ascii', errors='replace').str.decode('ascii') til en hurtig rensning, der kun bevarer ASCII, eller .str.normalize('NFKD') for at dekomponere accenter, før du fjerner dem.

import pandas as pd
import unicodedata

df = pd.DataFrame({'name': ['Caf\u00e9', 'na\u00efve', 'r\u00e9sum\u00e9']})

# Normalize and strip accents (NFKD decomposition + ascii encoding)
df['name_ascii'] = (
    df['name']
    .str.normalize('NFKD')
    .str.encode('ascii', errors='ignore')
    .str.decode('ascii')
)
print(df)
#       name name_ascii
# 0     Cafe       Cafe
# 1    naive      naive
# 2   resume     resume

Oprettelse af sammensatte nøgler

I mange datasæt skal du oprette en sammensat nøgle ud fra flere kolonner for entydigt at identificere en række til sammenføjninger eller fjernelse af dubletter. Når rensede tekstkolonner (med fjernede mellemrum, konverterede til små bogstaver og normaliserede) kombineres til én nøglestreng, sikres ensartet matchning på tværs af datakilder, hvor den samme entitet kan være stavet en smule forskelligt i hver kilde.

import pandas as pd

df = pd.DataFrame({
    'first': ['  Alice', 'BOB', ' Carol'],
    'last': ['Smith ', 'JONES', 'White  '],
    'dob': ['1990-01-15', '1985-07-22', '1992-11-30']
})

df['match_key'] = (
    df['first'].str.strip().str.lower() + '|' +
    df['last'].str.strip().str.lower() + '|' +
    df['dob']
)
print(df['match_key'].tolist())
# ['alice|smith|1990-01-15', 'bob|jones|1985-07-22', 'carol|white|1992-11-30']

Håndhævelse af en kanonisk kategoriliste

Efter rensningen skal du validere, at alle værdier i en kategorisk tekstkolonne tilhører et kendt kanonisk sæt. En værdi, der ikke findes i sættet, kan være en ny legitim kategori eller en datafejl. Log eller markér ukendte værdier til manuel gennemgang i stedet for at fjerne dem uden videre, så intet overses.

import pandas as pd

df = pd.DataFrame({
    'status': ['active', 'inactive', 'active', 'archived', 'unknown_status']
})

canonical = {'active', 'inactive', 'archived'}

unknown = df[~df['status'].isin(canonical)]['status'].unique()
print('Unknown statuses:', unknown.tolist())
# ['unknown_status']

# Flag unknown rows
df['status_valid'] = df['status'].isin(canonical)
print(df)

Komplet tekstbehandlingspipeline

Her er en komplet tekstbehandlingspipeline, der anvender alle teknikkerne fra denne lektion: fjern mellemrum, normaliser store og små bogstaver, ret forkortelser, fjern specialtegn, og valider mod en kanonisk liste. Det er den slags genanvendelige funktion, du kan føje til ethvert modul til dataindlæsning.

import pandas as pd

def clean_category_column(series, canonical_map, canonical_set):
    cleaned = (
        series
        .str.strip()
        .str.lower()
        .map(lambda x: canonical_map.get(x, x))  # fix known variants
    )
    unknown = cleaned[~cleaned.isin(canonical_set)]
    if not unknown.empty:
        print('Warning: unknown values:', unknown.unique().tolist())
    return cleaned

cmap = {'eng': 'engineering', 'hr': 'human_resources', 'mktg': 'marketing'}
cset = {'engineering', 'human_resources', 'marketing', 'finance'}

df = pd.DataFrame({'dept': ['Eng', 'HR', 'Marketing', 'MKTG', 'Legal']})
df['dept_clean'] = clean_category_column(df['dept'], cmap, cset)
print(df)

Hurtigt tjek

Test din forståelse af, hvordan tekstkolonner kombineres og renses.

Opsummering af lektionen

I denne lektion har du lært at sammenkæde kolonner med + operatoren efter konvertering af numeriske værdier til tekst, bruge str.cat(sep=) til at sammenkæde med et skilletegn og håndtere NaN, anvende en kanonisk afbildning med .map() for at normalisere inkonsistente etiketter og bruge explode() til at udfolde celler med listeværdier til rækker. Håndhæv kanoniske sæt for tidligt at opdage problemer med datakvaliteten. Næste gang sorterer vi DataFrames efter kolonneværdier.

Gratis at komme i gang

Lær Python med en AI-underviser — gratis

Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.

Kurser
30
Lektioner
120

Ofte stillede spørgsmål

Er lektionen “Kombination og oprydning i tekstkolonner” gratis?

Ja — hele teksten til “Kombination og oprydning i tekstkolonner” kan læses gratis her på nettet. Hvis du vil øve dig interaktivt med en indbygget kodeeditor og en AI-vejleder døgnet rundt og få adgang til resten af Pandas & NumPy Academy-kurset, skal du opgradere til CoddyKit PRO. Pandas & NumPy Academy-kurset indeholder 4 lektioner i alt.

Hvad lærer jeg i “Kombination og oprydning i tekstkolonner”?

Sammenkæd flere kolonner til én streng, fjern overflødige mellemrum, og standardisér inkonsistente kategorietiketter. Du øver dig i Pandas & NumPy Academy med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.

Skal jeg have erfaring for at begynde på Pandas & NumPy Academy?

Der kræves ingen tidligere erfaring. Pandas & NumPy Academy på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 4 af 4.

Hvor lang tid tager lektionen “Kombination og oprydning i tekstkolonner”?

De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.

Kan jeg skrive og køre kode i denne Pandas & NumPy Academy-lektion?

Ja. Alle Pandas & NumPy Academy-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.

Alle lektioner i dette kursus

  1. Accessoren .str
  2. Opdeling og erstatning af strenge
  3. Mønstergenkendelse med regex
  4. Kombination og oprydning i tekstkolonner
← Tilbage til Pandas & NumPy Academy