Pandas & NumPy Academy · Lektion

Kombinera och rensa textkolumner

Slå samman flera kolumner till en sträng, ta bort blanksteg och normalisera inkonsekventa kategorietiketter.

Lektion 4 av 413 steg

Kombinera och rensa textkolumner är en gratis lektion i Pandas & NumPy Academy på CoddyKit. Detta är lektion 4 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för Pandas & NumPy Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Pandas & NumPy Academy innehåller totalt 4 lektioner.

Sammanfoga textkolumner

En vanlig uppgift vid databeredning är att skapa en enda sträng genom att kombinera värden från flera kolumner – till exempel skapa ett fullständigt namn från förnamn och efternamn eller en adress från gata, ort och land. I Pandas sammanfogar Ni strängkolumner med operatorn + på två Series (eller en Series och en strängliteral), efter att numeriska kolumner har konverterats till strängar 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']

Sammanfoga med kolumner som inte är strängar

När Ni kombinerar en numerisk kolumn med en strängkolumn måste Ni först konvertera den numeriska kolumnen till en sträng med .astype(str). Pythons operator + utlöser ett TypeError om Ni försöker addera en sträng-Series och en integer-Series. Detta är en vanlig källa till förvirring när sammansatta nycklar eller etiketter skapas från kolumner med blandade datatyper.

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() för sammanfogning med avgränsare

Series.str.cat(others, sep=) är Pandas inbyggda sätt att sammanfoga flera Series med en avgränsare och hanterar NaN-värden på ett smidigt sätt. Som standard gör en NaN i någon kolumn att resultatet för den raden blir NaN. Ange na_rep='?' (eller valfri sträng) för att ersätta NaN med en platshållare i stället för att låta värdet spridas vidare.

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']

Normalisera inkonsekventa kategorietiketter

Kategorikolumner i verkliga data har ofta inkonsekventa etiketter på grund av stavfel, variationer i skiftläge eller olika förkortningar (till exempel 'US', 'USA', 'United States'). Den vanliga lösningen är att skapa en mappningsordbok som mappar varje variant till den kanoniska formen och sedan tillämpa 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']

Ta bort blanksteg och standardisera skiftläge

Innan textkolumner jämförs eller grupperas ska Ni alltid ta bort blanksteg och normalisera skiftläget som första rensningssteg. Två värden som ser likadana ut för en människa (' Active' och 'active') behandlas som olika av Pandas på grund av det inledande blanksteget och skillnaden i skiftläge. En kedja i två steg – ta bort blanksteg och konvertera sedan till gemener – fångar båda problemen.

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

Luddig matchning för korrigering av stavfel

När stavfel förhindrar exakt matchning beräknar luddig matchning likhetspoäng mellan strängar. Biblioteket rapidfuzz (eller det klassiska fuzzywuzzy) tillhandahåller vektoriserad luddig matchning. Ett typiskt arbetsflöde är att för varje unikt orent värde hitta det närmaste kanoniska värdet över en likhetströskel och skapa en korrigeringsmappning.

# 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%)

Dela celler med flera värden med explode()

Ibland innehåller en cell flera värden som separeras av en avgränsare (till exempel 'python,sql,pandas'). Dela kolumnen för att få listor och anropa sedan .explode() för att skapa en rad per värde. Det omvandlar en bred, packad cell till ett städad långformat där varje rad innehåller exakt ett värde – vilket krävs för groupby- och join-operationer på dessa värden.

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

Hantera blandad teckenkodning i text

Textdata från olika källor kan ha problem med teckenkodning – ovanliga tecken som \xa0 (fast blanksteg), \u2019 (böjt apostroftecken) eller förvrängda tecken med diakritiska markeringar. Använd .str.encode('ascii', errors='replace').str.decode('ascii') för en snabb rensning till enbart ASCII, eller .str.normalize('NFKD') för att dela upp diakritiska markeringar innan de tas bort.

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

Skapa sammansatta nycklar

I många dataset behöver Ni skapa en sammansatt nyckel från flera kolumner för att entydigt identifiera en rad vid join-operationer eller borttagning av dubbletter. Genom att kombinera rensade strängkolumner (med borttagna blanksteg, konverterade till gemener och normaliserade) till en enda nyckelsträng säkerställs konsekvent matchning mellan datakällor där samma entitet kan vara stavad något olika i varje källa.

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']

Tvinga fram en kanonisk kategorilista

Efter rensningen ska Ni kontrollera att alla värden i en kategorisk textkolumn tillhör en känd kanonisk mängd. Ett värde som inte finns i mängden kan ange en ny legitim kategori eller ett datafel. Logga eller flagga okända värden för manuell granskning i stället för att tyst ta bort dem, så att inget passerar obemärkt.

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)

Fullständig pipeline för textrensning

Här är en komplett pipeline för textrensning som tillämpar alla tekniker från den här lektionen: ta bort blanksteg, normalisera skiftläge, korrigera förkortningar, ta bort specialtecken och validera mot en kanonisk lista. Detta är den typ av återanvändbar funktion som Ni skulle lägga till i vilken modul för dataimport som helst.

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)

Snabb kontroll

Testa Er förståelse av hur textkolumner kombineras och rensas.

Lektionssammanfattning

I den här lektionen lärde Ni Er att sammanfoga kolumner med + operator efter att numeriska värden har konverterats till strängar, använda str.cat(sep=) för att sammanfoga med en avgränsare och hantera NaN, tillämpa en kanonisk mappning med .map() för att normalisera inkonsekventa etiketter och använda explode() för att expandera celler med listvärden till rader. Tvinga fram kanoniska mängder för att upptäcka problem med datakvaliteten tidigt. Nästa steg är att sortera DataFrames efter kolumnvärden.

Gratis att börja

Lär dig Python med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser
30
Lektioner
120

Vanliga frågor

Är lektionen ”Kombinera och rensa textkolumner” gratis?

Ja – hela texten till ”Kombinera och rensa textkolumner” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i Pandas & NumPy Academy, kan Ni uppgradera till CoddyKit PRO. Kursen i Pandas & NumPy Academy innehåller totalt 4 lektioner.

Vad lär jag mig i ”Kombinera och rensa textkolumner”?

Slå samman flera kolumner till en sträng, ta bort blanksteg och normalisera inkonsekventa kategorietiketter. Ni övar på Pandas & NumPy Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig Pandas & NumPy Academy?

Du behöver inga förkunskaper. Utbildningen i Pandas & NumPy Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 4 av 4.

Hur lång tid tar lektionen ”Kombinera och rensa textkolumner”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här Pandas & NumPy Academy-lektionen?

Ja. Varje Pandas & NumPy Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

  1. Attributet .str
  2. Dela upp och ersätta strängar
  3. Mönstermatchning med regex
  4. Kombinera och rensa textkolumner
← Tillbaka till Pandas & NumPy Academy