Dopasowywanie wzorców za pomocą wyrażeń regularnych
Wyodrębniaj fragmenty tekstu i sprawdzaj wzorce za pomocą .str.extract(), .str.contains() oraz .str.match(), korzystając z wyrażeń regularnych.
Dopasowywanie wzorców za pomocą wyrażeń regularnych to bezpłatna lekcja Pandas & NumPy Academy na CoddyKit. To lekcja 3 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.
Dlaczego wyrażenia regularne w Pandas?
Wyrażenia regularne (regex) to język opisywania wzorców napisów. W Pandas akcesor .str udostępnia wyrażenia regularne za pomocą metod contains(), match(), extract(), findall() oraz replace(). Wyrażenia regularne są właściwym narzędziem, gdy wzorce są zbyt złożone dla prostych sprawdzeń contains/startswith — na przykład podczas sprawdzania poprawności formatów adresów e-mail, wyodrębniania numerów telefonów z tekstu swobodnego lub znajdowania wszystkich kwot w dolarach w kolumnie z notatkami.
import pandas as pd
df = pd.DataFrame({
'text': ['Order #12345 placed', 'No order', 'Ref #67890 paid', 'Refund for #11111']
})
# Find rows that contain an order number (# followed by 5 digits)
has_order = df['text'].str.contains(r'#\d{5}', regex=True)
print(df[has_order])
# text
# 0 Order #12345 placed
# 2 Ref #67890 paid
# 3 Refund for #11111.str.contains() z wyrażeniem regularnym
.str.contains(pattern) z regex=True (wartość domyślna) zwraca logiczny obiekt Series, w którym wartość True występuje wszędzie tam, gdzie wzorzec dopasowuje się w dowolnym miejscu napisu. Należy używać kotwic, takich jak ^ (początek) i $ (koniec), aby ograniczyć miejsce dopasowania. Typowe zastosowanie to filtrowanie wierszy, których pole spełnia wymagania określonego formatu, na przykład poprawnego wzorca daty lub prawidłowo sformatowanego kodu.
import pandas as pd
df = pd.DataFrame({
'code': ['US-001', 'UK-042', 'DE-18', 'FR-', 'us-003']
})
# Valid format: two uppercase letters, hyphen, 3 digits
valid = df['code'].str.contains(r'^[A-Z]{2}-\d{3}$', regex=True)
print(df['code'][valid].tolist())
# ['US-001', 'UK-042'].str.match() do dopasowywania od początku
.str.match(pattern) sprawdza, czy każdy napis zaczyna się od wzorca (wzorzec jest zakotwiczony na początku). Na tym polega różnica w porównaniu z contains(), które wyszukuje wzorzec w dowolnym miejscu napisu. Należy używać match(), gdy interesuje Państwa tylko prefiks napisu, a fullmatch(), gdy cały napis musi pasować do wzorca.
import pandas as pd
df = pd.DataFrame({'id': ['ORD001', 'ORD002', 'RET003', 'ORDXYZ']})
# Match rows whose ID starts with 'ORD' followed by digits
orders = df['id'].str.match(r'ORD\d+')
print(df[orders])
# id
# 0 ORD001
# 1 ORD002
# match() is anchored at start, so 'ORDXYZ' (XYZ not digits) is excluded.str.extract() do grup przechwytujących
.str.extract(pattern) wykorzystuje grupy przechwytujące () we wzorcu wyrażenia regularnego do wyodrębniania konkretnych części dopasowanych napisów. Zwraca obiekt DataFrame z jedną kolumną dla każdej grupy przechwytującej. Z każdego napisu zwracane jest tylko pierwsze dopasowanie. Jest to idealne rozwiązanie do wyodrębniania ustrukturyzowanych danych osadzonych w tekście swobodnym — takich jak wartości liczbowe, daty czy identyfikatory.
import pandas as pd
df = pd.DataFrame({
'notes': ['Shipped on 2024-01-15', 'Delivered on 2024-03-20', 'Pending', 'Shipped on 2024-07-04']
})
# Extract the date (YYYY-MM-DD) from the notes column
dates = df['notes'].str.extract(r'(\d{4}-\d{2}-\d{2})')
df['shipped_date'] = dates[0]
print(df[['notes', 'shipped_date']])
# notes shipped_date
# 0 Shipped on 2024-01-15 2024-01-15
# 1 Delivered on 2024-03-20 2024-03-20
# 2 Pending NaN
# 3 Shipped on 2024-07-04 2024-07-04Nazwane grupy przechwytujące
Grupy przechwytujące można nazwać za pomocą składni (?P<name>...). Przy użyciu nazwanych grup z str.extract() wynikowy obiekt DataFrame automatycznie używa tych nazw jako nagłówków kolumn — dzięki temu wynik sam opisuje swoją zawartość i nie trzeba później zmieniać nazw kolumn.
import pandas as pd
df = pd.DataFrame({
'entry': ['Alice (25, Engineer)', 'Bob (30, Manager)', 'Carol (28, Analyst)']
})
# Named capturing groups
extracted = df['entry'].str.extract(
r'(?P<name>\w+) \((?P<age>\d+), (?P<role>\w+)\)'
)
print(extracted)
# name age role
# 0 Alice 25 Engineer
# 1 Bob 30 Manager
# 2 Carol 28 Analyst.str.extractall() do wielu dopasowań
.str.extractall(pattern) znajduje wszystkie dopasowania wzorca w każdym napisie, a nie tylko pierwsze. Zwraca obiekt DataFrame z MultiIndex: zewnętrzny poziom zawiera oryginalny indeks wiersza, a wewnętrzny poziom (match) zlicza dopasowania w każdym wierszu. Jest to przydatne do wyodrębniania wszystkich liczb, adresów URL lub słów kluczowych z pól zawierających tekst swobodny.
import pandas as pd
df = pd.DataFrame({
'text': ['Call 555-1234 or 555-5678', 'Contact 800-9000', 'No numbers']
})
# Extract all phone patterns
all_phones = df['text'].str.extractall(r'(\d{3}-\d{4})')
print(all_phones)
# 0
# match
# 0 0 555-1234
# 1 555-5678
# 1 0 800-9000.str.findall() — lista dopasowań
.str.findall(pattern) zwraca obiekt Series zawierający listy, przy czym każda lista zawiera wszystkie dopasowania znalezione w napisie danego wiersza. W przeciwieństwie do extractall() metoda ta nie tworzy MultiIndex — każdy wiersz otrzymuje listę dopasowań. Jest to wygodne, gdy wyniki mają pozostać w płaskiej strukturze lub gdy chcą Państwo zliczyć dopasowania w każdym wierszu.
import pandas as pd
df = pd.DataFrame({
'text': ['Buy 3 items for $10 each', 'Save $5 on 2 products', 'No deal']
})
# Find all dollar amounts
df['prices'] = df['text'].str.findall(r'\$\d+')
df['price_count'] = df['prices'].str.len()
print(df[['text', 'prices', 'price_count']])
# text prices price_count
# 0 Buy 3 items for $10 each [$10] 1
# 1 Save $5 on 2 products [$5] 1
# 2 No deal [] 0Dopasowywanie bez uwzględniania wielkości liter za pomocą re.IGNORECASE
Domyślnie wyrażenia regularne w Pandas uwzględniają wielkość liter. Należy przekazać flags=re.IGNORECASE (lub re.I), aby dopasowanie nie uwzględniało wielkości liter. Dzięki temu nie trzeba pisać wzorców alternatywnych, takich jak [Pp][Yy][Tt][Hh][Oo][Nn], gdy chcą Państwo jednakowo dopasowywać wartości „python”, „Python” i „PYTHON”.
import pandas as pd
import re
df = pd.DataFrame({
'skill': ['Python', 'JAVA', 'javascript', 'PyThOn developer', 'SQL']
})
# Case-insensitive search for python
mask = df['skill'].str.contains('python', flags=re.IGNORECASE, regex=True)
print(df[mask])
# skill
# 0 Python
# 3 PyThOn developerSprawdzanie formatów za pomocą pełnego dopasowania
.str.fullmatch(pattern) (dodane w Pandas 1.1) zwraca True tylko wtedy, gdy cały napis pasuje do wzorca. W przeciwieństwie do contains(), które dopasowuje podnapis, fullmatch jest równoważne zakotwiczeniu wzorca za pomocą ^...$. Jest to najbezpieczniejszy sposób sprawdzania zgodności z formatem — w przypadku adresów e-mail, numerów telefonów, kodów pocztowych lub dowolnych pól o ścisłym schemacie.
import pandas as pd
df = pd.DataFrame({
'email': ['alice@example.com', 'bob_at_work', 'carol@test', 'dave@org.co']
})
# Simple email validation: word@word.word
valid_email = df['email'].str.fullmatch(r'[\w.+-]+@[\w-]+\.[\w.]+')
print(df[valid_email])
# email
# 0 alice@example.com
# 3 dave@org.coZastępowanie za pomocą odwołań wstecznych wyrażeń regularnych
Podczas używania str.replace(pattern, repl, regex=True) napis zastępujący może zawierać odwołania wsteczne, takie jak r'\1', odnoszące się do zawartości przechwyconej przez pierwszą grupę (). Umożliwia to zaawansowane przeformatowywanie — na przykład zmianę formatu MM/DD/YYYY na YYYY-MM-DD lub otoczenie dopasowanego słowa tagami HTML.
import pandas as pd
df = pd.DataFrame({'phone': ['(555) 123-4567', '(800) 555-0199', '(212) 867-5309']})
# Reformat to 555-123-4567
df['phone_clean'] = df['phone'].str.replace(
r'\((\d{3})\) (\d{3})-(\d{4})',
r'\1-\2-\3',
regex=True
)
print(df)
# phone phone_clean
# 0 (555) 123-4567 555-123-4567
# 1 (800) 555-0199 800-555-0199
# 2 (212) 867-5309 212-867-5309Tworzenie ekstraktora danych opartego na wyrażeniach regularnych
Oto praktyczny przykład obejmujący cały proces: wyodrębnianie SKU produktu i ceny z nieuporządkowanej kolumny z notatkami za pomocą nazwanych grup. Tego typu ekstrakcja jest częsta podczas importowania danych ze starszych systemów, w których wiele pól połączono w jedno pole tekstowe.
import pandas as pd
df = pd.DataFrame({
'note': [
'SKU:A001 price:$49.99 in stock',
'SKU:B202 price:$12.50 low stock',
'No SKU available'
]
})
extracted = df['note'].str.extract(
r'SKU:(?P<sku>\w+).*price:\$(?P<price>[\d.]+)'
)
print(extracted)
# sku price
# 0 A001 49.99
# 1 B202 12.50
# 2 NaN NaNSzybkie sprawdzenie
Sprawdź swoją wiedzę na temat dopasowywania wzorców za pomocą wyrażeń regularnych w Pandas.
Podsumowanie lekcji
W tej lekcji nauczyli się Państwo, że: str.contains(regex) filtruje wiersze według wzorca, str.extract() przechwytuje pierwsze dopasowanie do kolumny obiektu DataFrame (nazwane grupy zapewniają samoopisujący się wynik), str.extractall() znajduje wszystkie dopasowania w każdym wierszu za pomocą MultiIndex, a str.fullmatch() sprawdza, czy cały napis jest zgodny ze wzorcem. W następnej części połączymy i wyczyścimy wiele kolumn tekstowych.
Ucz się Python dzięki korepetycjom AI — za darmo
Pisz i uruchamiaj kod w przeglądarce, otrzymuj natychmiastową pomoc od korepetytora AI dostępnego 24/7 i kontynuuj naukę w sieci lub w aplikacji.
- Kursy
- 30
- Lekcje
- 120
Często zadawane pytania
Czy lekcja „Dopasowywanie wzorców za pomocą wyrażeń regularnych” jest bezpłatna?
Tak — pełny tekst „Dopasowywanie wzorców za pomocą wyrażeń regularnych” 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 „Dopasowywanie wzorców za pomocą wyrażeń regularnych”?
Wyodrębniaj fragmenty tekstu i sprawdzaj wzorce za pomocą .str.extract(), .str.contains() oraz .str.match(), korzystając z wyrażeń regularnych. Ć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 3 z 4.
Ile czasu zajmuje lekcja „Dopasowywanie wzorców za pomocą wyrażeń regularnych”?
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
- Akcesor .str
- Dzielenie i zastępowanie tekstu
- Dopasowywanie wzorców za pomocą wyrażeń regularnych
- Łączenie i czyszczenie kolumn tekstowych