Welche primitiven Datentypen gibt es und wie wählt man sie aus?
Die vier fundamentalen Datentypen
Primitive Datentypen sind die kleinsten, fest in einer Programmiersprache integrierten Bausteine zur Informationsverarbeitung. Sie repräsentieren jeweils genau einen einfachen, unteilbaren Wert. In fast allen modernen Sprachen findest du diese vier Grundtypen:
- Integer (Ganzzahl): Speichert Zahlen ohne Komma. Dieser Typ ist perfekt für zählbare Dinge, wie die Anzahl von Servern (
anzahl_server = 5) oder Stückzahlen in einem Warenkorb. - Float (Gleitkommazahl): Speichert Zahlen mit Nachkommastellen. Ideal für kontinuierliche Messwerte, wie die CPU-Temperatur (
temperatur = 45.5) oder prozentuale Auslastungen. - Boolean (Wahrheitswert): Kennt exakt zwei Zustände:
True(wahr) oderFalse(falsch). Er wird für Ja/Nein-Zustände genutzt, etwa um zu prüfen, ob eine nutzende Person Administrator-Rechte hat (ist_admin = True). - Character (Zeichen): Speichert ein einzelnes Textzeichen (Buchstabe, Ziffer, Symbol). Nützlich für einzelne Tastenanschläge oder Laufwerksbuchstaben (
laufwerk = 'C').
Kriterien für die optimale Typ-Wahl
Die Wahl des richtigen Datentyps entscheidet über die Fehlerfreiheit und Effizienz deines Programms. Du musst drei Kriterien abwägen:
- Wertebereich: Jeder Typ hat technische Grenzen. Ein Standard-Integer kann oft Zahlen bis ca. 2 Milliarden speichern. Erwartest du größere Werte (z. B. weltweite Seitenaufrufe einer Website), musst du einen größeren Typ (wie
Long) wählen. - Speicherbedarf: Ein Boolean benötigt im Hintergrund viel weniger Arbeitsspeicher als ein Float. Bei Millionen von Datensätzen summiert sich das enorm. Wähle stets den kleinstmöglichen Typ, der deinen Wertebereich sicher abdeckt.
- Genauigkeit: Für Währungsbeträge solltest du niemals einen Float verwenden! Floats sind für wissenschaftliche Messungen gedacht und erzeugen bei Finanzdaten gefährliche Rundungsfehler. Nutze für Geld stattdessen Integer (Rechnung in Cent) oder sprachspezifische Dezimal-Datentypen.
Wie interagieren primitive Datentypen durch Operationen?
Arithmetische Operationen (Integer und Float)
Mit numerischen Datentypen kannst du alle klassischen Rechenoperationen durchführen. Interessant wird es, wenn verschiedene Typen gemischt werden. In vielen Sprachen führt die Division zweier Integer automatisch zu einem Float, um Nachkommastellen nicht zu verlieren.
basis_takt = 2000 # Integer
multiplikator = 1.5 # Float
# Eine Operation mit Integer und Float ergibt meist einen Float
cpu_takt = basis_takt * multiplikator
print(cpu_takt) # Ergebnis: 3000.0 (Float)
# Modulo (Restwertdivision) ist extrem nützlich für Integer,
# z. B. um zu prüfen, ob eine Zahl gerade ist:
rest = 10 % 2 # Ergebnis: 0 (Integer)Vergleichs- und Logikoperationen
Wie du bereits aus Verzweigungen weißt, steuern Bedingungen den Programmfluss. Der Kern dabei ist: Jede Vergleichsoperation zwischen primitiven Datentypen erzeugt als Ergebnis zwingend einen Boolean. Logische Operatoren verknüpfen diese Booleans dann weiter.
max_logins = 3 # Integer
versuche = 3 # Integer
# Der Vergleich zweier Integer generiert einen Boolean
ist_gesperrt = (versuche >= max_logins) # True
# Logische Verknüpfung von Booleans
alarm_ausloesen = ist_gesperrt and True # TrueOperationen auf einzelnen Zeichen (Character)
Auch mit einzelnen Zeichen (Character) kannst du operieren. Da Computer intern nur Zahlen verstehen, wird jedem Zeichen ein numerischer Wert (z. B. nach dem ASCII- oder Unicode-Standard) zugeordnet. Das große 'A' hat beispielsweise den Wert 65, das 'B' die 66. Dadurch lassen sich Zeichen mathematisch vergleichen oder prüfen:
eingabe = 'C'
# Prüfen, ob das Zeichen ein Großbuchstabe zwischen A und Z ist
ist_buchstabe = (eingabe >= 'A') and (eingabe <= 'Z')
print(ist_buchstabe) # Ergebnis: True
# 'A' (65) ist mathematisch kleiner als 'B' (66)
print('A' < 'B') # Ergebnis: TrueWelche Tücken verbergen sich bei Berechnungen mit primitiven Datentypen?
Overflow und Underflow: Gesprengte Wertebereiche
Jeder Datentyp hat im Arbeitsspeicher eine feste Größe (z. B. 8 Bit, 16 Bit, 32 Bit). Ein 8-Bit-Integer kann exakt 256 verschiedene Werte darstellen (0 bis 255).
Was passiert, wenn du zum Maximalwert 255 eine 1 addierst? Der Speicherplatz reicht nicht aus. Das System fängt wieder von vorne an und das Ergebnis springt auf 0 (oder in den negativen Bereich, je nach Sprache). Dieses Phänomen nennt man Overflow (Überlauf). Stell dir einen mechanischen Kilometerzähler im Auto vor, der bei 99.999 km steht. Fährst du einen Kilometer weiter, springt er auf 00.000.
Das Gegenteil ist der Underflow (oder Wrap-around nach unten): Subtrahierst du 1 von 0 bei einem Datentyp, der keine negativen Zahlen erlaubt, springt der Wert plötzlich auf das absolute Maximum (z. B. 255). Solche unbemerkten Sprünge führen zu katastrophalen Logikfehlern in Programmen.
Rundungsfehler: Die Illusion der exakten Kommazahlen
Computer arbeiten auf Hardwareebene ausschließlich im Binärsystem (Basis 2). Genau wie wir im Dezimalsystem den Bruch $\frac{1}{3}$ nicht exakt aufschreiben können ($0.333...$), kann das Binärsystem bestimmte Dezimalbrüche wie $0.1$ oder $0.2$ nicht exakt darstellen. Sie werden intern als unendlich lange, periodische Binärbrüche berechnet und am Ende aus Platzmangel abgeschnitten.
Das führt zu winzigen Rundungsfehlern, die bei Berechnungen mit Floats plötzlich sichtbar werden:
preis_1 = 0.1
preis_2 = 0.2
summe = preis_1 + preis_2
print(summe) # Ausgabe: 0.30000000000000004
print(summe == 0.3) # Ausgabe: False!Deshalb gilt die eiserne Regel der Softwareentwicklung: Verwende für exakte Berechnungen (wie Währungen oder sicherheitskritische Messungen) niemals Floats, da sich diese winzigen Ungenauigkeiten bei tausenden Transaktionen zu echten Fehlbeträgen aufsummieren.
Teste dein Wissen
Du entwickelst einen Onlineshop und musst die Anzahl der Artikel im Warenkorb speichern. Welcher Datentyp ist dafür am besten geeignet?