0Pricing
Pandas & NumPy Academy · Lezione

Selezione di colonne e righe

Selezioni una o più colonne con la notazione tra parentesi quadre e recuperi le righe per etichetta e posizione usando .loc e .iloc.

Selezione di colonne e righe è una lezione Pandas & NumPy Academy gratuita su CoddyKit. Questa è la lezione 2 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.

Selezione di una singola colonna

Acceda a una singola colonna tramite il nome usando la notazione tra parentesi df['col'], che restituisce una Series. Può anche usare la notazione con il punto df.col quando il nome della colonna è un identificatore Python valido e non contiene spazi. La notazione tra parentesi è sempre sicura; quella con il punto non funziona per i nomi che entrano in conflitto con i metodi del DataFrame, come count o mean.

import pandas as pd

df = pd.DataFrame({'name': ['Alice', 'Bob'], 'score': [90, 75]})
print(df['name'])     # Series
print(type(df['name']))  # pandas.core.series.Series

Selezione di più colonne

Per selezionare più colonne, passi un elenco di nomi di colonne tra parentesi: df[['col1', 'col2']]. Noti le doppie parentesi: la coppia esterna è l'operatore di indicizzazione, mentre quella interna crea un elenco Python. Il risultato è un DataFrame, non una Series. Questa tecnica viene usata comunemente per estrarre una matrice delle feature per il machine learning.

import pandas as pd

df = pd.DataFrame({'a': [1,2], 'b': [3,4], 'c': [5,6]})
subset = df[['a', 'c']]
print(type(subset))      # pandas.core.frame.DataFrame
print(subset)

.loc per selezionare righe e colonne

df.loc[row_label, col_label] seleziona i dati in base all'etichetta. Fornisca una singola etichetta, un elenco di etichette o uno slice sia per le righe sia per le colonne. df.loc[:, 'score'] seleziona tutte le righe della colonna 'score'. df.loc['r1':'r3', ['a', 'b']] seleziona le righe da r1 a r3 (estremi inclusi) per le colonne a e b.

import pandas as pd

df = pd.DataFrame({'x': [10,20,30], 'y': [40,50,60]},
                  index=['r1', 'r2', 'r3'])
print(df.loc['r2', 'x'])       # 20
print(df.loc['r1':'r2', 'y'])  # r1:40  r2:50

.iloc per la selezione posizionale

df.iloc[row_pos, col_pos] seleziona in base alla posizione intera, ignorando le etichette. Entrambi gli argomenti seguono le convenzioni degli slice Python, con estremi finali esclusi. df.iloc[:, 0] seleziona la prima colonna come Series. df.iloc[0:2, 1:3] seleziona un sotto-DataFrame rettangolare 2×2 dall'angolo in alto a sinistra.

import pandas as pd

df = pd.DataFrame({'a': [1,2,3], 'b': [4,5,6], 'c': [7,8,9]})
print(df.iloc[1, 2])        # 8  -- row 1, col 2
print(df.iloc[0:2, 0:2])   # top-left 2x2 sub-table

Selezione booleana delle righe

Passi a .loc una Series booleana (con lo stesso indice del DataFrame) per filtrare le righe. Costruisca la Series booleana a partire da una condizione su una colonna. Può combinare le condizioni con & e |. Questo è lo schema standard per il filtraggio nell'analisi dei dati con Pandas ed è molto più espressivo delle clausole WHERE di SQL per condizioni complesse su più colonne.

import pandas as pd

df = pd.DataFrame({'name': ['A','B','C','D'], 'score': [80,55,92,71]})
high = df.loc[df['score'] >= 70]
print(high)
#   name  score
# 0    A     80
# 2    C     92
# 3    D     71

Condizioni di filtraggio composte

Le condizioni multiple devono essere racchiuse singolarmente tra parentesi e combinate con & (AND) o | (OR). Usare le parole chiave Python and/or sulle Series genera un errore. Per negare una condizione, usi ~ (tilde) invece di not. Verifichi sempre le condizioni singolarmente prima di combinarle, così da isolare la causa di risultati imprevisti.

import pandas as pd

df = pd.DataFrame({'name': ['A','B','C','D'],
                   'score': [80, 55, 92, 71],
                   'dept': ['Eng', 'HR', 'Eng', 'HR']})
filtered = df.loc[(df['score'] >= 70) & (df['dept'] == 'Eng')]
print(filtered)

Selezione delle righe per posizione intera

