0Pricing
Pandas & NumPy Academy · Lektion

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: object

Das 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: object

Den 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+ bytes

Hä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 bool

Speicherverbrauch 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' failed

Mehrdeutigkeit 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)  # Int64

select_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

  1. Datentypen von Spalten untersuchen
  2. Typumwandlung mit astype()
  3. Kategorischer Datentyp
  4. Datumsangaben korrekt parsen
← Zurück zu Pandas & NumPy Academy