Confrontare pattern con le espressioni regolari
Estragga le sottostringhe e verifichi i pattern con .str.extract(), .str.contains() e .str.match() usando le espressioni regolari.
Confrontare pattern con le espressioni regolari è una lezione Pandas & NumPy Academy gratuita su CoddyKit. Questa è la lezione 3 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Pandas & NumPy Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Pandas & NumPy Academy include 4 lezioni in totale.
Perché usare le regex in Pandas?
Le espressioni regolari (regex) sono un linguaggio per descrivere i pattern delle stringhe. In Pandas, l'accessor .str espone le regex tramite contains(), match(), extract(), findall() e replace(). Le regex sono lo strumento giusto quando i pattern sono troppo complessi per semplici controlli con contains/startswith, ad esempio per convalidare i formati degli indirizzi e-mail, estrarre numeri di telefono da testo libero o trovare tutti gli importi in dollari in una colonna di note.
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() con le regex
.str.contains(pattern) con regex=True (il valore predefinito) restituisce una Series booleana con valore True dove il pattern corrisponde a una parte qualsiasi della stringa. Utilizzi ancoraggi come ^ (inizio) e $ (fine) per limitare la posizione della corrispondenza. Usi comuni: filtrare le righe in cui un campo rispetta un requisito di formato, come un pattern di data valido o un codice formattato correttamente.
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() per le corrispondenze ancorate
.str.match(pattern) verifica se ogni stringa inizia con il pattern (è ancorato all'inizio). Questa è la differenza rispetto a contains(), che cerca in qualsiasi punto della stringa. Utilizzi match() quando interessa soltanto il prefisso della stringa e fullmatch() quando l'intera stringa deve corrispondere al pattern.
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() per i gruppi di cattura
.str.extract(pattern) usa i gruppi di cattura () nel pattern regex per estrarre parti specifiche delle stringhe corrispondenti. Restituisce un DataFrame con una colonna per ogni gruppo di cattura. Viene restituita soltanto la prima corrispondenza di ogni stringa. È ideale per estrarre dati strutturati incorporati nel testo libero, come valori numerici, date o ID.
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-04Gruppi di cattura denominati
È possibile assegnare un nome ai gruppi di cattura usando la sintassi (?P<name>...). Quando si utilizzano gruppi denominati con str.extract(), il DataFrame risultante usa automaticamente tali nomi come intestazioni delle colonne, rendendo l'output autoesplicativo senza dover rinominare le colonne in seguito.
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() per più corrispondenze
.str.extractall(pattern) trova tutte le corrispondenze del pattern in ogni stringa, non soltanto la prima. Restituisce un DataFrame con un MultiIndex: il livello esterno è l'indice della riga originale e il livello interno (match) conta le corrispondenze per riga. È utile per estrarre tutti i numeri, gli URL o le parole chiave dai campi di testo libero.
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() per ottenere una lista di corrispondenze
.str.findall(pattern) restituisce una Series di liste, in cui ogni lista contiene tutte le corrispondenze trovate nella stringa della riga. A differenza di extractall(), non crea un MultiIndex: ogni riga riceve una lista di corrispondenze. È comodo quando si desidera mantenere i risultati in una struttura piatta o contare le corrispondenze per riga.
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 [] 0Corrispondenze senza distinzione tra maiuscole e minuscole con re.IGNORECASE
Per impostazione predefinita, le regex in Pandas distinguono tra maiuscole e minuscole. Passi flags=re.IGNORECASE (o re.I) per rendere il pattern insensibile alle maiuscole e minuscole. In questo modo non è necessario scrivere pattern con alternanze come [Pp][Yy][Tt][Hh][Oo][Nn] quando si desidera trovare allo stesso modo 'python', 'Python' o '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 developerConvalidare i formati con una corrispondenza completa
.str.fullmatch(pattern) (aggiunto in Pandas 1.1) restituisce True solo quando la stringa intera corrisponde al pattern. A differenza di contains(), che trova una sottostringa, fullmatch equivale ad aggiungere gli ancoraggi ^...$. È il modo più sicuro per convalidare la conformità a un formato: indirizzi e-mail, numeri di telefono, codici postali o qualsiasi campo con uno schema rigido.
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.coSostituire usando riferimenti all'indietro regex
Quando si usa str.replace(pattern, repl, regex=True), la stringa di sostituzione può includere riferimenti all'indietro come r'\1' per fare riferimento al contenuto acquisito nel primo gruppo (). Questo consente potenti riformattazioni, ad esempio trasformare MM/DD/YYYY in YYYY-MM-DD o racchiudere una parola trovata in tag 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-5309Creare un estrattore di dati basato sulle regex
Ecco un esempio pratico completo: estrarre lo SKU e il prezzo di un prodotto da una colonna di note disordinate usando gruppi denominati. Questo tipo di estrazione è comune quando si importano dati da sistemi legacy in cui più campi sono stati concatenati in un unico campo di testo.
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 NaNVerifica rapida
Verifichi la Sua comprensione della ricerca di corrispondenze nei pattern con le regex in Pandas.
Riepilogo della lezione
In questa lezione ha imparato che str.contains(regex) filtra le righe in base a un pattern, str.extract() acquisisce la prima corrispondenza in una colonna del DataFrame (utilizzi gruppi denominati per ottenere un output autoesplicativo), str.extractall() trova tutte le corrispondenze per riga usando un MultiIndex e str.fullmatch() verifica che l'intera stringa rispetti un pattern. Prossimamente combineremo e puliremo più colonne di testo.
Impara Python con un tutor IA — gratis
Scrivi ed esegui vero codice nel tuo browser, ricevi aiuto istantaneo da un tutor IA disponibile 24/7, e riprendi da dove hai lasciato sul web o nell'app.
- Corsi
- 30
- Lezioni
- 120
Domande Frequenti
La lezione «Confrontare pattern con le espressioni regolari» è gratuita?
Sì — il testo completo di «Confrontare pattern con le espressioni regolari» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Pandas & NumPy Academy, passa a CoddyKit PRO. Il corso Pandas & NumPy Academy include 4 lezioni in totale.
Cosa imparerò in «Confrontare pattern con le espressioni regolari»?
Estragga le sottostringhe e verifichi i pattern con .str.extract(), .str.contains() e .str.match() usando le espressioni regolari. Eserciti Pandas & NumPy Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.
Ho bisogno di esperienza per iniziare Pandas & NumPy Academy?
Non è richiesta alcuna esperienza precedente. Pandas & NumPy Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 3 di 4.
Quanto tempo richiede la lezione «Confrontare pattern con le espressioni regolari»?
La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.
Posso scrivere ed eseguire codice in questa lezione Pandas & NumPy Academy?
Sì. Ogni lezione Pandas & NumPy Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.
Tutte le lezioni di questo corso
- L'accessor .str
- Dividere e sostituire le stringhe
- Confrontare pattern con le espressioni regolari
- Combinare e ripulire le colonne di testo