0Pricing
Pandas & NumPy Academy · Lezione

Conversione con astype()

Converta le colonne in int, float, string, boolean e datetime usando astype() e gestisca gli errori di conversione più comuni.

Conversione con astype() è 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.

Introduzione a astype()

Series.astype(dtype) converte una colonna dal tipo corrente a quello specificato. Restituisce una nuova Series (o un DataFrame, quando viene chiamato su un DataFrame completo) senza modificare l'originale. È lo strumento principale di Pandas per correggere i problemi dei dtype dopo il caricamento dei dati e può convertire tra tipi numerici, stringhe, valori booleani e il tipo Categorical.

import pandas as pd

df = pd.DataFrame({'age': ['25', '30', '35']})
print('Before:', df['age'].dtype)  # object

df['age'] = df['age'].astype(int)
print('After:', df['age'].dtype)   # int64
print(df['age'] + 1)               # [26, 31, 36] — arithmetic now works

Conversione ai tipi numerici

La conversione più comune è da object a un tipo numerico. Può eseguire il cast a 'int64', 'int32', 'float64', 'float32' e così via. Se un valore della colonna non può essere convertito, astype() genera un ValueError. Utilizzi invece pd.to_numeric(series, errors='coerce') quando la colonna può contenere stringhe non numeriche: converte i valori errati in NaN invece di interrompere l'esecuzione con un errore.

import pandas as pd

df = pd.DataFrame({'price': ['10.5', '20.0', 'N/A', '30.5']})

# astype would crash on 'N/A'
# price_float = df['price'].astype(float)  # ValueError!

# pd.to_numeric with errors='coerce' is safer
df['price_float'] = pd.to_numeric(df['price'], errors='coerce')
print(df)
#   price  price_float
# 0  10.5         10.5
# 1  20.0         20.0
# 2   N/A          NaN
# 3  30.5         30.5

Conversione in stringa (object)

Il cast di una colonna a str (o 'object') converte ogni valore nella sua rappresentazione in formato stringa. È utile quando deve concatenare una colonna numerica con una colonna di testo o quando vuole applicare metodi per stringhe a dati numerici, ad esempio per aggiungere zeri iniziali agli ID. Pandas offre anche il più recente dtype 'string', che gestisce meglio i valori NA nelle colonne di testo.

import pandas as pd

df = pd.DataFrame({'id': [1, 2, 3], 'region': ['E', 'W', 'N']})

# Concatenate id and region into a composite key
df['key'] = df['id'].astype(str) + '_' + df['region']
print(df)
#    id region  key
# 0   1      E  1_E
# 1   2      W  2_W
# 2   3      N  3_N

Conversione in booleano

La conversione in booleano è utile quando le colonne memorizzano True/False come interi (0/1) o come stringhe ('Yes'/'No'). Il cast degli interi 0/1 con astype(bool) funziona direttamente: 0 diventa False, mentre qualsiasi valore diverso da zero diventa True. Per le colonne con stringhe 'Yes'/'No', esegua prima una mappatura con un dizionario, quindi applichi il cast.

import pandas as pd

df = pd.DataFrame({
    'active_int': [1, 0, 1, 0],
    'active_str': ['Yes', 'No', 'Yes', 'No']
})

# Integer to bool
df['active_bool'] = df['active_int'].astype(bool)

# String to bool via mapping
df['active_bool2'] = df['active_str'].map({'Yes': True, 'No': False})

print(df[['active_bool', 'active_bool2']])
#    active_bool  active_bool2
# 0         True          True
# 1        False         False

Riduzione dei tipi numerici

Per impostazione predefinita, Pandas utilizza tipi a 64 bit. Se i valori interi rientrano in 32 o persino 8 bit, può eseguire il downcast a un tipo più piccolo per dimezzare (o ridurre a un quarto) l'uso della memoria. Utilizzi pd.to_numeric(series, downcast='integer') oppure esegua esplicitamente il cast con astype('int32'). È un'ottimizzazione fondamentale per i dataset di grandi dimensioni.

import pandas as pd
import numpy as np

df = pd.DataFrame({'count': np.random.randint(0, 200, 1_000_000)})

print('int64 bytes:', df['count'].nbytes)   # 8,000,000

df['count_int16'] = df['count'].astype('int16')  # max 32767, fits 0-200
print('int16 bytes:', df['count_int16'].nbytes)  # 2,000,000

# Or let Pandas choose the smallest type automatically
df['count_auto'] = pd.to_numeric(df['count'], downcast='integer')
print('auto dtype:', df['count_auto'].dtype)

Convertire DataFrame completi con astype(dict)

Può convertire più colonne contemporaneamente passando un dizionario a df.astype(), in cui le chiavi sono i nomi delle colonne e i valori sono i dtype di destinazione. Questa soluzione è più chiara rispetto al concatenamento di assegnazioni a singole colonne e rende il passaggio di conversione dei tipi autoesplicativo come blocco unico della pipeline.

import pandas as pd

df = pd.DataFrame({
    'age': ['25', '30'],
    'salary': ['50000', '70000'],
    'is_manager': ['1', '0']
})

df = df.astype({
    'age': 'int32',
    'salary': 'float64',
    'is_manager': 'bool'
})
print(df.dtypes)
# age           int32
# salary      float64
# is_manager     bool

Gestire gli errori in astype()

