0Pricing
Pandas & NumPy Academy · Lección

Coincidencia de patrones con regex

Extraiga subcadenas y compruebe patrones con .str.extract(), .str.contains() y .str.match() mediante expresiones regulares.

Coincidencia de patrones con regex es una lección gratuita de Pandas & NumPy Academy en CoddyKit. Esta es la lección 3 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Pandas & NumPy Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Pandas & NumPy Academy incluye 4 lecciones en total.

¿Por qué usar regex en Pandas?

Las expresiones regulares (regex) son un lenguaje para describir patrones de cadenas. En Pandas, el accessor .str expone regex mediante contains(), match(), extract(), findall() y replace(). Regex es la herramienta adecuada cuando sus patrones son demasiado complejos para comprobaciones simples con contains/startswith; por ejemplo, para validar formatos de correo electrónico, extraer números de teléfono de texto libre o encontrar todos los importes en dólares de una columna de notas.

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 regex

.str.contains(pattern) con regex=True (el valor predeterminado) devuelve una Serie booleana que es True dondequiera que el patrón coincida en alguna parte de la cadena. Utilice anclas como ^ (inicio) y $ (final) para restringir dónde puede producirse la coincidencia. Un uso habitual es filtrar las filas cuyo campo cumple un requisito de formato, como un patrón de fecha válido o un código con el formato correcto.

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 coincidencias ancladas

.str.match(pattern) comprueba si cada cadena comienza por el patrón (está anclado al principio). Esta es la diferencia con contains(), que busca en cualquier parte de la cadena. Utilice match() cuando solo le interese el prefijo de la cadena y fullmatch() cuando toda la cadena deba coincidir con el patrón.

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) utiliza grupos de captura () en el patrón regex para extraer partes específicas de las cadenas coincidentes. Devuelve un DataFrame con una columna por cada grupo de captura. Solo devuelve la primera coincidencia de cada cadena. Es perfecto para extraer datos estructurados incrustados en texto libre, como valores numéricos, fechas o 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-04

Grupos de captura con nombre

Puede asignar nombres a los grupos de captura mediante la sintaxis (?P<name>...). Cuando utiliza grupos con nombre con str.extract(), el DataFrame resultante utiliza automáticamente esos nombres como encabezados de columna, lo que hace que el resultado sea autoexplicativo sin necesidad de cambiar los nombres de las columnas posteriormente.

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 varias coincidencias

.str.extractall(pattern) encuentra todas las coincidencias del patrón en cada cadena, no solo la primera. Devuelve un DataFrame con un MultiIndex: el nivel externo es el índice de la fila original y el nivel interno (match) cuenta las coincidencias de cada fila. Resulta útil para extraer todos los números, las URL o las palabras clave de campos de texto libre.

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 obtener una lista de coincidencias

.str.findall(pattern) devuelve una Serie de listas, donde cada lista contiene todas las coincidencias encontradas en la cadena de esa fila. A diferencia de extractall(), no crea un MultiIndex; cada fila recibe una lista de coincidencias. Esto resulta práctico cuando desea mantener los resultados en una estructura plana o contar las coincidencias por fila.

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

Coincidencias sin distinguir mayúsculas con re.IGNORECASE

De forma predeterminada, las regex en Pandas distinguen entre mayúsculas y minúsculas. Pase flags=re.IGNORECASE (o re.I) para que el patrón no distinga entre mayúsculas y minúsculas. Así no tendrá que escribir patrones de alternancia como [Pp][Yy][Tt][Hh][Oo][Nn] cuando quiera que 'python', 'Python' y 'PYTHON' coincidan por igual.

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

Validar formatos con coincidencia completa

.str.fullmatch(pattern) (añadido en Pandas 1.1) devuelve True solo cuando coincide la cadena completa con el patrón. A diferencia de contains(), que coincide con una subcadena, fullmatch equivale a anclar el patrón con ^...$. Esta es la forma más segura de validar el cumplimiento de un formato: direcciones de correo electrónico, números de teléfono, códigos postales o cualquier campo con un esquema estricto.

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

Reemplazar con referencias inversas de regex

Al utilizar str.replace(pattern, repl, regex=True), la cadena de reemplazo puede incluir referencias inversas como r'\1' para hacer referencia al contenido capturado en el primer grupo (). Esto permite realizar reformateos avanzados, como cambiar MM/DD/YYYY a YYYY-MM-DD o envolver una palabra coincidente en etiquetas 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

Crear un extractor de datos basado en regex

Aquí tiene un ejemplo práctico de principio a fin: extraer el SKU y el precio de un producto de una columna de notas desordenada mediante grupos con nombre. Este tipo de extracción es habitual al importar datos de sistemas heredados en los que varios campos se concatenaron en un ú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    NaN

Comprobación rápida

Compruebe su comprensión de la búsqueda de patrones con regex en Pandas.

Resumen de la lección

En esta lección ha aprendido que str.contains(regex) filtra las filas por patrón, str.extract() captura la primera coincidencia en una columna de DataFrame (utilice grupos con nombre para obtener resultados autoexplicativos), str.extractall() encuentra todas las coincidencias de cada fila mediante un MultiIndex y str.fullmatch() valida que toda la cadena cumpla un patrón. A continuación, combinará y limpiará varias columnas de texto.

Preguntas frecuentes

¿La lección «Coincidencia de patrones con regex» es gratis?

Sí — el texto completo de «Coincidencia de patrones con regex» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Pandas & NumPy Academy, actualiza a CoddyKit PRO. El curso de Pandas & NumPy Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Coincidencia de patrones con regex»?

Extraiga subcadenas y compruebe patrones con .str.extract(), .str.contains() y .str.match() mediante expresiones regulares. Practicas Pandas & NumPy Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Pandas & NumPy Academy?

No se requiere experiencia previa. Pandas & NumPy Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 3 de 4.

¿Cuánto tiempo toma la lección «Coincidencia de patrones con regex»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Pandas & NumPy Academy?

Sí. Cada lección de Pandas & NumPy Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. El accessor .str
  2. Dividir y reemplazar cadenas
  3. Coincidencia de patrones con regex
  4. Combinar y limpiar columnas de texto
← Volver a Pandas & NumPy Academy