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.SeriesSelezione 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-tableSelezione 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 71Condizioni 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 rowCombinazione 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 9Selezione 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']])) # DataFrameat 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]) # 3Avviso 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
- Creazione di DataFrame
- Selezione di colonne e righe
- Aggiunta ed eliminazione di colonne
- Ispezione di base dei DataFrame