astype() non dispone di una modalità integrata di gestione degli errori (a differenza di pd.to_numeric). Se una conversione non riesce, genera un ValueError o un OverflowError. Il flusso di lavoro sicuro è: (1) pulire prima la colonna (rimuovere i simboli, riempire i valori NaN), (2) eseguire quindi il cast. In alternativa, utilizzi pd.to_numeric(errors='coerce') per i valori numerici oppure scriva una piccola funzione di supporto che intercetti gli errori di conversione.

import pandas as pd

# Clean then cast pattern
df = pd.DataFrame({'price': ['$1,200', '$800', '$450']})

# Step 1: remove non-numeric characters
df['price_clean'] = (
    df['price']
    .str.replace('$', '', regex=False)
    .str.replace(',', '', regex=False)
)
# Step 2: safe cast
df['price_num'] = df['price_clean'].astype(float)
print(df)
#      price price_clean  price_num
# 0  $1,200        1200     1200.0
# 1    $800         800      800.0
# 2    $450         450      450.0

Eseguire il cast al tipo StringDtype di Pandas

Il più recente dtype 'string' (la variante con la S maiuscola o pd.StringDtype()) è stato introdotto per offrire un supporto nativo alle stringhe con una corretta gestione dei valori NA: memorizza le stringhe mancanti come pd.NA anziché None o np.nan. Abilita l'accessor .str preservando meglio la semantica dei valori NA rispetto al dtype object, ed è consigliato per il nuovo codice destinato a Pandas 2+.

import pandas as pd

df = pd.DataFrame({'name': ['Alice', None, 'Carol']})

# Convert to the modern string dtype
df['name'] = df['name'].astype('string')
print(df['name'].dtype)   # string
print(df['name'].isna())  # proper NA detection
# 0    False
# 1     True
# 2    False

Rischi di overflow durante il downcast

Quando esegue il downcast a un tipo intero più piccolo, i valori che superano l'intervallo del tipo vanno silenziosamente in overflow e ricominciano dal limite opposto. Ad esempio, la conversione di 300 in int8 (intervallo da -128 a 127) produce 44 senza generare errori. Verifichi sempre che l'intervallo effettivo dei dati rientri nel tipo di destinazione prima di eseguire il downcast, per evitare danneggiamenti difficili da individuare.

import pandas as pd
import numpy as np

df = pd.DataFrame({'value': [100, 200, 300, 127, 128]})

# int8 range: -128 to 127
df['value_i8'] = df['value'].astype('int8')
print(df)
#    value  value_i8
# 0    100       100
# 1    200       -56   <- overflow! 200-256 = -56
# 2    300        44   <- overflow! 300-256 = 44
# 3    127       127
# 4    128      -128   <- overflow!

# Always check range first
print(df['value'].max())  # 300 > 127 — int8 is UNSAFE here

Verificare le conversioni con una mappa dei dtype

Dopo aver eseguito più conversioni di tipo, convalidi lo schema finale confrontando i dtype effettivi con una mappa prevista. Questo schema di asserzione rileva errori come una colonna che non è stata convertita (ad esempio perché NaN ha impedito la conversione a intero). Esegua questi controlli al termine della funzione di caricamento dei dati, come test leggero dello schema.

import pandas as pd

df = pd.DataFrame({
    'user_id': [1, 2, 3],
    'amount': [10.5, 20.0, 30.5],
    'active': [True, False, True]
})

expected = {'user_id': 'int64', 'amount': 'float64', 'active': 'bool'}

for col, dtype in expected.items():
    assert str(df[col].dtype) == dtype, (
        f'{col}: expected {dtype}, got {df[col].dtype}'
    )
print('Schema validation passed')

Esempio di pipeline completa di conversione

Riunendo tutti gli elementi: ecco una pipeline realistica di conversione dopo read_csv, che pulisce la formattazione, gestisce NaN in modo sicuro, converte ai tipi ottimali e convalida il risultato. Questo schema — pulire, convertire, convalidare — dovrebbe essere una parte standard di ogni funzione di acquisizione dei dati.

import pandas as pd

raw = pd.DataFrame({
    'user_id': ['101', '102', '103'],
    'revenue': ['$1,200', '$800', '$2,500'],
    'active': ['Yes', 'No', 'Yes']
})

df = (
    raw
    .assign(
        user_id=raw['user_id'].astype('int32'),
        revenue=pd.to_numeric(
            raw['revenue'].str.replace('[$,]', '', regex=True)
        ),
        active=raw['active'].map({'Yes': True, 'No': False})
    )
)
print(df.dtypes)
# user_id      int32
# revenue    float64
# active        bool

Verifica rapida

Verifichi la Sua comprensione del cast con astype().

Riepilogo della lezione

In questa lezione ha imparato che: astype(dtype) converte una colonna o un intero DataFrame in un nuovo tipo, pd.to_numeric(errors='coerce') è più sicuro per le colonne con stringhe non numeriche e passare un dizionario a astype() consente di convertire più colonne contemporaneamente. Esegua il downcast con cautela per evitare overflow e convalidi sempre lo schema finale tramite asserzioni. Ora esploreremo il dtype Categorical, efficiente in termini di memoria.

Domande Frequenti

La lezione «Conversione con astype()» è gratuita?

Sì — il testo completo di «Conversione con astype()» è 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 «Conversione con astype()»?

Converta le colonne in int, float, string, boolean e datetime usando astype() e gestisca gli errori di conversione più comuni. 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 «Conversione con astype()»?

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. Esaminare i tipi di dati delle colonne
  2. Conversione con astype()
  3. Tipo di dati categorico
  4. Analizzare correttamente le date
← Torna a Pandas & NumPy Academy