Gegevenstypen van kolommen inspecteren
Lees het kenmerk dtypes, onderscheid int64 van float64 en object en herken kolommen die conversie nodig hebben.
Gegevenstypen van kolommen inspecteren is een gratis Pandas & NumPy Academy-les op CoddyKit. Dit is les 1 van 4. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Pandas & NumPy Academy. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Pandas & NumPy Academy bevat in totaal 4 lessen.
Waarom gegevenstypen van kolommen belangrijk zijn
Elke kolom in een Pandas DataFrame heeft een dtype (gegevenstype) die bepaalt hoe waarden in het geheugen worden opgeslagen en welke bewerkingen erop geldig zijn. Een integerkolom met dtype object (tekenreeks) kan niet worden opgeteld. Een datum die als tekenreeks is opgeslagen, wordt behandeld als tekst en niet als tijdreeks. Onjuiste dtypes zijn een van de meest voorkomende oorzaken van onopgemerkte fouten en onverwachte resultaten in gegevensanalysepijplijnen.
Controleer dtypes altijd als allereerste stap nadat je een nieuwe dataset hebt geladen.
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: objectHet dtypes-attribuut
DataFrame.dtypes retourneert een Series waarvan de indexnamen de kolomnamen zijn en waarvan de waarden het Pandas-dtype van elke kolom zijn. Veelvoorkomende dtypes die je tegenkomt zijn int64, float64, object (tekenreeksen en gemengde waarden), bool, datetime64[ns] en category. De naam van het dtype vertelt je zowel welk soort gegevens het betreft als hoeveel bytes elke waarde gebruikt.
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: objectHet dtype object herkennen
Het dtype object is Pandas' algemene type voor kolommen die niet als numeriek of booleaans type kunnen worden opgeslagen. Meestal betekent dit tekenreeksgegevens, maar het kan ook wijzen op een kolom met gemengde typen (bijvoorbeeld integers gemengd met tekenreeksen). Objectkolommen gebruiken meer geheugen dan gespecialiseerde dtypes en bewerkingen erop zijn langzamer. Als je object ziet, vraag je dan af: moet dit een tekenreeks, getal, categorie of datum zijn?
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() voor een volledig typeoverzicht
df.info() drukt een beknopte tabel af met de naam van elke kolom, het aantal niet-lege waarden en het dtype, plus het totale geheugengebruik. Met deze ene opdracht krijg je een volledig overzicht van de kwaliteit van de dataset: je ziet tegelijk welke kolommen ontbrekende gegevens hebben en welke onjuiste dtypes hebben. Daarom is dit de standaard eerste opdracht nadat je een dataset hebt geladen.
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+ bytesVeelvoorkomende dtype-problemen na read_csv
Wanneer Pandas een CSV-bestand leest, leidt het dtypes af door waarden te scannen. Daarbij ontstaan verschillende veelvoorkomende problemen: numerieke kolommen worden als object gelezen als er komma's als scheidingsteken voor duizendtallen of valutasymbolen aanwezig zijn; booleaanse kolommen worden als object gelezen als ze zijn opgeslagen als tekenreeksen zoals 'Yes'/'No'; en datumkolommen worden als object gelezen omdat Pandas datums niet parseert tenzij je dat expliciet aangeeft. Als je deze patronen herkent, kun je ze snel herstellen met typeconversie.
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 boolGeheugengebruik van verschillende dtypes
Verschillende dtypes gebruiken zeer uiteenlopende hoeveelheden geheugen. Een kolom met int64 gebruikt 8 bytes per waarde, terwijl een kolom met object waarin korte tekenreeksen staan mogelijk 50-200 bytes per waarde gebruikt. Voor DataFrames met miljoenen rijen kan het kiezen van het juiste dtype het geheugengebruik terugbrengen van gigabytes naar megabytes. Roep df.memory_usage(deep=True) aan om de kosten in bytes per kolom te bekijken.
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!Numerieke kolommen met het verkeerde type herkennen
Een veelvoorkomend probleem is een numerieke kolom die als object is opgeslagen vanwege losse opmaaktekens. Je kunt dit herkennen door te controleren of pd.to_numeric(df['col'], errors='coerce') een ander resultaat oplevert dan de oorspronkelijke kolom. Waarden die niet kunnen worden geparseerd, worden NaN, waardoor precies zichtbaar wordt welke rijen ervoor zorgden dat de type-inferentie mislukte.
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' failedOnduidelijkheid tussen integer en float controleren
Als een kolom NaN-waarden bevat, slaat Pandas integerkolommen op als float64, omdat de standaard integertypen van NumPy NaN niet kunnen weergeven. De resulterende floats zoals 25.0 zien eruit als integers, maar worden als floats opgeslagen. Pandas introduceerde nullable integertypen (Int64 met een hoofdletter I), die NaN ondersteunen en tegelijk de semantiek van integers behouden.
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() voor filteren op type
Met df.select_dtypes(include=) kun je alle kolommen van een bepaalde typefamilie selecteren. Veelgebruikte argumenten zijn: 'number' (alle numerieke kolommen), 'object' (tekenreeksen), 'bool', 'datetime' en 'category'. Dit is erg nuttig aan het begin van een pijplijn: je kunt numerieke opschoning alleen op numerieke kolommen toepassen en opschoning van tekenreeksen alleen op tekstkolommen.
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']Een dtype-rapport maken
Een praktische gewoonte bij EDA is het maken van een dtype-rapport met het dtype, het aantal unieke waarden en voorbeeldwaarden van elke kolom. Zo herken je snel welke kolommen vóór de analyse moeten worden geconverteerd. Je kunt zo'n rapport genereren met een eenvoudig DataFrame dat je op basis van aggregaties per kolom opbouwt.
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)Consistente dtypes in productiepijplijnen
In productiepijplijnen die elke dag nieuwe gegevens verwerken, kunnen dtypes geleidelijk veranderen — een kolom die altijd int64 was, kan als float64 binnenkomen als er één NaN verschijnt. Voeg dtype-controles toe aan het begin van de pijplijn om wijzigingen in het schema vroeg te detecteren. Expliciet mislukken met een duidelijke fout is veel beter dan stilzwijgend onjuiste resultaten verderop te produceren.
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')Snelle controle
Test je begrip van het controleren van gegevenstypen van kolommen.
Samenvatting van de les
In deze les heb je geleerd dat df.dtypes het type van elke kolom toont, dat het dtype object het algemene type is voor tekenreeksen en gemengde typen, en dat df.info() een volledig overzicht van typen en ontbrekende waarden geeft. Gebruik select_dtypes() om kolommen op typefamilie te filteren en voeg dtype-controles toe om schemawijzigingen in productie te detecteren. Hierna zetten we kolommen met astype() om naar de juiste dtypes.
Leer Python met een AI-tutor — gratis
Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.
- Cursussen
- 30
- Lessen
- 120
Veelgestelde vragen
Is de les “Gegevenstypen van kolommen inspecteren” gratis?
Ja — de volledige tekst van “Gegevenstypen van kolommen inspecteren” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus Pandas & NumPy Academy wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus Pandas & NumPy Academy bevat in totaal 4 lessen.
Wat leer ik in “Gegevenstypen van kolommen inspecteren”?
Lees het kenmerk dtypes, onderscheid int64 van float64 en object en herken kolommen die conversie nodig hebben. Je oefent met Pandas & NumPy Academy door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.
Heb ik ervaring nodig om met Pandas & NumPy Academy te beginnen?
Ervaring vooraf is niet nodig. Pandas & NumPy Academy op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 1 van 4.
Hoe lang duurt de les “Gegevenstypen van kolommen inspecteren”?
De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.
Kan ik code schrijven en uitvoeren in deze les over Pandas & NumPy Academy?
Ja. Elke les over Pandas & NumPy Academy bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.
Alle lessen in deze cursus
- Gegevenstypen van kolommen inspecteren
- Converteren met astype()
- Categorisch gegevenstype
- Datums correct parseren