In diesem Kapitel beleuchten wir die Datentypen von Python und geben typische Operationen an, mit denen Variablen dieses Typs modifiziert werden können. Ein wichtiges Prinzip in Python ist das Duck-Typing^[1]. Solange eine Variable jede Operation unterstützt, die von ihr gefordert wird, ist Python der Typ der Variablen egal. Recht nützlich ist die Eigenschaft, eine Ente in einen Frosch zu verwandeln, sofern das möglich ist. Diese Zauberei wird Konvertierung genannt. Kommen wir aber erst zu den Datentypen.

Boolean

Der Datentyp bool repräsentiert Wahrheitswerte aus der Menge True und False. Werte dieses Datentyps werden zumeist bei Anfragen zurückgegeben, wie zum Beispiel: Enthält diese Zeichenkette ausschließlich Ziffern?. Die passende String-Methode hierzu heißt übrigens isdigit(). Ergebnisse werden zumeist im Zusammenhang mit Kontrollstrukturen, über die Sie im nächsten Kapitel mehr erfahren, verwendet. Alle Vergleiche, wie a > b, b > 1, a == b usw. sind entweder True oder False, also vom Typ bool. Wahrheitswerte kann man mit Operatoren verknüpfen.

Die logischen Verknüpfungen haben wir in folgender Tabelle zusammengefasst, wobei a und b Bool'sche Variablen sind, die nur die Werte False und True annehmen können:

Für die logische Xor-Verknüpfung gibt es in Python kein Schlüsselwort, die Verknüpfung Bool'scher Werte mit != leistet aber das Gleiche; auch das bitweise xor ^ kann verwendet werden.

Ein Ausdruck wird so schnell wie es geht ausgewertet. Ist am Anfang eines komplizierten Ausdrucks schon klar, dass der Ausdruck einen bestimmten Wahrheitswert erhält, dann wird nicht weiter ausgewertet. Zum Beispiel wird True or (A and B) zu True ausgewertet, ohne dass der Ausdruck (A and B) berücksichtigt wird. Dieses Vorgehen ist insbesondere wichtig im Zusammenhang mit Funktionen, denn A und B können auch Funktionen sein, die in diesem Fall nicht aufgerufen werden. Gleiches gilt für False and (Ausdruck). Hier wird (Ausdruck) ebenfalls nicht berücksichtigt.

Zahlen

Zahlen sind Grundtypen in Python. Es gibt verschiedene Arten von Zahlen unterschiedlicher Genauigkeit. Hier folgt als Vorgriff auf die Erläuterungen ein gemeinsames Beispiel:

# int
a = 3
print(a)

b = 2**65
print(b)

