0Pricing
Pandas & NumPy Academy · Lezione

Esaminare i tipi di dati delle colonne

Legga l'attributo dtypes, distingua int64 da float64 e object e individui le colonne che richiedono una conversione.

Esaminare i tipi di dati delle colonne è una lezione Pandas & NumPy Academy gratuita su CoddyKit. Questa è la lezione 1 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é i tipi di dati delle colonne sono importanti

Ogni colonna di un DataFrame Pandas ha un dtype (tipo di dati) che determina come vengono archiviati i valori in memoria e quali operazioni sono valide su di essi. Una colonna di interi con dtype object (stringa) non può essere sommata. Una data archiviata come stringa viene trattata come testo, non come serie temporale. I dtype errati sono tra le cause più comuni di bug silenziosi e risultati imprevisti nelle pipeline di analisi dei dati.

Controlli sempre i dtype come primissimo passaggio dopo aver caricato un nuovo dataset.

import pandas as pd
import numpy as np

df = pd.DataFrame({
    'age': ['25', '30', '35'],      # looks like int, stored as object
    'salary': [50000, 60000, 70000], # int64
    'hired': ['2022-01-01', '2023-06-15', '2024-03-10']  # looks like date
})

print(df.dtypes)
# age       object
# salary     int64
# hired     object
# dtype: object

L'attributo dtypes

DataFrame.dtypes restituisce una Series il cui indice contiene i nomi delle colonne e i cui valori sono i dtype Pandas di ciascuna colonna. I dtype più comuni che incontrerà sono int64, float64, object (stringhe e dati misti), bool, datetime64[ns] e category. Il nome del dtype indica sia il tipo di dati sia quanti byte utilizza ciascun valore.

import pandas as pd
import numpy as np

df = pd.DataFrame({
    'int_col': [1, 2, 3],
    'float_col': [1.5, 2.5, 3.5],
    'str_col': ['a', 'b', 'c'],
    'bool_col': [True, False, True]
})

print(df.dtypes)
# int_col      int64
# float_col  float64
# str_col     object
# bool_col      bool
# dtype: object

Identificare il dtype object

Il dtype object è il tipo generico di Pandas per le colonne che non possono essere archiviate come tipo numerico o booleano. In genere indica dati stringa, ma può anche indicare una colonna con tipi misti (ad esempio, interi mescolati a stringhe). Le colonne object consumano più memoria rispetto ai dtype specializzati e sono più lente nelle operazioni. Quando vede object, si chieda: dovrebbe essere una stringa, un numero, una categoria o una data?

import pandas as pd

df = pd.DataFrame({'mixed': [1, 'two', 3.0, None]})
print(df.dtypes)
# mixed    object

# Check actual Python types inside the column
print(df['mixed'].apply(type).value_counts())
# <class 'int'>      1
# <class 'str'>      1
# <class 'float'>    2  (includes NaN which is float)

info() per una panoramica completa dei tipi

df.info() stampa una tabella concisa che mostra il nome di ogni colonna, il numero di valori non null e il dtype, oltre all'utilizzo totale della memoria. Questo singolo comando offre una panoramica completa della qualità del dataset: può vedere contemporaneamente quali colonne contengono dati mancanti e quali hanno dtype errati, perciò è il comando standard da eseguire per primo dopo aver caricato un dataset.

import pandas as pd
import numpy as np

df = pd.DataFrame({
    'id': [1, 2, 3],
    'score': [88.5, 92.0, np.nan],
    'grade': ['A', 'A', 'B']
})

df.info()
# <class 'pandas.core.frame.DataFrame'>
# RangeIndex: 3 entries, 0 to 2
# Data columns (total 3 columns):
#  #   Column  Non-Null Count  Dtype
# ---  ------  --------------  -----
#  0   id      3 non-null      int64
#  1   score   2 non-null      float64
#  2   grade   3 non-null      object
# dtypes: float64(1), int64(1), object(1)
# memory usage: 200.0+ bytes

Problemi comuni con i dtype dopo read_csv

Quando Pandas legge un file CSV, deduce i dtype analizzando i valori. Possono verificarsi diversi problemi comuni: le colonne numeriche vengono lette come object se contengono separatori delle migliaia o simboli di valuta; le colonne booleane vengono lette come object se sono archiviate come stringhe 'Yes'/'No'; e le colonne di date vengono lette come object perché Pandas non analizza le date automaticamente. Riconoscere questi schemi consente di correggerli rapidamente convertendo i tipi.

import pandas as pd
import io

csv = '''price,date,is_active
'1,200',2024-01-15,Yes
'800',2024-02-20,No
'''

df = pd.read_csv(io.StringIO(csv))
print(df.dtypes)
# price       object    <- should be int
# date        object    <- should be datetime64
# is_active   object    <- should be bool

Utilizzo della memoria dei diversi dtype

Quantità di memoria molto diverse vengono utilizzate da dtype diversi. Una colonna int64 usa 8 byte per valore, mentre una colonna object che contiene stringhe brevi può usare 50-200 byte per valore. Nei DataFrame con milioni di righe, scegliere il dtype corretto può ridurre l'uso della memoria da gigabyte a megabyte. Chiami df.memory_usage(deep=True) per visualizzare il costo in byte di ogni colonna.

import pandas as pd
import numpy as np

df = pd.DataFrame({
    'int64_col': np.arange(1_000_000, dtype='int64'),
    'float32_col': np.arange(1_000_000, dtype='float32'),
    'obj_col': ['a'] * 1_000_000
})

