Aggiunta ed eliminazione di colonne
Aggiunga nuove colonne calcolate, rinomini quelle esistenti ed elimini colonne o righe indesiderate con drop().
Aggiunta ed eliminazione di colonne è una lezione Pandas & NumPy Academy gratuita su CoddyKit. Questa è la lezione 3 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.
Aggiunta di una nuova colonna tramite assegnazione
Il modo più semplice per aggiungere una colonna è l'assegnazione diretta: df['new_col'] = values. Il membro a destra dell'assegnazione può essere uno scalare (distribuito su tutte le righe), una lista della stessa lunghezza, un array NumPy, una Series Pandas (allineata in base all'indice) oppure un'espressione calcolata che coinvolge colonne esistenti. Le nuove colonne vengono aggiunte a destra del DataFrame.
import pandas as pd
df = pd.DataFrame({'price': [10.0, 20.0, 15.0], 'qty': [3, 5, 2]})
df['revenue'] = df['price'] * df['qty']
df['currency'] = 'USD'
print(df)Feature engineering: colonne calcolate
Una delle operazioni più comuni sui DataFrame consiste nel creare feature derivate a partire da colonne esistenti. È possibile calcolare somme progressive, rapporti, flag o codificare valori categorici con una singola espressione vettorializzata. Queste colonne calcolate vengono aggiornate automaticamente quando cambiano le colonne di origine, se le ricalcola, rendendo le pipeline di feature engineering facili da riprodurre.
import pandas as pd
df = pd.DataFrame({'salary': [50000, 80000, 60000],
'bonus': [5000, 12000, 7000]})
df['total_comp'] = df['salary'] + df['bonus']
df['bonus_pct'] = (df['bonus'] / df['salary'] * 100).round(1)
print(df)Utilizzare assign() per concatenare metodi
df.assign(new_col=expression) restituisce un nuovo DataFrame con la colonna aggiunta, senza modificare l'originale. A differenza dell'assegnazione diretta, si integra naturalmente in una catena di metodi. È possibile aggiungere più colonne in una sola chiamata e le espressioni delle colonne successive possono fare riferimento alle colonne precedenti definite nella stessa chiamata a assign() usando funzioni lambda.
import pandas as pd
df = pd.DataFrame({'x': [1, 2, 3], 'y': [4, 5, 6]})
result = (df
.assign(sum_xy=lambda d: d['x'] + d['y'])
.assign(ratio=lambda d: d['x'] / d['sum_xy'])
)
print(result)Rinominare le colonne con rename()
df.rename(columns={'old': 'new'}) restituisce un nuovo DataFrame con le colonne rinominate. Passi un dict per rinominare colonne selezionate senza modificare le altre. È anche possibile rinominare tramite una funzione: df.rename(columns=str.upper) converte in maiuscolo tutti i nomi delle colonne. Rinomini sempre le colonne prima di unire DataFrame provenienti da origini diverse, per garantire l'allineamento delle colonne chiave.
import pandas as pd
df = pd.DataFrame({'a': [1, 2], 'b': [3, 4], 'c': [5, 6]})
renamed = df.rename(columns={'a': 'alpha', 'b': 'beta'})
print(renamed.columns.tolist()) # ['alpha', 'beta', 'c']
# Rename all columns to uppercase
print(df.rename(columns=str.upper).columns.tolist()) # ['A', 'B', 'C']Pulire i nomi delle colonne
I nomi delle colonne dei dati reali spesso contengono spazi, caratteri speciali o maiuscole e minuscole incoerenti. Un passaggio comune di pre-elaborazione consiste nel normalizzarli: rimuovere gli spazi superflui, convertirli in minuscolo e sostituire gli spazi con caratteri di sottolineatura. In questo modo le colonne diventano accessibili tramite la notazione con il punto e si evitano problemi di quoting nelle stringhe di query in stile SQL.
import pandas as pd
df = pd.DataFrame(columns=['First Name', 'Last Name', 'Email Address'])
df.columns = (df.columns
.str.strip()
.str.lower()
.str.replace(' ', '_', regex=False)
)
print(df.columns.tolist()) # ['first_name', 'last_name', 'email_address']Inserire una colonna in una posizione specifica
df.insert(loc, column, value) inserisce una colonna nella posizione intera loc, spostando a destra le altre colonne. È utile quando si desidera che la nuova colonna compaia accanto a colonne correlate anziché alla fine. Modifica il DataFrame in loco, a differenza di assign().
import pandas as pd
df = pd.DataFrame({'name': ['A', 'B'], 'score': [80, 90]})
df.insert(1, 'grade', ['B', 'A'])
print(df)
# name grade score
# 0 A B 80
# 1 B A 90Eliminare colonne con drop()
df.drop(columns=['col1', 'col2']) restituisce un nuovo DataFrame privo di quelle colonne. Anche la sintassi precedente df.drop(['col1', 'col2'], axis=1) funziona, ma è meno leggibile. Per eliminare le colonne in loco, passi inplace=True. Nelle pipeline, preferisca sempre restituire un nuovo DataFrame, così da conservare l'originale per confronti o ripristini.
import pandas as pd
df = pd.DataFrame({'a': [1,2], 'b': [3,4], 'c': [5,6], 'd': [7,8]})
cleaned = df.drop(columns=['b', 'd'])
print(cleaned.columns.tolist()) # ['a', 'c']Eliminare righe con drop()
df.drop(index=['r1', 'r2']) rimuove le righe in base all'etichetta. df.drop([0, 2]) rimuove le righe 0 e 2 da un indice intero predefinito. L'eliminazione delle righe viene comunemente usata per rimuovere record notoriamente errati, valori anomali o righe di test dopo la pulizia dei dati. Per le rimozioni basate su condizioni, preferisca l'indicizzazione booleana, che mantiene il codice leggibile.
import pandas as pd
df = pd.DataFrame({'x': [10, 20, 30, 40]}, index=['a', 'b', 'c', 'd'])
trimmed = df.drop(index=['b', 'd'])
print(trimmed)
# x
# a 10
# c 30pop() per rimuovere e restituire una colonna
df.pop('col') rimuove la colonna dal DataFrame in loco e la restituisce come Series. È utile quando occorre estrarre una colonna target (etichetta) da una matrice di feature: la si rimuove dal DataFrame e la si conserva separatamente per usarla come variabile y in un modello.
import pandas as pd
df = pd.DataFrame({'feature1': [1,2], 'feature2': [3,4], 'target': [0,1]})
y = df.pop('target') # removes column and returns as Series
X = df # remaining features
print(y.tolist()) # [0, 1]
print(X.columns.tolist()) # ['feature1', 'feature2']Riordinare le colonne
Per riordinare le colonne, le selezioni nell'ordine desiderato usando df[['col3', 'col1', 'col2']]. Per i DataFrame di grandi dimensioni, quando desidera spostare solo alcune colonne, calcoli l'ordine desiderato a livello programmatico: sposti le colonne prioritarie all'inizio e lasci seguire tutte le altre. Questo è un passaggio comune nella preparazione dei report prima dell'esportazione in Excel.
import pandas as pd
df = pd.DataFrame({'id': [1,2], 'score': [80,90], 'name': ['A','B']})
# Move 'name' and 'id' to front
cols = ['name', 'id'] + [c for c in df.columns if c not in ['name', 'id']]
df = df[cols]
print(df.columns.tolist()) # ['name', 'id', 'score']Aggiornare i valori di una colonna esistente
L'aggiornamento di tutti i valori di una colonna esistente usa la stessa sintassi di assegnazione dell'aggiunta di una nuova colonna: df['col'] = new_values. Usi df.loc[mask, 'col'] = value per aggiornare solo le righe che corrispondono a una condizione. Non usi mai l'indicizzazione concatenata per gli aggiornamenti: usi sempre .loc per evitare il SettingWithCopyWarning.
import pandas as pd
df = pd.DataFrame({'name': ['Alice', 'Bob', 'Carol'], 'score': [45, 80, 92]})
# Set scores below 50 to 50 (floor)
df.loc[df['score'] < 50, 'score'] = 50
print(df['score'].tolist()) # [50, 80, 92]Verifica rapida
Verifichi la sua comprensione dell'aggiunta e dell'eliminazione di colonne trattate in questa lezione.
Riepilogo della lezione
In questa lezione ha imparato che: le nuove colonne vengono aggiunte tramite assegnazione o tramite assign(), adatto alle catene di metodi, rename() modifica i nomi delle colonne senza alterare i dati e drop() rimuove colonne o righe e, per impostazione predefinita, restituisce un nuovo DataFrame. Ora useremo head(), tail(), info() e describe() per profilare rapidamente qualsiasi DataFrame.
Domande Frequenti
La lezione «Aggiunta ed eliminazione di colonne» è gratuita?
Sì — il testo completo di «Aggiunta ed eliminazione di colonne» è 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 «Aggiunta ed eliminazione di colonne»?
Aggiunga nuove colonne calcolate, rinomini quelle esistenti ed elimini colonne o righe indesiderate con drop(). 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 3 di 4.
Quanto tempo richiede la lezione «Aggiunta ed eliminazione di colonne»?
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