Walidacja i czyszczenie tekstu w Pythonie

Podstawowe czyszczenie tekstu

Normalizacja podstawowa:

Python
Kopiuj
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
def clean_text(text: str) -> str:
    """Podstawowe czyszczenie tekstu."""
    if not text:
        return ""

# Usuwanie białych znaków na początku i końcu
text = text.strip()

# Normalizacja białych znaków (podstawowe czyszczenie)
text = " ".join(text.split())

# Usuwanie znaków specjalnych (opcjonalnie)
import re
text = re.sub(r'[^\w\s-]', '', text)

return text

print(clean_text("To jestprzykładowytekst!"))

Regex do walidacji

Sprawdzanie poprawności formatów:

Python
Kopiuj
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
import re

def validate_email(email: str) -> bool:
    """Waliduje adres e-mail."""
    pattern = r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$'
    return bool(re.match(pattern, email))

def validate_phone(phone: str) -> bool:
    """Waliduje numer telefonu (PL format)."""
    pattern = r'^(\+48)?[\s-]?[0-9]{3}[\s-]?[0-9]{3}[\s-]?[0-9]{3}$'
    return bool(re.match(pattern, phone.replace(' ', '').replace('-', '')))

def validate_nip(nip: str) -> bool:
    """Waliduje NIP (PL)."""
    nip = nip.replace('-', '').replace(' ', '')
    if not nip.isdigit() or len(nip) != 10:
        return False

    # Sprawdzanie sumy kontrolnej
    weights = [6, 5, 7, 2, 3, 4, 5, 6, 7]
    checksum = sum(int(nip[i]) * weights[i] for i in range(9))
    return checksum % 11 == int(nip[9])

# Przykłady
print(validate_email("jan@example.com"))# True
print(validate_phone("+48 123 456 789"))# True
print(validate_nip("123-456-32-18"))# True/False zależy od sumy kontrolnej

Wykrywanie anomalii w tekście

Znajdowanie nietypowych wartości:

Python
Kopiuj
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
from collections import Counter

def detect_text_anomalies(texts: list[str]) -> dict:
    """Wykrywa anomalie w tekście."""
    anomalies = {
        "puste": [],
        "za_krotkie": [],
        "za_dlugie": [],
        "nietypowe_znaki": []
    }

    lengths = [len(text) for text in texts]
    avg_length = sum(lengths) / len(lengths) if lengths else 0

    for i, text in enumerate(texts):
        if not text or not text.strip():
            anomalies["puste"].append(i)
        elif len(text) < avg_length * 0.3:
            anomalies["za_krotkie"].append(i)
        elif len(text) > avg_length * 3:
            anomalies["za_dlugie"].append(i)

        # Sprawdzanie nietypowych znaków
        if text and any(ord(char) > 127 and not char.isalpha() for char in text):
            anomalies["nietypowe_znaki"].append(i)

    return anomalies

texts = ["Normalny tekst", "", "A", "Bardzo długi tekst" * 100, "Tekst z 特殊字符"]
anomalies = detect_text_anomalies(texts)
print(anomalies)

Normalizacja tekstu

Standaryzacja różnych formatów:

Python
Kopiuj
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
import re
import unicodedata

def normalize_text(text: str) -> str:
    """Normalizuje tekst: usuwa akcenty, normalizuje znaki."""
    # Normalizacja Unicode
    text = unicodedata.normalize('NFD', text)

    # Usuwanie akcentów
    text = ''.join(char for char in text if unicodedata.category(char) != 'Mn')

    # Konwersja do małych liter
    text = text.lower()

    # Normalizacja białych znaków - usuwanie nadmiarowych spacji
    text = re.sub(r'\s+', ' ', text).strip()

    return text

def normalize_polish_text(text: str) -> str:
    """Normalizuje polski tekst zachowując znaki diakrytyczne."""
    # Standaryzacja białych znaków - ujednolicenie spacji w polskim tekście
    text = re.sub(r'\s+', ' ', text).strip()

    # Usuwanie nadmiarowych spacji
    text = re.sub(r'\s+', ' ', text)

    return text

print(normalize_text("Café résumé"))
print(normalize_polish_text("To jesttekst"))

Szybkie reguły jakości

Automatyczna kontrola jakości:

Python
Kopiuj
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
def quality_check(text: str) -> dict:
    """Sprawdza jakość tekstu według różnych kryteriów."""
    checks = {
    "ma_min_3_znaki": len(text) >= 3,
    "ma_brak_podwojnych_spacji": "" not in text,
    "ma_brak_znakow_specjalnych_na_poczatku": not text.startswith(("!", "?", ".", ",")),
    "nie_jest_wylacznie_wielkimi": not text.isupper(),
    "ma_brak_bledow_ogolnych": all(char.isprintable() or char.isspace() for char in text)
    }

    checks["score"] = sum(checks.values()) / len(checks)
    return checks

result = quality_check("Przykładowy tekst do sprawdzenia")
print(result)

Podsumowanie

Walidacja i czyszczenie tekstu obejmuje:

• Podstawowe czyszczenie i normalizację
• Walidację z regex dla formatów
• Wykrywanie anomalii w danych tekstowych
• Normalizację Unicode i znaków specjalnych
• Automatyczne reguły jakości dla kontroli

Te techniki są podstawą automatyzacji kontroli jakości tekstu w Pythonie.

---

➡️ Następny artykuł

Po opanowaniu walidacji danych, naucz się generować profesjonalne raporty:

Raporty z Pandas do PDF/CSV/Excel — tworzenie profesjonalnych raportów z DataFrame'ów w różnych formatach, z formatowaniem i wykresami.