Pandas & NumPy Academy · Lezione

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.

Lezione 3 di 413 passaggi

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-04

Gruppi 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      []            0

Corrispondenze 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 developer

Convalidare 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.co

Sostituire 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-5309

Creare 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    NaN

Verifica 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.

Gratis per iniziare

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

  1. L'accessor .str
  2. Dividere e sostituire le stringhe
  3. Confrontare pattern con le espressioni regolari
  4. Combinare e ripulire le colonne di testo
← Torna a Pandas & NumPy Academy