0Pricing
Pandas & NumPy Academy · Lekcja

Łączenie i czyszczenie kolumn tekstowych

Połącz wiele kolumn w jeden tekst, usuń białe znaki i ujednolić niespójne etykiety kategorii.

Łączenie i czyszczenie kolumn tekstowych to bezpłatna lekcja Pandas & NumPy Academy na CoddyKit. To lekcja 4 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Pandas & NumPy Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Pandas & NumPy Academy zawiera 4 lekcji w sumie.

Łączenie kolumn tekstowych

Częstym zadaniem podczas przygotowywania danych jest utworzenie jednego napisu przez połączenie wartości z wielu kolumn — na przykład utworzenie pełnego imienia i nazwiska z imienia i nazwiska albo adresu z ulicy, miasta i kraju. W Pandas kolumny tekstowe łączy się za pomocą operatora + użytego na dwóch obiektach Series (albo na obiekcie Series i literału napisowym), po wcześniejszej konwersji kolumn liczbowych na napisy za pomocą .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']

Łączenie z kolumnami nietekstowymi

Podczas łączenia kolumny liczbowej z kolumną tekstową należy najpierw przekonwertować kolumnę liczbową na napis za pomocą .astype(str). Operator + języka Python zgłasza TypeError przy próbie dodania obiektu Series zawierającego napisy do obiektu Series zawierającego liczby całkowite. Jest to częste źródło nieporozumień podczas tworzenia kluczy złożonych lub etykiet z kolumn o różnych typach.

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()` do łączenia z separatorem

Series.str.cat(others, sep=) to natywny dla Pandas sposób łączenia wielu obiektów Series za pomocą separatora, który prawidłowo obsługuje wartości NaN. Domyślnie wartość NaN w dowolnej kolumnie powoduje, że wynik dla danego wiersza również jest NaN. Przekazanie na_rep='?' (lub dowolnego innego ciągu znaków) zastępuje NaN symbolem zastępczym zamiast propagować tę wartość.

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

Normalizowanie niespójnych etykiet kategorii

Kolumny kategorii w rzeczywistych danych często zawierają niespójne etykiety wynikające z literówek, różnic w wielkości liter lub różnych skrótów (np. „US”, „USA”, „United States”). Standardowym rozwiązaniem jest utworzenie słownika mapowania, który przypisuje każdemu wariantowi postać kanoniczną, a następnie zastosowanie go za pomocą .map() lub .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']

Usuwanie białych znaków i ujednolicanie wielkości liter

Przed porównywaniem lub grupowaniem kolumn tekstowych należy zawsze w pierwszym kroku czyszczenia usunąć białe znaki i ujednolicić wielkość liter. Pandas traktuje dwie wartości, które dla człowieka wyglądają tak samo („ Active” i „active”), jako różne z powodu spacji na początku i różnicy w wielkości liter. Dwuetapowy łańcuch — najpierw usunięcie białych znaków, a następnie zamiana na małe litery — eliminuje oba problemy.

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

Dopasowanie przybliżone do poprawiania literówek

Gdy literówki uniemożliwiają dokładne dopasowanie, dopasowanie przybliżone oblicza poziom podobieństwa między ciągami znaków. Biblioteka rapidfuzz (lub klasyczna biblioteka fuzzywuzzy) udostępnia zwektoryzowane dopasowanie przybliżone. Typowy przebieg pracy wygląda następująco: dla każdej unikalnej niepoprawnej wartości należy znaleźć najbardziej zbliżoną wartość kanoniczną, której podobieństwo przekracza ustalony próg, i utworzyć mapę poprawek.

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

Dzielenie komórek z wieloma wartościami za pomocą explode()

Czasami komórka zawiera wiele wartości rozdzielonych separatorem (np. 'python,sql,pandas'). Należy podzielić kolumnę, aby uzyskać listy, a następnie wywołać .explode(), by utworzyć osobny wiersz dla każdej wartości. W ten sposób szeroka, upakowana komórka zostaje przekształcona w uporządkowany format długi, w którym każdy wiersz zawiera dokładnie jedną wartość — jest to konieczne przy operacjach groupby i join na tych wartościach.

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

Obsługa tekstu z mieszaną stroną kodową

Dane tekstowe z różnych źródeł mogą zawierać problemy z kodowaniem — nietypowe znaki, takie jak \xa0 (spacja nierozdzielająca), \u2019 (zakrzywiony apostrof) lub zniekształcone znaki diakrytyczne. Do szybkiego czyszczenia ograniczonego do ASCII należy użyć .str.encode('ascii', errors='replace').str.decode('ascii'), a za pomocą .str.normalize('NFKD') można rozłożyć znaki diakrytyczne przed ich usunięciem.

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

Tworzenie kluczy złożonych

W wielu zbiorach danych trzeba utworzyć klucz złożony z wielu kolumn, aby jednoznacznie identyfikować wiersz na potrzeby złączeń lub usuwania duplikatów. Połączenie oczyszczonych kolumn tekstowych (z usuniętymi białymi znakami, zamienionych na małe litery i znormalizowanych) w jeden ciąg klucza zapewnia spójne dopasowanie między źródłami danych, w których ta sama jednostka może być zapisana nieco inaczej.

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

Wymuszanie kanonicznej listy kategorii

Po oczyszczeniu należy sprawdzić, czy wszystkie wartości w kategorycznej kolumnie tekstowej należą do znanego zbioru kanonicznego. Wartość spoza tego zbioru może wskazywać nową, prawidłową kategorię albo błąd danych. Nieznane wartości należy rejestrować lub oznaczać do ręcznego przeglądu, zamiast po cichu je usuwać, aby żadna nieprawidłowość nie pozostała niezauważona.

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)

Kompletny potok czyszczenia tekstu

Oto kompletny potok czyszczenia tekstu, który stosuje wszystkie techniki z tej lekcji: usuwa białe znaki, ujednolica wielkość liter, poprawia skróty, usuwa znaki specjalne i sprawdza wartości względem listy kanonicznej. Tego rodzaju funkcję wielokrotnego użytku można dodać do dowolnego modułu pozyskiwania danych.

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)

Szybkie sprawdzenie

Sprawdź, czy rozumie Pan/Pani łączenie i czyszczenie kolumn tekstowych.

Podsumowanie lekcji

W tej lekcji nauczył się Pan / nauczyła się Pani: łączyć kolumny za pomocą operatora + po konwersji wartości liczbowych na ciągi znaków, używać str.cat(sep=) do łączenia z separatorem i obsługi NaN, stosować mapę kanoniczną za pomocą .map() w celu normalizowania niespójnych etykiet oraz używać explode() do rozwijania komórek zawierających listy do postaci wierszy. Należy wymuszać zgodność ze zbiorami kanonicznymi, aby wcześnie wykrywać problemy z jakością danych. W następnej części posortujemy obiekty DataFrame według wartości kolumn.

Często zadawane pytania

Czy lekcja „Łączenie i czyszczenie kolumn tekstowych” jest bezpłatna?

Tak — pełny tekst „Łączenie i czyszczenie kolumn tekstowych” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Pandas & NumPy Academy, przejdź na CoddyKit PRO. Kurs Pandas & NumPy Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Łączenie i czyszczenie kolumn tekstowych”?

Połącz wiele kolumn w jeden tekst, usuń białe znaki i ujednolić niespójne etykiety kategorii. Ćwiczysz Pandas & NumPy Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Pandas & NumPy Academy?

Nie wymagamy żadnego doświadczenia. Pandas & NumPy Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 4 z 4.

Ile czasu zajmuje lekcja „Łączenie i czyszczenie kolumn tekstowych”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Pandas & NumPy Academy?

Tak. Każda lekcja Pandas & NumPy Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

  1. Akcesor .str
  2. Dzielenie i zastępowanie tekstu
  3. Dopasowywanie wzorców za pomocą wyrażeń regularnych
  4. Łączenie i czyszczenie kolumn tekstowych
← Powrót do Pandas & NumPy Academy