# Fließkommazahl
c = 2.7
d = 1.3
print(c // d)
print(2**65.0)

# komplexe Zahl
d = 5.0 + 2.0j
print(d**2.0)

Die Ausgabe:

3
36893488147419103232
2.0
(21+20j)
3.6893488147419103e+19

Strings

Ein String ist eine Folge von Zeichen. Anders als in anderen Sprachen kann man einen String nicht mehr verändern. Man muss dazu neue Strings erzeugen, welche den Ursprungsstring beinhalten:

# Gibt den String aus
print("Hallo, Welt!")
# Fügt beide Strings zusammen, ohne Leerzeichen...
print("Hallo" + "Ballo")
# ... selbiges mit Leerzeichen
print("Hallo", "Ballo")
# Viermal "Hallo"
print("Hallo"*4)

s = """



Dieses ist ein langer String, er geht
über mehrere Zeilen. Es steht zwar nichts interessantes
darin, aber darauf kommt es auch nicht an."""
print(s)

Hallo, Welt!
HalloBallo
Hallo Ballo
HalloHalloHalloHallo




Dieses ist ein langer String, er geht
über mehrere Zeilen. Es steht zwar nichts interessantes
darin, aber darauf kommt es auch nicht an.

Strings können also zusammengesetzt werden, wobei gerade die Variante "Hallo" * 4, einen neuen String zu erzeugen, ungewohnt aber direkt erscheint. Lange Strings werden ebenso gebildet wie ein Kommentar, mit dem Unterschied, dass er einer Variable zugewiesen wird. Tatsächlich sind Kommentare, die mit """ gebildet werden nichts anderes, als anonyme Strings.

Auf String-Objekte kann man Methoden anwenden. Diese geben oft einen Ergebnis-String zurück und lassen das Original unverändert:

s = "dies ist mein kleiner String"
print(s.capitalize())
print(s.replace("kleiner", "kurzer"))
print(s.upper())

Dies ist mein kleiner string
dies ist mein kurzer String
DIES IST MEIN KLEINER STRING

Einige der Methoden, die auf ein String-Objekt anwendbar sind, finden sich in folgender Tabelle:

Mehr über Strings erfahren Sie im Abschnitt Sequenzen.

Zeichen

Zeichen kann man als Spezialfall von Strings auffassen. Sie sind Strings der Länge Eins. Wir führen sie hier auf, um zwei in späteren Kapiteln benötigte Funktionen aufzuführen, nämlich ord(Zeichen) und chr(Zahl). ord(Zeichen) liefert eine Zahl, die der internen Darstellung des Zeichens entspricht, während chr(Zahl) ein Zeichen zurückliefert, welches zur angegebenen Zahl passt.

print("'A' hat den numerischen Wert", ord('A'))
print("Das Zeichen mit der Nummer 100 ist '" + chr(100) + "'")

'A' hat den numerischen Wert 65
Das Zeichen mit der Nummer 100 ist 'd'

Listen

Listen sind veränderbare Datentypen, die dazu dienen, zur selben Zeit Elemente beliebigen Typs aufzunehmen.

Werte = ['Text', 'Noch ein Text', 42, 3.14]
print(Werte)
print("Anzahl der Elemente: ", len(Werte))

['Text', 'Noch ein Text', 42, 3.1400000000000001]
Anzahl der Elemente:  4

Die Funktion len() bestimmt die Anzahl der Elemente der Liste, in diesem Fall 4. Listen können auch Listen enthalten, auch sich selbst.

Hinzugefügt werden Werte mit dem +-Operator und den Funktionen append() und insert():

Werte = ['Text', 42]
Werte += ['foo']
Werte.append(3)
Werte.insert(2, 111)
print(Werte)

['Text', 42, 111, 'foo', 3]

Diese Funktionen nennt man Methoden, da sie Bestandteil der Listenobjekte sind. Die Methode insert(2, 111) fügt vor dem Element mit dem Index 2 die Zahl 111 ein. Die Zählung beginnt mit der 0, das nullte Element ist im obigen Beispiel die Zeichenkette Text.

Löschen lassen sich Listenelemente ebenfalls:

Werte = [1, 2, 'Meier', 4, 5]
print(Werte.pop())
print(Werte.pop(0))
Werte.remove('Meier')
print(Werte)

5
1
[2, 4]

Die Methode pop() ohne Argument liefert das letzte Element der Liste und entfernt es anschließend. Mit Argument N wird das N-te Element gelöscht. Die Methode remove(x) entfernt das erste Element mit dem Wert x.

Listen lassen sich auch per Funktion erzeugen. Eine solche Funktion ist range(Startwert, Endwert, Schrittweite). Sie erwartet einen Startwert sowie einen Endwert und baut daraus eine Liste, wobei der Endwert nicht Teil der entstehenden Liste ist. Die Parameter Startwert und Schrittweite sind optional.

l1 = [i for i in range(1, 10)]		# oder [*range(1, 10)]
l2 = [i for i in range(1, 10, 3)]	# oder [*range(1, 10, 3)]
print(l1)
print(l2)

[1, 2, 3, 4, 5, 6, 7, 8, 9]
[1, 4, 7]

In unserem Beispiel enthält l1 alle Werte von 1 bis 9, l2 hingegen enthält lediglich 1, 4 und 7, weil wir eine Schrittweite von 3 vereinbart haben. Im Gegensatz zu Python2 legt die range()-Funktion in Python3 nicht die gesamte Liste, sondern ein range-Objekt an.

Mehr über Listen erfahren Sie im Abschnitt Sequenzen.

Tupel

Tupel lassen sich, anders als Listen, nicht verändern. Sie sind damit besonders geeignet, um Konstanten zu repräsentieren. Ansonsten ähneln sie Listen aber sehr:

Werte = ('Text', 'Noch ein Text', 42, 3.14)
print(min(Werte))
print(max(Werte))
print("Anzahl der Elemente: ", len(Werte))

3.14
Text
Anzahl der Elemente:  4

Ein Tupel wird in runde Klammern geschrieben; auch Tupel mit nur einem Element sind möglich, dafür muss ein Komma nach dem Element stehen, um das Tupel von einem Ausdruck in Klammern zu unterscheiden, z.B. (1,).

Mehr über Tupel erfahren Sie im nächsten Abschnitt Sequenzen.

Sequenzen

Zu Sequenzen zählen die hier behandelten Strings, Listen und Tupel. Lediglich Listen lassen sich ändern, alle anderen Sequenztypen sind konstant. Grund genug, einige Details zusammenzufassen.

Sequenzen können aufgezählt werden. Das erste Element hat den Index 0, das letzte Element den Index len(Sequenz)-1. Sequenzen können ihrerseits wieder Sequenzen aufnehmen. Eine Besonderheit ist, dass man Teilsequenzen, so genannte Slices, bilden kann:

text = "Dies ist mein String"
print("Großbuchstaben: ", text[0], text[14])
print("Verb: ", text[5:8])
print("Erstes Wort: ", text[:4])
print("Letztes Wort: ", text[14:])

Großbuchstaben:  D S
Verb:  ist
Erstes Wort:  Dies
Letztes Wort:  String

An diesem Beispiel sieht man, dass man einzelne Zeichen direkt adressieren kann, wobei man den Index in eckige Klammern setzt, wie auch einen Bereich der Sequenz ansprechen kann, indem Anfang und Ende durch Doppelpunkt getrennt werden. Anfang und Ende vom Slice sind optional. Steht vor dem Doppelpunkt kein Wert, so ist der Anfang der Sequenz gemeint. Analoges gilt für das Ende. Optional kann auch nach einem zweiten Doppelpunkt eine Schrittweite angegeben werden, [::2] wäre zum Beipiel jedes zweite Element, [::-1] die Sequenz von hinten nach vorne. Wenn Sie diese Art der Adressierung verstanden haben, fällt es Ihnen sicher leicht, die negative Adressierung ebenfalls zu verstehen:

sequenz = (1, 2, 'a', 'b', 'c')
print("Buchstaben: ", sequenz[-3:])
print("Ziffern: ", sequenz[:-3])
print("Jedes 2. Zeichen:", sequenz[::2])

Buchstaben:  ('a', 'b', 'c')
Ziffern:  (1, 2)
Jedes 2. Zeichen: (1, 'a', 'c')

Buchstabenindizes werden hier vom Ende gezählt. Der Index -1 ist das c, der Index -2 ist das b und so weiter. Die Buchstaben werden also vom drittletzten zum letzten hin ausgegeben. Ziffern hingegen werden vom Nullten zum ebenfalls drittletzten ausgegeben, wobei ebendieses nicht mit ausgegeben wird.

Auf Sequenzen sind gemeinsame Operatoren und Methoden definiert. Folgende Tabelle gibt einen Überblick:

Set

Der Typ set beschreibt Mengen. Elemente einer Menge sind ungeordnet und einzigartig. Alle Sets unterstützen die üblichen Mengenoperationen:

s1 = set('abc')
s2 = set('bcd')
print('s1 =', s1,' s2 =', s2)
# Differenzmenge
print('s1 - s2 =', s1 - s2)
# Vereinigungsmenge
print('s1 | s2 =', s1 | s2)
# Schnittmenge
print('s1 & s2 =', s1 & s2)
# Symmetrische Differenz
print('s1 ^ s2 =', s1 ^ s2)
# Enthalten
print("'a' in s1 =", 'a' in s1)
# Mächtigkeit der Menge
print("len(s1) = ", len(s1))

s1 = {'c', 'b', 'a'}  s2 = {'b', 'c', 'd'}
s1 - s2 = {'a'}
s1 | s2 = {'c', 'b', 'a', 'd'}
s1 & s2 = {'b', 'c'}
s1 ^ s2 = {'a', 'd'}
'a' in s1 = True
len(s1) =  3

Die Operation in liefert als Ergebnis True wenn ein Element in der Menge vorkommt.

Folgende Methoden lassen sich von einem Set-Objekt ansprechen:

Dictionaries

Der Typ dict stellt eine Zuordnung zwischen Schlüsseln und Werten her. Er ist genau wie ein Wörterbuch zu verstehen, wo als Schlüssel zum Beispiel ein englischer Begriff und als Wert ein deutschsprachiger Begriff aufgeführt ist. Selbstverständlich lassen sich auch Telefonnummern oder Gehälter auf diese Weise ordnen:

personal = {'Tom' : 32000, 'Beate' : 44000, 'Peter' : 10000}
print(personal)
print("Tom verdient %d Euro pro Jahr" % (personal['Tom']))

{'Peter': 10000, 'Beate': 44000, 'Tom': 32000}
Tom verdient 32000 Euro pro Jahr

Dictionaries können modifiziert werden. Darüber hinaus bietet die Methode keys() die Möglichkeit, sich alle Schlüssel anzeigen zu lassen.

personal = {'Tom' : 32000, 'Beate' : 44000, 'Peter' : 10000}
print(personal)
print("Susi kommt dazu...", end="")
personal['Susi'] = 10000
print(personal.keys())
print("Peter hat einen anderen Job gefunden...")
del personal['Peter']
print(personal.keys())
print("Tom bekommt mehr Geld: ", end="")
personal['Tom'] = 33000
print(personal)

{'Peter': 10000, 'Beate': 44000, 'Tom': 32000}
Susi kommt dazu... ['Susi', 'Peter', 'Beate', 'Tom']
Peter hat einen anderen Job gefunden...
['Susi', 'Beate', 'Tom']
Tom bekommt mehr Geld:  {'Susi': 10000, 'Beate': 44000, 'Tom': 33000}

Elemente kann man hinzufügen, in dem man einen neuen Schlüssel in eckigen Klammern anspricht, und diesem einen Wert zuweist. Mit delete() lassen sich Schlüssel/Wert-Paare löschen. Die Methode keys() zeigt alle Schlüssel eines Dictionaries als Liste an. Folgende Tabelle zeigt darüberhinaus noch einige gebräuchliche Dictionary-Methoden:

Besonderheiten beim Kopieren

Beim Kopieren von Variablen gibt es eine Besonderheit. Die Kopien verweisen wieder auf die Originale. Versucht man nun, eine Kopie zu verändern, verändert man gleichzeitig das Original, wie folgendes Beispiel zeigt:

liste1 = [1, 2, 3]
liste2 = liste1
liste2 += [5]

print(liste1)
print(liste2)

Statt zweier unterschiedlicher Listen bekommen wir dieses erstaunliche Ergebnis:

[1, 2, 3, 5]
[1, 2, 3, 5]

Wir haben also gar keine Kopie bearbeitet, sondern nur die einzig vorhandene Liste, auf die sowohl liste1 als auch liste2 nur verweisen.

Lösung des Problems: liste2 = liste1[:], ein Slice über die komplette Liste. Für andere Datentypen (aber auch Listen) gibt es aus dem Modul copy die Funktion copy(). Dictionaries haben eine eigene copy()-Methode. All dieses erzeugt aber nur eine flache Kopie. Sollen auch z. B. Listen mit kopiert werden, die in einer Liste enthalten sind, verwendet man die Funktion copy.deepcopy(). Hierzu noch ein Beispiel:

import copy

tupel1 = (1, 2, [3, 4], 5)
tupel2 = copy.deepcopy(tupel1)
#tupel2 = copy.copy(tupel1)   #  zum Testen des unterschiedlichen Verhaltens auskommentieren
tupel2[2].append("foo")

print(tupel1)
print(tupel2)

Die beiden Tupel sind nun also eigenständige Kopien inklusive der enthaltenen Liste, wie uns die Programmausgabe beweist:

(1, 2, [3, 4], 5)
(1, 2, [3, 4, 'foo'], 5)

Das Beispiel zeigt auch nochmal, dass zwar Tupel unveränderlich sind, aber enthaltene veränderliche Datentypen gleichwohl auch veränderlich bleiben. Die Problematik des Kopierens ist also nicht auf veränderliche Datentypen beschränkt.

Konvertierung

Wie wir in der Einführung schon festgestellt haben, kann man einige Datentypen ineinander umwandeln. Aus einem String kann zum Beispiel eine Zahl werden, wenn der String nur Ziffern enthält. Andernfalls wird eine Fehlermeldung beim Versuch der Konvertierung ausgegeben. Die folgende Tabelle enthält einige Konvertierungsfunktionen:

Typenabfrage

Den Typ einer Variablen kann man mit Hilfe der Funktion type() abfragen:

print(type(3))
print(type('a'))
print(type(("Hallo", "Welt")))
print(type(["Hallo", "Welt"]))
print(type({"Hallo" : 1, "Welt" : 2}))

<class 'int'>
<class 'str'>
<class 'tuple'>
<class 'list'>
<class 'dict'>

Konstanten

Symbolische Konstanten gibt es in Python nicht; stattdessen sind spezielle Vereinbarungen für Variablennamen (Namenskonventionen) üblich. Man schreibt sie groß, damit alle an einem Programm arbeitenden Personen wissen, dass diese Variable wie eine Konstante behandelt werden soll. Das folgende Beispiel zeigt, wie das geht:

KONSTANTE = 3

print("Meine Konstante ist:", KONSTANTE)

Anstelle von Konstanten werden also Variablen verwendet, bei der Programmierer vereinbaren, sie groß zu schreiben und nach der Initialisierung nicht mehr zu ändern. Dieses ist ein Teil des Python way of coding, der oft von weniger Strenge und Formalismus geprägt ist.

Zusammenfassung

Sie haben jetzt einen Überblick über das Typensystem von Python. Vom Prinzip her braucht man sich über den Typ meistens keine Gedanken machen, sollte jedoch in Spezialfällen darüber Bescheid wissen. Einer Variablen weist man Werte zu und schon steht der Typ fest. Den Typ einer Variablen kann man zur Laufzeit ändern und abfragen.

Anmerkungen

1. ↑ Wenn etwas so aussieht wie eine Ente (oder ein Datentyp), so geht wie eine Ente und so quakt wie eine Ente, warum soll es dann keine sein?
2. ↑ Um mehr Hintergrundinformationen über komplexe Zahlen zu bekommen, empfehlen wir ihnen das Wikibuch Komplexe Zahlen.