Undersøke kolonners datatyper
Les dtypes-attributtet, skill mellom int64, float64 og object, og finn kolonner som trenger konvertering.
Undersøke kolonners datatyper er en gratis leksjon i Pandas & NumPy Academy på CoddyKit. Dette er leksjon 1 av 4. Du kan lese hele leksjonen gratis nedenfor – og deretter øve praktisk i nettleseren med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i Pandas & NumPy Academy, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i Pandas & NumPy Academy inneholder totalt 4 leksjoner.
Hvorfor kolonners datatyper er viktige
Hver kolonne i en Pandas DataFrame har en dtype (datatype) som bestemmer hvordan verdiene lagres i minnet, og hvilke operasjoner som er gyldige for dem. En heltallskolonne med dtype object (streng) kan ikke summeres. En dato som er lagret som en streng, behandles som tekst, ikke som en tidsserie. Feil dtypes er en av de vanligste årsakene til skjulte feil og uventede resultater i datapipelines.
Kontroller alltid dtypes som det aller første trinnet etter at et nytt datasett er lastet inn.
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: objectAttributtet dtypes
DataFrame.dtypes returnerer en Series med kolonnenavnene som indeks og Pandas-datatypen til hver kolonne som verdier. Vanlige dtypes du vil møte, er int64, float64, object (strenger og blandede typer), bool, datetime64[ns] og category. Dtypenavnet forteller både hva slags data det er, og hvor mange byte hver verdi bruker.
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: objectIdentifisere object-dtypen
Dtypen object er Pandas' samlebetegnelse for kolonner som ikke kan lagres som en numerisk type eller en boolsk type. Det betyr vanligvis strengdata, men kan også angi en kolonne med blandede typer (for eksempel heltall blandet med strenger). Object-kolonner bruker mer minne enn spesialiserte dtypes og er tregere å arbeide med. Når du ser object, bør du spørre: Skal dette være en streng, et tall, en kategori eller en dato?
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() for en fullstendig typeoversikt
df.info() skriver ut en kort tabell som viser navnet på hver kolonne, antallet verdier som ikke er null, og dtypen, i tillegg til totalt minneforbruk. Denne ene kommandoen gir deg et fullstendig øyeblikksbilde av datakvaliteten: Du kan samtidig se hvilke kolonner som har manglende data, og hvilke som har feil dtypes. Derfor er den standardkommandoen etter at et datasett er lastet inn.
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+ bytesVanlige dtype-problemer etter read_csv
Når Pandas leser en CSV-fil, utleder biblioteket dtypes ved å skanne verdiene. Flere vanlige problemer kan oppstå: numeriske kolonner leses som object hvis det finnes tusenskilletegn eller valutasymboler; boolske kolonner leses som object hvis de er lagret som strengene 'Yes'/'No'; og datokolonner leses som object fordi Pandas ikke tolker datoer med mindre du ber biblioteket om det. Når du kjenner igjen disse mønstrene, kan du raskt rette dem med typekonvertering.
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 boolMinnebruk for ulike dtypes
Ulike dtypes bruker svært forskjellige mengder minne. En int64-kolonne bruker 8 byte per verdi, mens en object-kolonne som lagrer korte strenger, kan bruke 50–200 byte per verdi. For DataFrames med millioner av rader kan riktig dtype redusere minnebruken fra gigabyte til megabyte. Kall df.memory_usage(deep=True) for å se bytekostnaden per kolonne.
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!Oppdage numeriske kolonner med feil datatype
Et vanlig problem er at en numerisk kolonne er lagret som object på grunn av overflødige formaterings tegn. Du kan oppdage dette ved å kontrollere om pd.to_numeric(df['col'], errors='coerce') gir et annet resultat enn den opprinnelige kolonnen. Verdier som ikke kan tolkes, blir til NaN, slik at du ser nøyaktig hvilke rader som førte til at typeutledningen mislyktes.
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' failedKontrollere tvetydighet mellom heltall og flyttall
Når en kolonne inneholder NaN-verdier, lagrer Pandas heltallskolonner som float64, fordi standardheltallstypene i NumPy ikke kan representere NaN. Det resulterende flyttallet, for eksempel 25.0, ser ut som et heltall, men lagres som et flyttall. Pandas introduserte heltallstyper som tillater manglende verdier (Int64 med stor I), som støtter NaN samtidig som heltallssemantikken bevares.
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) # Int64select_dtypes() for typebasert filtrering
df.select_dtypes(include=) lar deg velge alle kolonner i en bestemt typefamilie. Vanlige argumenter er 'number' (alle numeriske typer), 'object' (strenger), 'bool', 'datetime' og 'category'. Dette er svært nyttig i starten av en pipeline, slik at du kan bruke numerisk rensing bare på numeriske kolonner og strengrensing bare på tekstkolonner.
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']Bygge en dtype-rapport
En praktisk vane innen EDA er å lage en dtype-rapport som viser dtypen, antallet unike verdier og eksempelverdier for hver kolonne. Dette gjør det enklere å raskt identifisere kolonner som må konverteres før analysen begynner. Du kan generere en slik rapport med en enkel DataFrame som bygges fra aggregeringer på kolonnenivå.
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)dtype-konsistens i produksjonspipelines
I produksjonspipelines som behandler nye data hver dag, kan dtypes endre seg over tid – en kolonne som alltid har vært int64, kan komme inn som float64 hvis en enkelt NaN dukker opp. Legg til dtype-sjekker i starten av pipelinen for å oppdage endringer i skjemaet tidlig. Det er langt bedre å stoppe med en tydelig feilmelding enn å produsere feil resultater senere uten å varsle.
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')Hurtigsjekk
Test forståelsen din av hvordan du kontrollerer datatypene i kolonner.
Oppsummering av leksjonen
I denne leksjonen lærte du at df.dtypes viser typen til hver kolonne, at dtypen object er samlebetegnelsen for strenger og blandede typer, og at df.info() gir en fullstendig oversikt over typer og nullverdier. Bruk select_dtypes() til å filtrere kolonner etter typefamilie, og legg til dtype-sjekker for å oppdage endringer i skjemaet i produksjon. Neste steg er å konvertere kolonner til riktige dtypes ved hjelp av astype().
Lær deg Python med en AI-veileder – gratis
Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.
- Kurs
- 30
- Leksjoner
- 120
Ofte stilte spørsmål
Er leksjonen «Undersøke kolonners datatyper» gratis?
Ja – hele teksten i «Undersøke kolonners datatyper» er gratis å lese her på nettet. For å øve interaktivt med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt, og for å låse opp resten av Pandas & NumPy Academy-kurset, kan du oppgradere til CoddyKit PRO. Kurset i Pandas & NumPy Academy inneholder totalt 4 leksjoner.
Hva lærer jeg i «Undersøke kolonners datatyper»?
Les dtypes-attributtet, skill mellom int64, float64 og object, og finn kolonner som trenger konvertering. Du øver på Pandas & NumPy Academy med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.
Trenger jeg erfaring for å begynne med Pandas & NumPy Academy?
Ingen tidligere erfaring er nødvendig. Pandas & NumPy Academy på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 1 av 4.
Hvor lang tid tar leksjonen «Undersøke kolonners datatyper»?
De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.
Kan jeg skrive og kjøre kode i denne Pandas & NumPy Academy-leksjonen?
Ja. Alle Pandas & NumPy Academy-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.
Alle leksjonene i dette kurset
- Undersøke kolonners datatyper
- Typekonvertering med astype()
- Kategorisk datatype
- Tolke datoer riktig