df.iloc[n] restituisce l'n-esima riga come Series. df.iloc[n:m] restituisce le righe da n a m-1 come DataFrame. df.iloc[[0, 2, 4]] seleziona righe specifiche per posizione usando l'indicizzazione avanzata. Queste operazioni equivalgono alla selezione delle righe di un array NumPy e vengono spesso usate per dividere i dati in set di addestramento e di test prima di applicare modelli di machine learning.

import pandas as pd

df = pd.DataFrame({'a': range(5), 'b': range(5, 10)})
print(df.iloc[0])         # first row as Series
print(df.iloc[1:3])       # rows 1 and 2 as DataFrame
print(df.iloc[[0, 4]])    # first and last row

Combinazione della selezione di righe e colonne

Sia .loc sia .iloc accettano due argomenti: df.loc[row_selector, col_selector]. Ciò consente una selezione rettangolare precisa in un'unica espressione. Un due punti : da solo seleziona tutte le righe o tutte le colonne. Questo schema è essenziale per estrarre una matrice delle feature con colonne specifiche, limitatamente alle righe di addestramento di un dataset.

import pandas as pd

df = pd.DataFrame({'x': [1,2,3], 'y': [4,5,6], 'z': [7,8,9]})
# Filter rows where x > 1, keep columns y and z
result = df.loc[df['x'] > 1, ['y', 'z']]
print(result)
#    y  z
# 1  5  8
# 2  6  9

Selezione di una singola riga con .loc

Quando passa un'unica etichetta scalare a df.loc[label], il risultato è una Series il cui indice contiene i nomi delle colonne. È utile per esaminare un record specifico. Per ottenere invece un DataFrame con una sola riga, racchiuda l'etichetta in un elenco: df.loc[[label]]. La distinzione è importante quando si passano i risultati a funzioni che prevedono un DataFrame.

import pandas as pd

df = pd.DataFrame({'name': ['A','B'], 'score': [80, 90]},
                  index=['r1', 'r2'])
print(type(df.loc['r1']))    # Series
print(type(df.loc[['r1']])) # DataFrame

at e iat per un accesso scalare rapido

df.at[row_label, col_name] e df.iat[row_pos, col_pos] recuperano o impostano un singolo valore scalare con un sovraccarico minore rispetto a .loc/.iloc. Sono progettati per i cicli che aggiornano singole celle. Nel codice di produzione preferisca sempre le operazioni vettorializzate agli aggiornamenti cella per cella, ma usi at/iat quando deve effettivamente iterare.

import pandas as pd

df = pd.DataFrame({'x': [1, 2, 3], 'y': [4, 5, 6]},
                  index=['a', 'b', 'c'])
print(df.at['b', 'y'])    # 5
print(df.iat[2, 0])       # 3

Avviso sull'indicizzazione concatenata

L'indicizzazione concatenata, come df['col'][condition] o df[mask]['col'] = val, può produrre un SettingWithCopyWarning perché Pandas potrebbe operare su una copia anziché sull'originale. Usi sempre un'unica espressione .loc per qualsiasi modifica: df.loc[mask, 'col'] = val. Questo è lo schema corretto, senza avvisi.

import pandas as pd

df = pd.DataFrame({'score': [80, 55, 92]})
# WRONG - may not modify original:
# df[df['score'] > 60]['score'] = 100

# CORRECT:
df.loc[df['score'] > 60, 'score'] = 100
print(df)

Verifica rapida

Verifichi la Sua comprensione della selezione di colonne e righe presentata in questa lezione.

Riepilogo della lezione

In questa lezione ha imparato che: .loc seleziona righe e colonne per etichetta, includendo l'estremo finale degli slice, .iloc seleziona per posizione intera, con estremi finali esclusi come negli slice Python e le condizioni booleane applicate tramite .loc filtrano le righe senza il problema del SettingWithCopyWarning causato dall'indicizzazione concatenata. Ora aggiungeremo nuove colonne calcolate, rinomineremo quelle esistenti e rimuoveremo le colonne indesiderate con drop().

Domande Frequenti

La lezione «Selezione di colonne e righe» è gratuita?

Sì — il testo completo di «Selezione di colonne e righe» è 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 «Selezione di colonne e righe»?

Selezioni una o più colonne con la notazione tra parentesi quadre e recuperi le righe per etichetta e posizione usando .loc e .iloc. 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 2 di 4.

Quanto tempo richiede la lezione «Selezione di colonne e righe»?

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. Creazione di DataFrame
  2. Selezione di colonne e righe
  3. Aggiunta ed eliminazione di colonne
  4. Ispezione di base dei DataFrame
← Torna a Pandas & NumPy Academy