0Pricing
Pandas & NumPy Academy · Lección

Seleccionar columnas por patrón

Use filter(like=), filter(regex=) y las comprensiones de listas para seleccionar columnas cuyo nombre coincida con un patrón.

Seleccionar columnas por patrón es una lección gratuita de Pandas & NumPy Academy en CoddyKit. Esta es la lección 4 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é seleccionar columnas por patrón?

Los DataFrames procedentes de fuentes reales suelen tener decenas o cientos de columnas, y rara vez necesita todas. Cuando las columnas siguen una convención de nombres —prefijos como sales_, sufijos como _2023 o patrones basados en palabras clave—, seleccionarlas por patrón de nombre es mucho más fácil de mantener que enumerar cada columna explícitamente. Si cambia el esquema, la selección basada en patrones se adapta automáticamente.

Pandas proporciona dos herramientas principales: el método filter() y las comprensiones de listas sobre df.columns.

import pandas as pd

df = pd.DataFrame({
    'sales_jan': [100, 200],
    'sales_feb': [150, 250],
    'cost_jan': [50, 80],
    'cost_feb': [60, 90],
    'profit': [140, 280]
})

print(df.columns.tolist())
# ['sales_jan', 'sales_feb', 'cost_jan', 'cost_feb', 'profit']

filter(like=) para buscar subcadenas

DataFrame.filter(like='substring') selecciona las columnas cuyos nombres contienen la subcadena indicada en cualquier posición (distingue entre mayúsculas y minúsculas). De forma predeterminada, opera sobre el eje de columnas y devuelve un DataFrame nuevo que solo contiene las columnas coincidentes.

Esta es la herramienta más sencilla para seleccionar por patrón: no necesita conocimientos de expresiones regulares, solo una subcadena que buscar.

import pandas as pd

df = pd.DataFrame({
    'sales_jan': [100, 200],
    'sales_feb': [150, 250],
    'cost_jan': [50, 80],
    'revenue_q1': [110, 210]
})

# Select columns whose name contains 'sales'
sales_cols = df.filter(like='sales')
print(sales_cols)
#    sales_jan  sales_feb
# 0        100        150
# 1        200        250

filter(regex=) para buscar patrones

DataFrame.filter(regex='pattern') selecciona las columnas cuyos nombres coinciden con la expresión regular indicada. Es más potente que like=, ya que las expresiones regulares permiten buscar prefijos, sufijos, posiciones de dígitos o patrones complejos. La expresión regular se busca en cualquier posición del nombre de la columna (no está anclada al principio).

import pandas as pd

df = pd.DataFrame({
    'q1_revenue': [100],
    'q2_revenue': [200],
    'q1_cost': [40],
    'q2_cost': [60],
    'annual_total': [360]
})

# Select columns ending with '_revenue'
revenue_cols = df.filter(regex='_revenue$')
print(revenue_cols)
#    q1_revenue  q2_revenue
# 0         100         200

# Select columns starting with 'q' (quarter columns)
quarter_cols = df.filter(regex='^q')
print(quarter_cols.columns.tolist())
# ['q1_revenue', 'q2_revenue', 'q1_cost', 'q2_cost']

Comprensión de listas sobre df.columns

Para obtener la máxima flexibilidad, itere sobre df.columns con una comprensión de listas y aplique cualquier método de cadenas de Python para crear la lista de columnas. Esto funciona con startswith, endswith, contains, comprobaciones de longitud de cadenas o cualquier lógica personalizada que una expresión regular no pueda expresar por sí sola.

import pandas as pd

df = pd.DataFrame({
    'age': [25, 30],
    'age_group': ['young', 'mid'],
    'income': [50000, 70000],
    'income_tax': [8000, 12000],
    'name': ['Alice', 'Bob']
})

# Select columns that start with 'income'
income_cols = [c for c in df.columns if c.startswith('income')]
print(df[income_cols])
#    income  income_tax
# 0   50000        8000
# 1   70000       12000

Selección por sufijo del nombre de columna

El método str.endswith() del Index de columnas es la forma más clara de seleccionar columnas por sufijo. Los objetos Index de Pandas admiten métodos de acceso .str, por lo que puede aplicar operaciones de cadenas a todos los nombres de columnas a la vez y usar la matriz booleana resultante para seleccionar una parte del DataFrame.

import pandas as pd

df = pd.DataFrame({
    'revenue_2022': [100],
    'cost_2022': [40],
    'revenue_2023': [150],
    'cost_2023': [55],
    'notes': ['ok']
})

# Use Index.str.endswith for suffix selection
cols_2023 = df.columns[df.columns.str.endswith('_2023')]
print(df[cols_2023])
#    revenue_2023  cost_2023
# 0           150         55

Eliminación de columnas por patrón

A veces es más sencillo excluir un conjunto de columnas que indicar los nombres que desea conservar. Combine la selección por patrón con drop() o use el complemento: cree una lista de las columnas que desea eliminar y, después, llame a df.drop(columns=cols_to_drop). Como alternativa, obtenga las columnas que no desea y páselas a drop.

import pandas as pd

df = pd.DataFrame({
    'id': [1, 2],
    'name': ['A', 'B'],
    'temp_col1': [0, 0],
    'temp_col2': [0, 0],
    'score': [90, 80]
})

# Drop columns whose name starts with 'temp_'
temp_cols = [c for c in df.columns if c.startswith('temp_')]
cleaned = df.drop(columns=temp_cols)
print(cleaned)
#    id name  score
# 0   1    A     90
# 1   2    B     80

Selección de columnas numéricas con select_dtypes