mem = df.memory_usage(deep=True) / 1024**2  # MB
print(mem.round(2))
# Index         0.00
# int64_col     7.63
# float32_col   3.81
# obj_col      55.26  <- much more for object!

Individuare le colonne numeriche con tipo errato

Un problema comune è una colonna numerica archiviata come object a causa di caratteri di formattazione estranei. Può rilevarlo verificando se pd.to_numeric(df['col'], errors='coerce') produce un risultato diverso da quello della colonna originale. I valori che non possono essere analizzati diventano NaN, mostrando esattamente quali righe hanno causato il fallimento dell'inferenza del tipo.

import pandas as pd

df = pd.DataFrame({'revenue': ['1000', '2000', '$3000', '4,000']})

# Check which values can't be parsed as numbers
parsed = pd.to_numeric(df['revenue'], errors='coerce')
print(parsed)
# 0    1000.0
# 1    2000.0
# 2       NaN   <- '$3000' failed
# 3       NaN   <- '4,000' failed

Verificare l'ambiguità tra intero e float

Quando una colonna contiene anche un solo valore NaN, Pandas archivia le colonne intere come float64, perché i tipi interi standard di NumPy non possono rappresentare NaN. I float risultanti, come 25.0, sembrano interi ma sono archiviati come numeri in virgola mobile. Pandas ha introdotto i tipi interi nullable (Int64 con la I maiuscola), che supportano NaN mantenendo la semantica degli interi.

import pandas as pd
import numpy as np

df = pd.DataFrame({'count': [1, 2, np.nan, 4]})
print(df['count'].dtype)  # float64 — because NaN is float

# Nullable integer type supports NaN
df['count'] = df['count'].astype('Int64')  # capital I!
print(df)
#    count
# 0      1
# 1      2
# 2   <NA>
# 3      4
print(df['count'].dtype)  # Int64

select_dtypes() per il filtraggio basato sul tipo

df.select_dtypes(include=) consente di selezionare tutte le colonne appartenenti a una determinata famiglia di tipi. Argomenti comuni: 'number' (tutti i tipi numerici), 'object' (stringhe), 'bool', 'datetime', 'category'. È molto utile all'inizio di una pipeline per applicare la pulizia numerica solo alle colonne numeriche e la pulizia delle stringhe solo alle colonne di testo.

import pandas as pd

df = pd.DataFrame({
    'name': ['Alice', 'Bob'],
    'age': [25, 30],
    'salary': [50000.0, 70000.0],
    'dept': ['Eng', 'HR']
})

numeric = df.select_dtypes(include='number')
print('Numeric columns:', numeric.columns.tolist())
# ['age', 'salary']

text = df.select_dtypes(include='object')
print('Text columns:', text.columns.tolist())
# ['name', 'dept']

Creare un report dei dtype

Una pratica utile nell'EDA consiste nel creare un report dei dtype che elenchi il dtype di ogni colonna, il numero di valori distinti e alcuni valori di esempio. Questo aiuta a individuare rapidamente le colonne che devono essere convertite prima di iniziare l'analisi. È possibile generare un report di questo tipo con un semplice DataFrame costruito a partire da aggregazioni per colonna.

import pandas as pd
import numpy as np

df = pd.DataFrame({
    'age': [25, 30, 35],
    'salary': [50000, 60000, 70000],
    'dept': ['Eng', 'HR', 'Eng'],
    'hired': ['2022-01-01', '2023-06-15', '2024-03-10']
})

report = pd.DataFrame({
    'dtype': df.dtypes,
    'unique_count': df.nunique(),
    'sample': df.iloc[0]
})
print(report)

Coerenza dei dtype nelle pipeline di produzione

Nelle pipeline di produzione che elaborano nuovi dati ogni giorno, i dtype possono cambiare: una colonna che era sempre int64 potrebbe arrivare come float64 se compare un singolo NaN. Aggiunga asserzioni sui dtype all'inizio della pipeline per rilevare tempestivamente le modifiche allo schema. Generare un errore chiaro è molto meglio che produrre silenziosamente risultati errati nelle fasi successive.

import pandas as pd

df = pd.DataFrame({'user_id': [1, 2, 3], 'score': [88.0, 92.0, 76.0]})

expected_dtypes = {'user_id': 'int64', 'score': 'float64'}

for col, expected in expected_dtypes.items():
    actual = str(df[col].dtype)
    assert actual == expected, (
        f'Column {col}: expected {expected}, got {actual}'
    )
print('All dtypes are correct')

Verifica rapida

Verifichi la Sua comprensione del controllo dei tipi di dati delle colonne.

Riepilogo della lezione

In questa lezione ha imparato che: df.dtypes mostra il tipo di ogni colonna, il dtype object è il tipo generico per stringhe e tipi misti e df.info() offre una panoramica completa dei tipi e della presenza di valori null. Utilizzi select_dtypes() per filtrare le colonne in base alla famiglia di tipi e aggiunga asserzioni sui dtype per rilevare il cambiamento dello schema in produzione. Ora convertiremo le colonne nei dtype corretti usando astype().

Domande Frequenti

La lezione «Esaminare i tipi di dati delle colonne» è gratuita?

Sì — il testo completo di «Esaminare i tipi di dati delle 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 «Esaminare i tipi di dati delle colonne»?

Legga l'attributo dtypes, distingua int64 da float64 e object e individui le colonne che richiedono una conversione. 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 1 di 4.

Quanto tempo richiede la lezione «Esaminare i tipi di dati delle 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

  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