Correspondência de padrões com expressões regulares
Extraia partes de textos e verifique padrões com .str.extract(), .str.contains() e .str.match() usando expressões regulares.
Correspondência de padrões com expressões regulares é uma aula grátis de Pandas & NumPy Academy no CoddyKit. Esta é a aula 3 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Pandas & NumPy Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Pandas & NumPy Academy inclui 4 aulas no total.
Por que usar expressões regulares no Pandas?
Expressões regulares (regex) são uma linguagem para descrever padrões de cadeias de caracteres. No Pandas, o acessador .str disponibiliza expressões regulares por meio de contains(), match(), extract(), findall() e replace(). A expressão regular é a ferramenta adequada quando seus padrões são complexos demais para verificações simples com contains/startswith — por exemplo, para validar formatos de e-mail, extrair números de telefone de texto livre ou encontrar todos os valores em dólares em uma coluna de anotações.
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() com expressões regulares
.str.contains(pattern) com regex=True (o padrão) retorna uma Série booleana que contém True sempre que o padrão corresponde a qualquer parte da cadeia de caracteres. Use âncoras como ^ (início) e $ (fim) para restringir o local da correspondência. Usos comuns incluem filtrar linhas cujo campo corresponde a um requisito de formato, como um padrão de data válido ou um código formatado corretamente.
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() para correspondência ancorada
.str.match(pattern) verifica se cada cadeia de caracteres começa com o padrão (ele é ancorado no início). Essa é a diferença em relação a contains(), que pesquisa em qualquer parte da cadeia de caracteres. Use match() quando você se importa apenas com o prefixo da cadeia de caracteres e fullmatch() quando a cadeia inteira precisa corresponder ao padrão.
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() para grupos de captura
.str.extract(pattern) usa grupos de captura () no padrão de expressão regular para extrair partes específicas das cadeias de caracteres correspondentes. Ele retorna um DataFrame com uma coluna para cada grupo de captura. Apenas a primeira correspondência de cada cadeia de caracteres é retornada. Isso é ideal para extrair dados estruturados incorporados em texto livre — como valores numéricos, datas ou identificadores.
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-04Grupos de captura nomeados
Você pode nomear grupos de captura usando a sintaxe (?P<name>...). Ao usar grupos nomeados com str.extract(), o DataFrame resultante usa automaticamente esses nomes como cabeçalhos de coluna, tornando a saída autoexplicativa sem que seja necessário renomear as colunas depois.
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() para várias correspondências
.str.extractall(pattern) encontra todas as correspondências do padrão em cada cadeia de caracteres, não apenas a primeira. Ele retorna um DataFrame com um MultiIndex: o nível externo é o índice da linha original, e o nível interno (match) conta as correspondências por linha. Isso é útil para extrair todos os números, URLs ou termos-chave de campos de texto livre.
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() para obter uma lista de correspondências
.str.findall(pattern) retorna uma Série de listas, em que cada lista contém todas as correspondências encontradas na cadeia de caracteres daquela linha. Diferentemente de extractall(), ele não cria um MultiIndex — cada linha recebe uma lista de correspondências. Isso é conveniente quando você quer manter os resultados em uma estrutura simples ou contar as correspondências por linha.
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 [] 0Correspondência sem distinção entre maiúsculas e minúsculas com re.IGNORECASE
Por padrão, as expressões regulares no Pandas diferenciam maiúsculas de minúsculas. Passe flags=re.IGNORECASE (ou re.I) para tornar o padrão insensível a maiúsculas e minúsculas. Assim, você não precisa escrever padrões de alternância como [Pp][Yy][Tt][Hh][Oo][Nn] quando quiser tratar 'python', 'Python' e 'PYTHON' da mesma forma.
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 developerValidando formatos com correspondência completa
.str.fullmatch(pattern) (adicionado no Pandas 1.1) retorna True somente quando a cadeia de caracteres inteira corresponde ao padrão. Diferentemente de contains(), que corresponde a uma substring, fullmatch equivale a usar as âncoras ^...$. Essa é a forma mais segura de validar a conformidade com um formato — endereços de e-mail, números de telefone, códigos postais ou qualquer campo com um esquema rigoroso.
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.coSubstituindo com referências retroativas de expressões regulares
Ao usar str.replace(pattern, repl, regex=True), a cadeia de substituição pode incluir referências retroativas, como r'\1', para fazer referência ao conteúdo capturado no primeiro grupo (). Isso permite reformatá-lo de maneiras avançadas — por exemplo, mudar MM/DD/YYYY para YYYY-MM-DD ou envolver uma palavra encontrada em tags 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-5309Criando um extrator de dados baseado em expressões regulares
Veja um exemplo prático completo: extraímos o SKU e o preço de um produto de uma coluna de anotações desorganizada usando grupos nomeados. Esse tipo de extração é comum ao importar dados de sistemas legados nos quais vários campos foram concatenados em um único campo de texto.
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ção rápida
Teste sua compreensão da correspondência de padrões com expressões regulares no Pandas.
Resumo da lição
Nesta lição, você aprendeu que str.contains(regex) filtra linhas por padrão, str.extract() captura a primeira correspondência em uma coluna de um DataFrame (use grupos nomeados para obter uma saída autoexplicativa), str.extractall() encontra todas as correspondências por linha com um MultiIndex e str.fullmatch() valida se a cadeia inteira está em conformidade com um padrão. A seguir, combinaremos e limparemos várias colunas de texto.
Perguntas Frequentes
A aula “Correspondência de padrões com expressões regulares” é grátis?
Sim — o texto completo de “Correspondência de padrões com expressões regulares” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Pandas & NumPy Academy, atualize para CoddyKit PRO. O curso de Pandas & NumPy Academy inclui 4 aulas no total.
O que vou aprender em “Correspondência de padrões com expressões regulares”?
Extraia partes de textos e verifique padrões com .str.extract(), .str.contains() e .str.match() usando expressões regulares. Você pratica Pandas & NumPy Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.
Preciso ter experiência prévia para começar Pandas & NumPy Academy?
Nenhuma experiência prévia é necessária. Pandas & NumPy Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 3 de 4.
Quanto tempo leva a aula “Correspondência de padrões com expressões regulares”?
A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.
Posso escrever e executar código nesta aula de Pandas & NumPy Academy?
Sim. Cada aula de Pandas & NumPy Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.
Todas as aulas deste curso
- O acessador .str
- Dividindo e substituindo textos
- Correspondência de padrões com expressões regulares
- Combinando e limpando colunas de texto