Cuando desea columnas de un tipo de datos concreto en lugar de un patrón de nombres, utilice df.select_dtypes(include=). Pasar include='number' selecciona todas las columnas numéricas (enteras y de coma flotante), include='object' selecciona las columnas de texto y include='datetime' selecciona las columnas de fecha y hora.

Esto resulta especialmente útil antes de aplicar agregaciones numéricas: así nunca ejecutará accidentalmente mean() sobre una columna de texto.

import pandas as pd

df = pd.DataFrame({
    'name': ['Alice', 'Bob'],
    'age': [25, 30],
    'salary': [50000.0, 70000.0],
    'dept': ['Eng', 'HR']
})

# Select only numeric columns
numeric_df = df.select_dtypes(include='number')
print(numeric_df)
#    age   salary
# 0   25  50000.0
# 1   30  70000.0

# Exclude numeric columns
text_df = df.select_dtypes(exclude='number')
print(text_df)
#     name dept
# 0  Alice  Eng
# 1    Bob   HR

filter() en el índice de filas con axis=0

De forma predeterminada, filter() opera sobre las columnas (axis=1). Sin embargo, también puede filtrar filas por etiqueta de índice pasando axis=0. Esto resulta útil cuando su DataFrame tiene etiquetas de índice de texto significativas y desea seleccionar las filas cuya etiqueta de índice coincide con un patrón: un recurso menos habitual, pero práctico.

import pandas as pd

df = pd.DataFrame({
    'value': [10, 20, 30, 40]
}, index=['alpha_a', 'beta_b', 'alpha_c', 'gamma_d'])

# Filter rows by index label pattern
alpha_rows = df.filter(like='alpha', axis=0)
print(alpha_rows)
#          value
# alpha_a     10
# alpha_c     30

Combinación de patrones de selección de columnas

Las tareas reales de selección de columnas suelen combinar varias estrategias: primero se utiliza una expresión regular para encontrar un conjunto inicial y después se aplica un filtrado adicional con una comprensión de listas. Crear la lista de columnas paso a paso e inspeccionarla antes de hacer el slicing evita errores silenciosos, como eliminar accidentalmente columnas necesarias o incluir otras no deseadas.

import pandas as pd

df = pd.DataFrame(columns=[
    'user_id', 'user_name', 'user_email',
    'product_id', 'product_name', 'product_price',
    'order_total', 'order_date'
])

# Step 1: columns that start with 'user_' or 'order_'
step1 = [c for c in df.columns if c.startswith('user_') or c.startswith('order_')]

# Step 2: exclude email (PII)
final_cols = [c for c in step1 if 'email' not in c]
print(final_cols)
# ['user_id', 'user_name', 'order_total', 'order_date']

Reordenación de columnas mediante patrones

La selección basada en patrones también resulta útil para reordenar columnas. Seleccione primero las columnas que desea (por ejemplo, el ID y los metadatos) y después añada las columnas restantes en un orden específico. Reordenar las columnas facilita la lectura de los DataFrames y garantiza que los resultados tengan una estructura coherente.

import pandas as pd
import numpy as np

df = pd.DataFrame({
    'metric_b': [1], 'metric_a': [2],
    'id': [10], 'label': ['x'],
    'metric_c': [3]
})

# Put id and label first, then sort metric columns alphabetically
id_cols = ['id', 'label']
metric_cols = sorted([c for c in df.columns if c.startswith('metric')])
ordered = df[id_cols + metric_cols]
print(ordered.columns.tolist())
# ['id', 'label', 'metric_a', 'metric_b', 'metric_c']

Ejemplo práctico: datos de encuestas anchos

Un caso de uso clásico de la selección por patrones es un conjunto de datos de encuestas ancho, en el que cada pregunta genera varias columnas, como q1_score, q1_text, q2_score, etc. Puede extraer todas las columnas de puntuaciones con una sola expresión regular, calcular su media y mantener las columnas de análisis separadas de las respuestas de texto libre.

import pandas as pd

survey = pd.DataFrame({
    'respondent_id': [1, 2, 3],
    'q1_score': [4, 3, 5],
    'q2_score': [3, 4, 4],
    'q3_score': [5, 5, 3],
    'q1_comment': ['good', 'ok', 'great'],
    'q2_comment': ['fine', 'nice', 'meh']
})

# All score columns
score_cols = survey.filter(regex='_score$').columns
survey['avg_score'] = survey[score_cols].mean(axis=1)
print(survey[['respondent_id', 'avg_score']])
#    respondent_id  avg_score
# 0              1   4.000000
# 1              2   4.000000
# 2              3   4.000000

Comprobación rápida

Compruebe si comprende cómo seleccionar columnas mediante patrones.

Resumen de la lección

En esta lección ha aprendido lo siguiente: filter(like=) selecciona las columnas que contienen una subcadena, filter(regex=) utiliza expresiones regulares para realizar coincidencias flexibles con patrones y las comprensiones de listas sobre df.columns, junto con los métodos de cadenas de Python, ofrecen la máxima flexibilidad. Utilice select_dtypes() para seleccionar por tipo de datos. A continuación, aprenderemos a detectar valores ausentes (NaN) en los DataFrames.

Preguntas frecuentes

¿La lección «Seleccionar columnas por patrón» es gratis?

Sí — el texto completo de «Seleccionar columnas por patrón» 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 «Seleccionar columnas por patrón»?

Use filter(like=), filter(regex=) y las comprensiones de listas para seleccionar columnas cuyo nombre coincida con un patrón. 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 4 de 4.

¿Cuánto tiempo toma la lección «Seleccionar columnas por patrón»?

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. Indexación booleana en DataFrames
  2. El método query()
  3. Filtros isin() y between()
  4. Seleccionar columnas por patrón
← Volver a Pandas & NumPy Academy