Datentypen

Im Kontext von Programmiersprachen bezeichnet ein Datentyp (data type) die Zusammenfassung eines Wertebereichs (domain) und der darauf definierten Operationen (operations) zu einer Einheit.

Differenzierungen

Man unterscheidet elementare Datentypen (elementary types), die genau einen Wert aus dem ihnen zugeordneten Wertebereich aufnehmen können, und zusammengesetzte Datentypen (Container-Typen, container types), die mehrere Werte aus ihren Wertebereichen gleichzeitig aufnehmen können. Jede Programmiersprache hat eine gewisse Menge an eingebauten Datentypen (built-in types), die der Programmierer direkt nutzen oder zu eigenen Datentypen (custom types) zusammensetzen kann. Zu den in Python eingebauten Datentypen, die sich ähnlich in den meisten anderen höheren Programmiersprachen finden lassen, gehören:

Elementare Datentypen:

Zusammengesetzte Datentypen:

Sonderfall: None

Der Datentyp None zeigt das Nichtvorhandensein eines Werts eines anderen Typs an. In anderen Programmiersprachen oder im Kontext von Datenbanken heißt dieser Wert häufig null oder NULL.

Eigenschaften

Konkreten Datentypen lassen sich abstrakte Eigenschaften zuschreiben, mit denen eine bestimmte Auswahl typischer Operationen einhergeht. Strings, Tupel und elementare Datentypen sind grundsätzlich unveränderlich (immutable) und auch hashbar (hashable, s. die Definition im Python-Glossar). Listen, Mengen und Wörterbücher sind grundsätzlich veränderlich (mutable) und nicht hashbar. In Python können sie Werte mehrerer verschiedener Datentypen gleichzeitig aufnehmen - unter den unveränderlichen, zusammengesetzten Datentypen können das nur Tupel, nicht aber Strings.

Alle zusammengesetzten Datentypen sind iterierbar (iterable, Substantiv: iterable), d.h. es gibt eine Möglichkeit, systematisch alle darin enthaltenen Werte abzufragen. Listen, Tupel und Strings sind zudem sequenzierbar (sequencable, Substantiv: sequence), d.h. ihre Werte lassen sich in eine lineare Ordnung bringen und in der resultierenden Reihenfolge abfragen. Mengen können einzelne Werte nicht mehrfach enthalten (sie lassen keine Duplikate zu, sind also duplikatfrei). Ebenso kann jeder Schlüssel in einem Dict maximal einmal vorkommen; es können aber mehrere Schlüssel auf denselben Wert abgebildet werden.

Im Überblick:

Jeder Datentyp hat mindestens einen Konstruktor (constructor), mit dessen Hilfe sich explizit Werte dieses Typs spezifizieren oder Werte eines anderen, aber kompatiblen Typs in den gewünschten Datentyp überführen lassen (sog. type cast bzw. casting). Konstruktoren spielen vor allem bei der Arbeit mit zusammengesetzten Datentypen eine Rolle (und haben dort typischerweise Abkürzungen, sog. syntactic sugar). Bei der Arbeit mit einfachen Datentypen genügt es in der Regel, den benötigten Wert direkt anzugeben.

Beispiele

Allgemeines

# Typ ermitteln
# -------------
type("Hallo, Welt!")    # <class 'str'> - String

variable = 42
type(variable)          # <class 'int'> - Integer

Elementare Datentypen

Integers

# Integers (ganze Zahlen)
# ----------------------

# Konstruktor
int()

# Arithmetik
7 + 3        # 10 (Addition)
7 - 3        # 4 (Subtraktion)
7 * 3        # 21 (Multiplikation)
7 / 3        # 2.3333333333333335 (Division, Ergebnis ist Float)
7 // 3       # 2 (ganzzahlige Division ohne Rest, Ergebnis ist Integer)
7 % 3        # 1 (Modulo, d.h. Rest bei ganzzahliger Division)
7 ** 3       # 343 (Potenzierung)

Floats

# Floats (Gleitkommazahlen)
# ------------------------

# Konstruktor
float()

# Arithmetik - grds. wie Integer, nur mit Float als Rueckgabewert
# Rueckgabewert einer Operation mit Float und Integer ist i.A. Float
7.0 + 3      # 10.0

Booleans

# Booleans (Wahrheitswerte)
# ------------------------

# Konstruktor
bool()

# Boolesche Operationen
not True           # False (Negation)
True and False     # False (Konjunktion)
True or False      # True  (Disjunktion)

Zusammengesetzte Datentypen

Strings

# Strings (immutable, iterable, sequencable)
# -----------------------------------------

# Konstruktoren
str()                # Nutzung vor allem fuer Type Casts (z.B. von int)
'...'                # Single-Line String, Var. 1
"..."                # Single-Line String, Var. 2
'''...'''            # Multi-Line String, Var. 1
"""..."""            # Multi-Line String, Var. 2 (Konvention fuer Docstrings:
                     # https://www.python.org/dev/peps/pep-0257/)

# Konkatenation
'Hello, ' + 'World!' # 'Hello, World'

# Indexierung (beginnend bei Null)
'Hello'[-1]          # 'o'     (Besonderheit von Python: negative Indexierung moeglich)
'Hello'.index('l')   #  2      (Umkehrung der Indexierung: sucht ein Element und gibt
                     #          den Index des ersten Treffers zurueck)
'Hello'[0:5:2]       # 'Hlo'   (Slicing, Syntax: 'Text'[min:max:step], min ist inklusiv,
                     #          max ist exklusiv)
