Python unter Linux: Datentypen
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
[Bearbeiten]Dieser Datentyp repräsentiert Wahrheitswerte aus der Menge True und False. Werte dieses Datentyps werden zumeist bei Anfragen zurückgegeben, wie zum Beispiel: Enthält folgende Zeichenkette ausschließlich Ziffern?. Die passende String-Methode hierzu lautet übrigens isdigit(). Ergebnisse werden zumeist im Zusammenhang mit Kontrollstrukturen, über die Sie im nächsten Kapitel mehr erfahren, verwendet. 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:
a | b | not a | a and b | a or b | a ^ b (xor) |
---|---|---|---|---|---|
False | False | True | False | False | False |
False | True | True | False | True | True |
True | False | False | False | True | True |
True | True | False | True | True | False |
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
[Bearbeiten]Zahlen sind Grundtypen in Python. Es gibt verschiedene Sorten Zahlen unterschiedlicher Genauigkeit. Hier folgt als Vorgriff auf die Erläuterungen ein gemeinsames Beispiel:
#!/usr/bin/python
# -*- coding: utf-8 -*-
# Int
a = 3
print a
# Long
b = 2**65
print b
# Fließkommazahl
c = 2.7
d = 1.3
print c // d
# komplexe Zahl
d = 5.0 + 2.0j
print d**2.0
Die Ausgabe:
user@localhost:~$ ./zahlen1.py
3
36893488147419103232
2.0
(21+20j)
Int
[Bearbeiten]Ganze Zahlen haben Sie schon in den ersten Schritten kennen gelernt. Hier folgt nochmal eine Zusammenfassung der Dinge, die Sie mit ganzen Zahlen tun können:
Operation | Bedeutung |
---|---|
abs(Zahl) | berechnet den Absolutbetrag der Zahl |
bin(Zahl) | Liefert die binäre Darstellung der Zahl |
divmod(Zahl1, Zahl2) | berechnet ein 2-Tupel, wobei der erste Teil die
ganzzahlige Division und der zweite Teil die Modulo-Operation aus den beiden Zahlen ist. |
hex(Zahl) | Liefert die hexadezimale Darstellung der Zahl |
oct(Zahl) | Oktale Darstellung der Zahl |
chr(Zahl) | liefert das Zeichen mit dem "ASCII"-Code Zahl, z.B. chr(97) liefert 'a'. |
/, // | Ganzzahlige Division |
% | Modulo-Operation |
+, -, *, ** | Addieren, Subtrahieren, Multiplizieren und Potenzieren |
Long
[Bearbeiten]Dieser Typ wird verwendet, wenn es sich um sehr große Zahlen handelt. So können Sie in Python problemlos a=2**65 berechnen, das Ergebnis wird in eine Zahl vom Typ long konvertiert. Zahlen dieses Typs wird manchmal ein L nachgestellt. Die Operationen auf solchen Zahlen sind die gleichen wie oben beschrieben.
Float
[Bearbeiten]Dieser Typ repräsentiert Fließkommazahlen. Diese Zahlen werden mit einem Dezimalpunkt notiert. Folgende Operationen sind auf Fließkommazahlen definiert:
Operation | Bedeutung |
---|---|
round(Zahl) | rundet die Zahl kaufmännisch zur nächst größeren/kleineren ganzen Zahl. Das Ergebnis wird als Fließkommazahl dargestellt. |
/ | Normale Division |
// | entspricht der ganzzahligen Division |
% | Modulo-Operation |
+, -, *, ** | Addieren, Subtrahieren, Multiplizieren und Potenzieren |
Complex
[Bearbeiten]Komplexe Zahlen[2] bestehen aus einem 2-Tupel, wobei sich ein Teil Realteil und ein anderer Imaginärteil nennt. Man kann komplexe Zahlen nicht aufzählen oder entscheiden, welche von zwei gegebenen Zahlen größer ist als die andere. Dargestellt werden solche Zahlen in Python als Summe von Real- und Imaginärteil, beispielsweise C=5.0 + 2.0j.
Folgende Dinge kann man mit komplexen Zahlen tun:
Operation | Bedeutung |
---|---|
abs(C) | Berechnet den Absolutbetrag der komplexen Zahl C |
C.real, C.imag | liefert den Realteil, Imaginärteil der Zahl C zurück. |
+, -, *, /, ** | Addieren, Subtrahieren, Multiplizieren, Dividieren und Potenzieren |
Strings
[Bearbeiten]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:
#!/usr/bin/python
# -*- coding: utf-8 -*-
# Gibt den String aus
print "Hallo, Welt!"
# Fuegt 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
user@localhost:~$ ./string1.py
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:
#!/usr/bin/python
# -*- coding: utf-8 -*-
s = "dies ist mein kleiner String"
print s.capitalize()
print s.replace("kleiner", "kurzer")
print s.upper()
user@localhost:~$ ./string2.py
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:
Funktion | Beschreibung |
---|---|
capitalize() | Erzeugt einen neuen String, dessen erster Buchstabe groß geschrieben ist. |
count(Substring, Anfang, Ende) | Zählt die Vorkommen von Substring im Objekt. Anfang und Ende sind optional |
find(Substring, Anfang, Ende) | Findet das erste Vorkommen von Substring, gibt den Index innerhalb des Strings oder -1 zurück. Anfang und Ende sind optional. |
lower() | Gibt einen String zurück, der nur aus Kleinbuchstaben besteht |
replace(Alt, Neu, Anzahl) | Ersetzt im String Alt gegen Neu. Nur die ersten Anzahl Vorkommen werden ersetzt. Anzahl ist optional. |
strip(Zeichen) | Entfernt die Vorkommen von Zeichen am Anfang und am Ende vom String. Wenn Zeichen nicht angegeben wird, so wird Leerzeichen angenommen. |
upper() | Gibt einen String zurück, der nur aus Großbuchstaben besteht. |
isalnum() | True, wenn der String aus Ziffern und Buchstaben besteht |
isalpha() | True, wenn der String aus Buchstaben besteht. |
isdigit() | True, wenn der String aus Ziffern besteht. |
startswith(Prefix, Anfang, Ende) | True, wenn am Anfang des Strings Prefix vorkommt. Die Optionalen Parameter Anfang und Ende begrenzen den Suchbereich. |
split(Trenner) | Zerlegt einen String in einzelne Worte. Trenner ist optional. Ohne Angabe wird bei Leerzeichen, Tabulatoren und Zeilenumbruechen getrennt. |
join(Liste) | Fügt eine Liste von Strings mit diesem String wieder zusammen. Trenner.join(s.split(Trenner)) sollte genau den String s wiedergeben. |
Mehr über Strings erfahren Sie im Abschnitt Sequenzen.
Unicode-Strings und Zeichenkodierung
[Bearbeiten]Strings in Python werden intern immer als Unicode-Codepoints verarbeitet. Ein Codepoint ist eine festgelegte Zahl, die genau einem Zeichen zugeordnet ist. Der Unicode-Standard selbst definiert zudem Transformationsformate wie zum Beispiel UTF-8, die wiederum die tatsächliche Byte-Darstellung für die Speicherung festlegen. Wichtig zu verstehen ist, dass ein Unicode-Codepoint nicht mit einer UTF-8-Byte-Darstellung gleichzusetzen ist. Sie haben normalerweise unterschiedliche Werte für ein bestimmtes Zeichen.
Strings werden in zwei Schritten verarbeitet. Es gibt einen Dekodierungs- bzw. einen Kodierungsschritt. Für beide Schritte stehen analog die Funktionen decode() und encode() zur Verfügung. Beide Funktionen sind in der Klasse unicode und str zu finden.
Im ersten Schritt wird die Bytefolgen-Dekodierung der Python-Quelldatei in die Unicode-Codepoint-Darstellung durchgeführt. Über die in der Quelldatei angegebene Kommentarzeile # -*- coding: UTF-8 -*- wird auf die Standardzeichendekodierung hingewiesen, die zur automatischen Dekodierung hin zur internen Unicode-Codepoint-Darstellung benutzt werden soll. Dazu ist vom Programmierer sicherzustellen, dass die Datei auch in der gleichen Byte-Kodierung (hier UTF-8) abgespeichert ist, wie in der Kommentarzeile angegeben.
Im zweiten Schritt ist die Unicode-Codepoint-Darstellung in die Zielkodierung für den String zu bringen. Das geschieht über die encode()-Funktion und ist nur dann notwendig, wenn eine abweichende Zielkodierung zur Coding-Kommentarzeile angestrebt wird.
Die folgende Beispieldatei zeichenkodierung.py demonstriert die Bytefolgendarstellung der unterschiedlichen Zeichenkodierungen:
#!/usr/bin/python
# -*- coding: UTF-8 -*-
UnicodeText=u'ÄÜÖ€'
UTF_8Text='ÄÜÖ€'
ISO_8859_1TextIgnore=u'ÄÜÖ€'.encode('iso-8859-1', 'ignore')
ISO_8859_1TextReplace='ÄÜÖ€'.decode('UTF-8').encode('iso-8859-1', 'replace')
def bytefolge(kommentar, zeichenkette):
for zeichen in zeichenkette:
print "%x" % ord(zeichen),
print "(%s)" % kommentar
bytefolge("Unicode-Codepoint-Folge", UnicodeText)
bytefolge("UTF-8-Bytefolge", UTF_8Text)
bytefolge("ISO-8859-1-Bytefolge (€ ignoriert)", ISO_8859_1TextIgnore)
bytefolge("ISO-8859-1-Bytefolge (€ ersetzt)", ISO_8859_1TextReplace)
user@localhost:~$ ./zeichenkodierung.py
c4 dc d6 20ac (Unicode-Codepoint-Folge)
c3 84 c3 9c c3 96 e2 82 ac (UTF-8-Bytefolge)
c4 dc d6 (ISO-8859-1-Bytefolge (€ ignoriert))
c4 dc d6 3f (ISO-8859-1-Bytefolge (€ ersetzt))
Es sei darauf hingewiesen, dass das Eurozeichen (€) in der Zeichenkodierung ISO-8859-1 nicht vorhanden ist. Deshalb werden im Beispiel zwei verschiedene Strategien zur Behandlung dieser Situation gezeigt. Im ersten Fall wird das €-Zeichen ignoriert und erhält somit auch keine Byterepräsentation in der ausgegebenen Bytefolge. Im Zweiten wird es ersetzt durch das Standard-Ersatzzeichen für ISO-8859-1, das Fragezeichen (0x3f).
Zeichen
[Bearbeiten]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.
#!/usr/bin/python
print "'A' hat den numerischen Wert", ord('A')
print "Das Zeichen mit der Nummer 100 ist '" + chr(100) + "'"
user@localhost:~$ ./zeichen1.py
'A' hat den numerischen Wert 65
Das Zeichen mit der Nummer 100 ist 'd'
Listen
[Bearbeiten]Listen sind beschreibbare Datentypen, die dazu dienen, zur selben Zeit Elemente beliebigen Typs aufzunehmen.
#!/usr/bin/python
Werte = ['Text', 'Noch ein Text', 42, 3.14]
print Werte
print "Anzahl der Elemente: ", len(Werte)
user@localhost:~$ ./listen1.py
['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():
#!/usr/bin/python
Werte = ['Text', 42]
Werte += ['foo']
Werte.append(3)
Werte.insert(2, 111)
print Werte
user@localhost:~$ ./listen2.py
['Text', 42, 111, 'foo', 3]
wobei man diese Funktionen Methoden nennt, da sie Bestandteil der Listenobjekte sind. Die Methode insert(2, 111) fügt an die zweite Stelle die Zahl 111 ein. Die Zählung beginnt mit der 0, das nullte Element ist die Zeichenkette Text.
Löschen lassen sich Listenelemente ebenfalls:
#!/usr/bin/python
Werte = [1, 2, 'Meier', 4, 5]
print Werte.pop()
print Werte.pop(0)
Werte.remove('Meier')
print Werte
user@localhost:~$ ./listen3.py
5
1
[2, 4]
Die Methode pop() liefert ohne Argument das letzte Element der Liste und entfernt es anschließend. Mit Argument wird das N-te Element gelöscht. Die Methode remove() entfernt das Element mit dem angegebenen Schlüssel.
Listen lassen sich auch per Funktion erzeugen. Eine solche Funktion ist range(von, bis, step). Sie erwartet einen Startwert sowie einen Endwert und baut daraus eine Liste, wobei der Endwert nicht Teil der entstehenden Liste ist. Die Parameter von und step sind optional und geben den Anfangswert wie auch die Schrittweite an, mit der Listenelemente zwischen dem Start- und dem Endwert eingefügt werden.
#!/usr/bin/python
l1 = range(1, 10)
l2 = range(1, 10, 3)
print l1
print l2
user@localhost:~$ ./listen4.py
[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. Die range()-Funktion legt übrigens die gesamte Liste im Speicher an, weswegen man sich vor Gebrauch unbedingt sicher sein sollte, genug davon zu haben. Eine Liste mit mehreren Millionen Einträgen zu erzeugen dauert eine Weile, wie der Autor dieser Zeilen während eines recht eng terminierten Vortrags feststellen musste, als er statt xrange() (dazu kommen wir später) range() schrieb.
Mehr über Listen erfahren Sie im Abschnitt Sequenzen.
Tupel
[Bearbeiten]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:
#!/usr/bin/python
Werte = ('Text', 'Noch ein Text', 42, 3.14)
print min(Werte)
print max(Werte)
print "Anzahl der Elemente: ", len(Werte)
user@localhost:~$ ./tupel1.py
3.14
Text
Anzahl der Elemente: 4
Ein Tupel wird in runde Klammern geschrieben. min() bestimmt das Minimum eines Tupels, max() das Maximum. Enthält ein Tupel Text, so wird dieser alphabetisch verglichen.
Mehr über Tupel erfahren Sie im nächsten Abschnitt Sequenzen.
Sequenzen
[Bearbeiten]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:
#!/usr/bin/python
text = "Dies ist mein String"
print "Grossbuchstaben: ", text[0], text[14]
print "Verb: ", text[5:8]
print "Erstes Wort: ", text[:4]
print "Letztes Wort: ", text[14:]
user@localhost:~$ ./seq1.py
Grossbuchstaben: 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.
Wenn Sie diese Art der Adressierung verstanden haben, fällt es Ihnen sicher leicht, die negative Adressierung ebenfalls zu verstehen:
#!/usr/bin/python
sequenz = (1, 2, 'a', 'b', 'c')
print "Buchstaben: ", sequenz[-3:]
print "Ziffern: ", sequenz[:-3]
user@localhost:~$ ./seq2.py
Buchstaben: ('a', 'b', 'c')
Ziffern: (1, 2)
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:
Funktion | Beschreibung | Beispiel |
---|---|---|
S * n | Erzeugt eine Sequenz, die aus der n-fachen Aneinanderreihung von S besteht. | (3,) * 10, "Hallo " * 2 |
min(), max() | Bestimmt das Minimum/Maximum der Sequenz | min((1, 2, 3)), max(['a', 'b', 'c']) |
a in S | True, wenn Element a in der Sequenz S vorkommt | 3 in [0] * 7 |
S + T | Die Sequenzen S und T werden aneinandergehängt | (1, 2, 3) + (2,) |
len(S) | Länge, Anzahl der Elemente von S | len("Hallo, Welt!") |
Set
[Bearbeiten]Der Typ set beschreibt Mengen. Elemente einer Menge sind ungeordnet und einzigartig. Alle Sets unterstützen die üblichen Mengenoperationen:
#!/usr/bin/python
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
# Maechtigkeit der Menge
print "len(s1) = ", len(s1)
user@localhost:~$ ./set1.py
s1 = set(['a', 'c', 'b']) s2 = set(['c', 'b', 'd'])
s1 - s2 = set(['a'])
s1 | s2 = set(['a', 'c', 'b', 'd'])
s1 & s2 = set(['c', 'b'])
s1 ^ s2 = set(['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:
Methode | Beschreibung |
---|---|
s1.difference(s2) | Differenzmenge, s1 - s2 |
s1.intersection(s2) | Schnittmenge, s1 & s2 |
s1.issubset(s2) | Teilmenge, s1 <= s2 |
s1.issuperset(s2) | Obermenge, s1 >= s2 |
s1.union(s2) | Vereinigungsmenge, s1 | s2 |
s1.symmetric_difference(s2) | Symmetrische Differenz, s1 ^ s2 |
s.add(E) | Fügt dem Set s das Element E hinzu |
s.remove(E) | Entfernt das Element E aus dem Set |
Dictionaries
[Bearbeiten]Der Typ Dictionary 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:
#!/usr/bin/python
personal = {'Tom' : 32000, 'Beate' : 44000, 'Peter' : 10000}
print personal
print "Tom verdient %d Euro pro Jahr" % (personal['Tom'])
user@localhost:~$ ./dict1.py
{'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.
#!/usr/bin/python
personal = {'Tom' : 32000, 'Beate' : 44000, 'Peter' : 10000}
print personal
print "Susi kommt dazu...",
personal['Susi'] = 10000
print personal.keys()
print "Peter hat einen anderen Job gefunden..."
del personal['Peter']
print personal.keys()
print "Tom bekommt mehr Geld: ",
personal['Tom'] = 33000
print personal
user@localhost:~$ ./dict2.py
{'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:
Funktion | Beschreibung |
---|---|
get(Schlüssel) | Liefert den Wert für Schlüssel |
has_key(Schlüssel) | True, wenn Schlüssel vorkommt |
items() | Gibt den Inhalt als Liste von Tupeln zurück |
pop(Schlüssel) | Gibt den Wert für Schlüssel zurück, entfernt dann Schlüssel/Wert |
keys() | liefert alle Schlüssel als Liste |
values() | analog zu keys(), liefert alle Werte als Liste |
Im Kapitel Datenbanken lernen Sie eine Datenbank kennen, die wie ein Dictionary funktioniert.
Besonderheiten beim Kopieren
[Bearbeiten]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:
#!/usr/bin/python
liste1 = [1, 2, 3]
liste2 = liste1
liste2 += [5]
print liste1
print liste2
Statt zweier unterschiedlicher Listen bekommen wir dieses erstaunliche Ergebnis:
user@localhost:~$ ./kopieren1.py
[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[3] 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:
#!/usr/bin/python
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:
user@localhost:~$ ./kopieren2.py
(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
[Bearbeiten]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:
Funktion | Konvertiert von | Konvertiert nach | Beispiel |
---|---|---|---|
int() | String, float | ganze Zahl | int("33") |
float() | String, int | Fließkommazahl | float(1) |
unicode() | String, Zahl | Unicode String | unicode(3.14) |
ord() | Zeichen | ganze Zahl | ord('A') |
Typenabfrage
[Bearbeiten]Den Typ einer Variablen kann man mit Hilfe der Funktion type() abfragen:
#!/usr/bin/python
print type(3)
print type('a')
print type(u"Hallo, Welt")
print type(("Hallo", "Welt"))
print type(["Hallo", "Welt"])
print type({"Hallo" : 1, "Welt" : 2})
user@localhost:~$ ./typenabfrage1.py
<type 'int'>
<type 'str'>
<type 'unicode'>
<type 'tuple'>
<type 'list'>
<type 'dict'>
Konstanten
[Bearbeiten]Konstanten in Python sind nichts als spezielle Vereinbarungen. Man schreibt sie groß, dann wissen alle an einem Programm beteiligten Personen, dass dies eine Konstante ist. Das folgende Beispiel zeigt, wie das geht:
#!/usr/bin/python
KONSTANTE = 3
print "Meine Konstante ist:", KONSTANTE
Eine Ausgabe kann hier entfallen, das Programm ist schlicht zu trivial. Diese Art der textuellen Vereinbarung wird uns noch im Kapitel Rund um OOP begegnen. Eine Konstante ist also nicht anderes als eine Variable, 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
[Bearbeiten]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
[Bearbeiten]- ↑ 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?
- ↑ Um mehr Hintergrundinformationen über komplexe Zahlen zu bekommen, empfehlen wir ihnen das Wikibuch Komplexe Zahlen.
- ↑ Mehr über Module und deren Anwendungen findet sich im Kapitel Python unter Linux: Module