0Pricing
Pandas & NumPy Academy · Lezione

Selezionare colonne in base a un pattern

Usi filter(like=), filter(regex=) e le list comprehension per selezionare le colonne il cui nome corrisponde a un pattern.

Selezionare colonne in base a un pattern è una lezione Pandas & NumPy Academy gratuita su CoddyKit. Questa è la lezione 4 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é selezionare le colonne in base a un modello?

I DataFrame provenienti da fonti reali contengono spesso decine o centinaia di colonne, e raramente sono necessarie tutte. Quando le colonne seguono una convenzione di denominazione, come prefissi quali sales_, suffissi quali _2023 o determinati modelli di parole chiave, selezionarle in base al modello del nome è molto più facile da mantenere rispetto all'elencazione esplicita di ogni colonna. Se lo schema cambia, la selezione basata sul modello si adatta automaticamente.

Pandas fornisce due strumenti principali: il metodo filter() e le list comprehension su 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=) per trovare una sottostringa

DataFrame.filter(like='substring') seleziona le colonne i cui nomi contengono la sottostringa indicata in una posizione qualsiasi del nome, distinguendo tra maiuscole e minuscole. Per impostazione predefinita opera sull'asse delle colonne e restituisce un nuovo DataFrame contenente solo le colonne corrispondenti.

È lo strumento più semplice per la selezione basata su modelli: non è necessaria alcuna conoscenza delle espressioni regolari, basta la sottostringa da cercare.

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=) per trovare un modello

DataFrame.filter(regex='pattern') seleziona le colonne i cui nomi corrispondono all'espressione regolare indicata. È più potente di like=, perché le espressioni regolari consentono di individuare prefissi, suffissi, posizioni di cifre o modelli complessi. L'espressione regolare viene confrontata in una posizione qualsiasi del nome della colonna, non solo all'inizio.

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']

List comprehension su df.columns

Per ottenere la massima flessibilità, iteri su df.columns con una list comprehension e applichi qualsiasi metodo Python per le stringhe, così da creare l'elenco delle colonne. Questo funziona con startswith, endswith, contains, controlli sulla lunghezza delle stringhe o qualsiasi logica personalizzata che le sole espressioni regolari non sono in grado di esprimere.

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

Selezionare in base al suffisso del nome della colonna

Il metodo str.endswith() dell'indice delle colonne è il modo più chiaro per selezionare le colonne in base al suffisso. Gli oggetti Index di Pandas supportano i metodi dell'accessor .str, quindi è possibile applicare operazioni sulle stringhe a tutti i nomi delle colonne contemporaneamente e usare l'array booleano risultante per filtrare il 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

Eliminare le colonne in base a un pattern

A volte è più semplice escludere un insieme di colonne invece di indicare quelle da mantenere. Combinate la selezione per pattern con drop() oppure usate il complemento: create un elenco delle colonne da eliminare, quindi chiamate df.drop(columns=cols_to_drop). In alternativa, ottenete le colonne che non volete mantenere e passatele 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

Selezionare le colonne numeriche con select_dtypes

Quando desiderate colonne di un determinato tipo di dati anziché corrispondenti a un pattern nel nome, usate df.select_dtypes(include=). Passando include='number' selezionate tutte le colonne numeriche (int e float), include='object' seleziona le colonne stringa e include='datetime' seleziona le colonne datetime.

È particolarmente utile prima di applicare aggregazioni numeriche: non chiamerete mai accidentalmente mean() su una colonna di testo.

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() sull'indice delle righe con axis=0

Per impostazione predefinita, filter() opera sulle colonne (axis=1). Tuttavia, potete anche filtrare le righe in base all'etichetta dell'indice passando axis=0. È utile quando il DataFrame ha etichette stringa significative per l'indice e desiderate selezionare le righe la cui etichetta dell'indice corrisponde a un pattern: un approccio meno comune, ma pratico.

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

Combinare i pattern di selezione delle colonne

Nelle attività reali di selezione delle colonne si combinano spesso più strategie: si usa una regex per trovare un insieme di base, quindi si applica un ulteriore filtro con una list comprehension. Creare l'elenco delle colonne in più passaggi e controllarlo prima del filtraggio evita errori silenziosi, come eliminare accidentalmente colonne necessarie o includere colonne indesiderate.

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']

Riordinare le colonne in base a un pattern

La selezione basata su pattern è utile anche per riordinare le colonne. Selezionate prima le colonne che desiderate (ad esempio ID e metadati), quindi aggiungete le colonne rimanenti in un ordine specifico. Riordinare le colonne rende i DataFrame più leggibili e garantisce che i risultati abbiano una struttura coerente.

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']

Esempio pratico: dati di un sondaggio in formato ampio

Un caso d'uso classico della selezione per pattern è un dataset di un sondaggio in formato ampio, in cui ogni domanda genera più colonne come q1_score, q1_text, q2_score e così via. Potete estrarre tutte le colonne dei punteggi con una sola regex, calcolarne la media e tenere separate le colonne per l'analisi dalle risposte a testo libero.

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

Verifica rapida

Verificate la vostra comprensione della selezione delle colonne in base a un pattern.

Riepilogo della lezione

In questa lezione avete imparato che: filter(like=) seleziona le colonne che contengono una sottostringa, filter(regex=) usa le espressioni regolari per una corrispondenza flessibile dei pattern e le list comprehension su df.columns con i metodi per le stringhe di Python offrono la massima flessibilità. Usate select_dtypes() per selezionare in base al tipo di dati. Nella prossima lezione vedremo come rilevare i valori mancanti (NaN) nei DataFrame.

Domande Frequenti

La lezione «Selezionare colonne in base a un pattern» è gratuita?

Sì — il testo completo di «Selezionare colonne in base a un pattern» è 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 «Selezionare colonne in base a un pattern»?

Usi filter(like=), filter(regex=) e le list comprehension per selezionare le colonne il cui nome corrisponde a un pattern. 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 4 di 4.

Quanto tempo richiede la lezione «Selezionare colonne in base a un pattern»?

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. Indicizzazione booleana dei DataFrame
  2. Il metodo query()
  3. Filtri isin() e between()
  4. Selezionare colonne in base a un pattern
← Torna a Pandas & NumPy Academy