Datentypen von Spalten untersuchen
Lesen Sie das Attribut dtypes, unterscheiden Sie int64 von float64 und object und erkennen Sie Spalten, die konvertiert werden müssen.
Datentypen von Spalten untersuchen ist eine kostenlose Pandas & NumPy Academy-Lektion auf CoddyKit. Dies ist Lektion 1 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Pandas & NumPy Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Pandas & NumPy Academy-Kurs umfasst insgesamt 4 Lektionen.
Warum Spaltendatentypen wichtig sind
Jede Spalte in einem Pandas DataFrame hat einen dtype (Datentyp), der bestimmt, wie Werte im Speicher abgelegt werden und welche Operationen darauf zulässig sind. Eine Integer-Spalte mit dem dtype object (String) kann nicht summiert werden. Ein als String gespeichertes Datum wird als Text und nicht als Zeitreihe behandelt. Falsche dtypes gehören zu den häufigsten Ursachen für unbemerkte Fehler und unerwartete Ergebnisse in Datenanalyse-Pipelines.
Überprüfen Sie die dtypes immer als allererstes, nachdem Sie einen neuen Datensatz geladen haben.
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: objectDas dtypes-Attribut
DataFrame.dtypes gibt eine Series zurück, deren Index die Spaltennamen und deren Werte den Pandas-dtype der jeweiligen Spalte enthalten. Häufige dtypes, denen Sie begegnen werden, sind int64, float64, object (Strings und gemischte Werte), bool, datetime64[ns] und category. Der Name des dtypes gibt sowohl die Art der Daten als auch die Anzahl der Bytes an, die jeder Wert verwendet.
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: objectDen object-Dtype erkennen
Der dtype object ist Pandas’ Sammeltyp für Spalten, die nicht als numerischer oder boolescher Typ gespeichert werden können. In der Regel handelt es sich um String-Daten, er kann aber auch auf eine Spalte mit gemischten Typen hinweisen (z. B. Ganzzahlen gemischt mit Strings). Object-Spalten benötigen mehr Speicher als spezialisierte dtypes und lassen sich langsamer verarbeiten. Wenn Sie object sehen, fragen Sie sich: Sollte dies ein String, eine Zahl, eine Kategorie oder ein Datum sein?
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() für eine vollständige Typübersicht
df.info() gibt eine kompakte Tabelle aus, die den Namen jeder Spalte, die Anzahl der Nicht-Null-Werte und den dtype sowie den gesamten Speicherverbrauch anzeigt. Mit diesem einen Befehl erhalten Sie einen vollständigen Überblick über die Qualität des Datensatzes: Sie sehen gleichzeitig, welche Spalten fehlende Daten und welche falsche dtypes enthalten. Deshalb ist er der standardmäßige erste Befehl nach dem Laden eines Datensatzes.
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+ bytesHäufige dtype-Probleme nach read_csv
Beim Einlesen einer CSV-Datei ermittelt Pandas die dtypes, indem es die Werte untersucht. Dabei treten häufig folgende Probleme auf: Numerische Spalten werden als object eingelesen, wenn sie Tausendertrennzeichen oder Währungssymbole enthalten; boolesche Spalten werden als object eingelesen, wenn sie als Strings wie 'Yes'/'No' gespeichert sind; und Datumsspalten werden als object eingelesen, weil Pandas Datumsangaben nicht automatisch interpretiert, sofern Sie dies nicht angeben. Wenn Sie diese Muster erkennen, können Sie sie durch Typkonvertierung schnell beheben.
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 boolSpeicherverbrauch verschiedener dtypes
Verschiedene dtypes benötigen sehr unterschiedlich viel Speicher. Eine int64-Spalte verwendet 8 Bytes pro Wert, während eine object-Spalte mit kurzen Strings möglicherweise 50–200 Bytes pro Wert benötigt. Bei DataFrames mit Millionen von Zeilen kann die Wahl des richtigen dtypes den Speicherverbrauch von Gigabytes auf Megabytes reduzieren. Rufen Sie df.memory_usage(deep=True) auf, um die Bytekosten pro Spalte zu sehen.
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!Numerische Spalten mit falschem Typ erkennen
Ein häufiges Problem ist eine numerische Spalte, die aufgrund vereinzelter Formatierungszeichen als object gespeichert ist. Sie können dies erkennen, indem Sie prüfen, ob pd.to_numeric(df['col'], errors='coerce') ein anderes Ergebnis liefert als die ursprüngliche Spalte. Werte, die nicht geparst werden können, werden zu NaN und zeigen genau, in welchen Zeilen die Typinferenz fehlgeschlagen ist.
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' failedMehrdeutigkeit zwischen Integer und Float prüfen
Wenn eine Spalte NaN-Werte enthält, speichert Pandas Integer-Spalten als float64, weil die standardmäßigen NumPy-Integer-Typen NaN nicht darstellen können. Die daraus entstehenden Float-Werte wie 25.0 sehen wie Ganzzahlen aus, werden aber als Gleitkommazahlen gespeichert. Pandas hat nullable Integer-Typen eingeführt (Int64 mit großem I), die NaN unterstützen und dabei die Integer-Semantik beibehalten.
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() zur Filterung nach Typ
Mit df.select_dtypes(include=) können Sie alle Spalten einer bestimmten Typfamilie auswählen. Häufige Argumente sind: 'number' (alle numerischen Typen), 'object' (Strings), 'bool', 'datetime' und 'category'. Das ist am Anfang einer Pipeline besonders nützlich, um numerische Bereinigung nur auf numerische Spalten und String-Bereinigung nur auf Textspalten anzuwenden.
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']Einen dtype-Bericht erstellen
Eine praktische EDA-Gewohnheit ist das Erstellen eines dtype-Berichts, der für jede Spalte den dtype, die Anzahl eindeutiger Werte und Beispielwerte auflistet. So erkennen Sie schnell Spalten, die vor Beginn der Analyse konvertiert werden müssen. Einen solchen Bericht können Sie mit einem einfachen DataFrame erzeugen, der aus spaltenweisen Aggregationen erstellt wird.
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-Konsistenz in Produktionspipelines
In Produktionspipelines, die täglich neue Daten verarbeiten, können sich dtypes schleichend ändern — eine Spalte, die immer int64 war, kann als float64 eintreffen, sobald ein einzelner NaN-Wert auftritt. Fügen Sie am Anfang der Pipeline dtype-Assertions ein, um Schemaänderungen frühzeitig zu erkennen. Ein deutlicher Fehler ist wesentlich besser, als nachgelagert unbemerkt falsche Ergebnisse zu erzeugen.
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')Schnelltest
Testen Sie Ihr Verständnis für die Überprüfung von Spaltendatentypen.
Zusammenfassung der Lektion
In dieser Lektion haben Sie gelernt: df.dtypes zeigt den Typ jeder Spalte, der dtype object ist ein Sammeltyp für Strings und gemischte Typen, und df.info() liefert einen vollständigen Überblick über Typen und Nullwerte. Verwenden Sie select_dtypes(), um Spalten nach Typfamilie zu filtern, und fügen Sie dtype-Assertions hinzu, um Schemaänderungen in Produktionsumgebungen zu erkennen. Als Nächstes konvertieren wir Spalten mit astype() in die richtigen dtypes.
Häufig gestellte Fragen
Ist die Lektion „Datentypen von Spalten untersuchen“ kostenlos?
Ja — der vollständige Text von „Datentypen von Spalten untersuchen“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Pandas & NumPy Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Pandas & NumPy Academy-Kurs umfasst insgesamt 4 Lektionen.
Was lerne ich in „Datentypen von Spalten untersuchen“?
Lesen Sie das Attribut dtypes, unterscheiden Sie int64 von float64 und object und erkennen Sie Spalten, die konvertiert werden müssen. Du übst Pandas & NumPy Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.
Brauche ich Erfahrung, um Pandas & NumPy Academy zu starten?
Keine Vorkenntnisse erforderlich. Pandas & NumPy Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 1 von 4.
Wie lange dauert die Lektion „Datentypen von Spalten untersuchen“?
Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.
Kann ich in dieser Pandas & NumPy Academy-Lektion Code schreiben und ausführen?
Ja. Jede Pandas & NumPy Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.
Alle Lektionen in diesem Kurs
- Datentypen von Spalten untersuchen
- Typumwandlung mit astype()
- Kategorischer Datentyp
- Datumsangaben korrekt parsen