'Hello'[:]           # 'Hello' (Slicing, bis auf '[]' und ':'
                     #          sind alle Syntaxelemente optional)

# Join und Split
'Hello, World'.split()          # ['Hello,', 'World']
'Hello, World'.split(', ')      # ['Hello', 'World']
', '.join(['Hello', 'World'])   # 'Hello, World'

# Formatierung
'Hello, %s' % 'World'       # 'Hello, World' - Old Style ('String Modulo')
'Hello, {}'.format('World') # 'Hello, World' - New Style
greeting = 'World'
f'Hello, {greeting}'        # 'Hello, World' - Literal String Interpolation

Tupel

# Tupel (immutable, iterable, sequencable)
# ---------------------------------------
# Konkatenation, Indexierung und Slicing wie bei Strings

# Konstruktoren
tuple()                  # etwaiges Argument muss iterable sein
('element',)             # Konstruktor fuer einelementiges Tupel
('element1', 'element2') # Syntactic Sugar fuer tuple(), Var. 1
'element1', 'element2'   # Syntactic Sugar fuer tuple(), Var. 2

# Unpacking (mit Beispielfunktion 'print')
print(*(1,2))            # 1 2 (ohne Stern: (1, 2))
print(*"Hallo",sep="_")  # H_a_l_l_o (funktioniert auch bei String)

Listen

# Listen (mutable, iterable, sequencable)
# --------------------------------------
# Konkatenation, Indexierung und Slicing wie bei Strings; Unpacking wie bei Tupeln

# Konstruktoren
list()                 # etwaiges Argument muss iterable sein
[1,'a',True]           # Syntactic Sugar fuer list(), '[]' erzeugt leere Liste

# Austausch von Werten
[1,3,2][0] = True      # None, Liste nun [True, 3, 2]
[1,3,2][1:2] = "ba"    # None, Liste nun [1, 'b', 'a'],
                       # Datentyp rechts vom '=' muss iterierbar sein

# Anhaengen von Werten
[1,3,2].append(4)      # None, Liste nun [1, 3, 2, 4]
[1,3,2].extend([4,5])  # None, Liste nun [1, 3, 2, 4, 5],
                       # Argument von 'extend' muss iterierbar sein

# Sortieren (nur, falls Werte untereinander vergleichbar sind;
# Default-Sortierreihenfolge: aufsteigend)
[1,3,2].sort()         # Sortiert die Liste, ohne die Liste zurueckzugeben
sorted([1,3,2], reverse=True)  # [3, 2, 1], gibt eine neue, sortierte Liste zurueck

# Kopieren ("Kniff" erzeugt ein neues Listenobjekt mit den gleichen Werten)
aList = [1,3,2]
anotherList = aList[:]

Mengen

# Mengen (mutable, iterable)
# -------------------------
# Unpacking wie bei Tupeln
# Werte muessen hashbar sein, z.B. keine Mengen als Elemente einer Menge
# (anders in der Mathematik)
# Werte haben aber intern keine Reihenfolge

# Konstruktoren
set()                  # etwaiges Argument muss iterable sein
{'elem1', 'elem2'}     # Syntactic Sugar fuer set() - Achtung:
                       # nicht fuer leere Mengen ('{}' erzeugt leeres Dictionary)

# Eindeutigkeit der Elemente
{1,3,3}                # {1, 3}

# Einfuegen und Entfernen von Elementen
{1,3,2}.add("ba")      # None, Menge nun {1, 2, 3, 'ba'}
{1,3,2}.remove(3)      # None, Menge nun {1, 2}

# Mengenoperationen (Auszug)
{1,3,2}.union({4,5,1})         # {1, 2, 3, 4, 5} (Vereinigung)
{1,3,2}.intersection({4,5,1})  # {1} (Schnitt)

Dicts

# Dicts (mutable, iterable)
# ------------------------
# Schluessel muessen hashbar sein
# Schluessel-Wert-Paare haben intern keine Reihenfolge
# Wert kann wieder ein zusammengesetzter Datentyp sein (z.B. eine Liste)

# Konstruktoren
dict()                                 # etwaiges Argument muss iterable sein
{'key1': 'value1', 'key2': 'value2'}   # Syntactic Sugar fuer dict(),
                                       # '{}' erzeugt leeres Woerterbuch

# Eindeutigkeit der Schluessel
{'key': 'value', 'key': 'value2'}      # {'key': 'value2'} - 'value' wird ueberschrieben

# Einfuegen und Entfernen von Schluessel-Wert-Paaren sowie Aendern von Werten
a_dict = dict()
a_dict['key'] = 'value'          # None, a_dict nun {'key': 'value'}
                                 # (fuer Einfuegungen und Aenderungen)
del a_dict['key']                # None, a_dict nun {} (Fehler, falls 'key' nicht
                                 # als Schluessel in a_dict)

# Nachschlagen von Werten
{'key1': 'value1', 'key2': 'value2'}['key1'] # 'value1'
{'key1': 'value1', 'key2': 'value2'
}.get('key3','not found')     # liefert 'not found', wenn der Schluessel nicht existiert

# Iteration ueber Elemente - s. Kontrollfluss
{'key':'value'}.items()       # Zur Iteration ueber Schluessel-Wert-Paare
{'key':'value'}.keys()        # Zur Iteration ueber Schluessel
                              # (auch: for key in {'key':'value'})
{'key':'value'}.values()      # Zur Iteration ueber Werte