Numerische Datentypen sind:
Beispiele:
>>> x=3
>>> type(x)
<type 'int'>
>>> x=3.0
>>> type(x)
<type 'float'>
>>> x=1+2j
>>> type(x)
<type 'complex'>
>>> x.real
1.0
>>> x.imag
2.0
>>> x.conjugate()
(1-2j)
>>> x=0
>>> y=1
>>> bool(x)
False
>>> bool(y)
True
>>> bool(1+1j)
True
>>> bool(0+0j)
False
Gleitkommazahlen vom Typ float können auch in exponentieller Form eingegeben werden, z.B. 2e5 für 200000 oder 1e-3 für 0.001
Für numerische Datentypen sind folgende arithmetische Operatoren definiert:
In Python gibt es keine Operatoren für das Inkrementieren (x++) und Dekrementieren (x--). Es sind jedoch sogenannte erweiterte Zuweisungen der Form x+=y als kürzere Form für x=x+y möglich.
Beispiele:
>>> 3+5
8
>>> 5-7
-2
>>> 5*9
45
>>> 10%3
1
>>> 10//3
3
>>> 10/3
3
>>> 10/3.0
3.3333333333333335
>>> 2**12
4096
>>> -5
-5
Für die Datentypen int, long, float und bool sind die Vergleichsoperartoren ==, !=, <, <=, > und >= anwendbar.
Umwandlungen eines zu konvertierenden Werts x in einen neuen Typ werden allgemein in der Form neuerTyp(x) geschrieben, z.B. int(x), long(x) usw. Hier einige Beispiele:
>>> x=3
>>> float(x)
3.0
>>> x=3L
>>> type(x)
<type 'long'>
>>> x=3.9
>>> int(x)
3
>>> complex(x)
(3.9+0j)
>>> bool(x)
True
Ganze Zahlen vom Typ int oder long können auch oktal oder hexadezimal eingegeben werden. Oktale Eingaben werden durch eine führende 0, hexadezimale Eingaben durch ein führendes 0x identifiziert.
Beispiele:
>>> o=077
>>> o
63
>>> h=0x1A
>>> h
26
>>> type(h)
<type 'int'>
Für die Binärdarstellung von Zahlen gibt es in Python keine explizite Eingabemöglichkeit. Jedoch sind für beliebige ganze Zahlen x und y die Bitoperationen
Instanzen des Datentyps bool können nur die Werte True oder False annehmen. Der Typ bool wird zu den numerischne Typen gezählt, weil auf boolesche Variablen alle in Arithmetische Operatoren: definierten Operationen angewandt werden können. Darüber hinaus können auf boolesche Variablen auch die logischen Operatoren
angewandt werden.
Zum booleschen Wert False wird der numerische Wert 0 ausgewertet. Ausserdem werden leere Strings, leere Listen, leere Tupel und leere Dictionaries dem booleschen Wert False zugewiesen.
In diesem Abschnitt werden die sequenziellen Datentypen in Python kurz vorgestellt. Eine detailliertere Einführung bietet z.B. http://docs.python.org/tutorial/datastructures.html
In die Kategorie der sequenziellen Datentypen fallen Datentypen, die Folgen von Elementen zusammenfassen. Die Elemente müssen nicht zwingend vom gleichen Datentyp sein. Innerhalb des sequenziellen Datentyps haben die Elemente eine definierte Reihenfolge. Auf die Elemente kann über einen Index zugegriffen werden.
Zur Kategorie der sequenziellen Datennntypen gehören:
Für alle sequenziellen Datentypen sind folgende Operationen definiert:
Eine Liste (list) kann Elemente unterschiedlichen Datentyps enthalten. Eine Liste kann auch nach ihrer Erzeugung verändert werden. Der folgende Code zeigt das Anlegen einer Liste mit Elementen unterschiedlichen Typs:
>>> l1=[2,'d',3.7,'letzte']
>>> l1
[2, 'd', 3.7000000000000002, 'letzte']
>>> type(l1)
<type 'list'>
>>> type(l1[0]),type(l1[1])
(<type 'int'>, <type 'str'>)
>>> l1[1]=1020
>>> l1
[2, 1020, 3.7000000000000002, 'letzte']
Da die Liste ein sequenzieller Datentyp ist, können auf Instanzen diesen Typs alle in Operatoren für Sequenzen definierten Operationen angewandt werden. Zusätzlich zu den dort genannten Operatoren, sind für Listen folgende definiert:
Beispiele für Operationen auf Listen:
>>> l2=[0,1,2,3,4,5,6,7,8,9]
>>> l2
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> len(l2)
10
>>> min(l2)
0
>>> max(l2)
9
>>> l3=l2[1:8:3]
>>> l3
[1, 4, 7]
>>> l2[9]=l3
>>> l2
[0, 1, 2, 3, 4, 5, 6, 7, 8, [1, 4, 7]]
>>> l2[1:3]=l3
>>> l2
[0, 1, 4, 7, 3, 4, 5, 6, 7, 8, [1, 4, 7]]
>>> len(l2)
11
>>> del l2[-1]
>>> l2
[0, 1, 4, 7, 3, 4, 5, 6, 7, 8]
>>> del l2[5]
>>> l2
[0, 1, 4, 7, 3, 5, 6, 7, 8]
Ist L eine Liste, dann wird durch C=L eine Kopie der Referenz auf die Liste, auf welche L zeigt, angelegt. D.h. C zeigt auf den gleichen Speicher wie L, jedoch werden nicht die Listenelemente kopiert. Eine flache Kopie einer Liste kann mit C=L[:] angelegt werden. Um tiefe Kopien von Listen (allgemein von Objekten) zu erstellen kann die Funktion copy.deepcopy() aus dem Paket copy verwendet werden (das Paket muss zuvor importiert werden).
Listen können nicht nur mit den genannten Operationen manipuliert werden. Für Referenzen auf Listen können auch Methoden aufgerufen werden. Es sei s eine Referenz auf ein Objekt des Typs Liste. Die auf s anwendbaren Methoden sind dann:
hängt x an das Ende der Liste an,
hängt die Elemente von x an das Ende der Liste an,
zählt wie häufig das Element x in s vorkommt,
liefert den Index an dem der Wert x erstmalig in s auftritt,
fügt x am Index i in s ein,
liefert das i.te Element der Liste und entfernt es aus dieser. Ohne Argument wird einfach das letzte Element herausgenommen,
entfernt das erste Vorkommen von x aus s,
Kehrt die Reihenfolge der Elemente in s um,
sortiert Liste nach aufsteigenden Werten. Mit s.sort(reverse=True) wird Liste absteigend sortiert.
Beispiele für Methoden auf Listen:
>>> s=[5,3,4,8,2,1,3,3,4,2]
>>> s
[5, 3, 4, 8, 2, 1, 3, 3, 4, 2]
>>> x=[1,2,3]
>>> x
[1, 2, 3]
>>> s.append(x)
>>> s
[5, 3, 4, 8, 2, 1, 3, 3, 4, 2, [1, 2, 3]]
>>> s.pop()
[1, 2, 3]
>>> s
[5, 3, 4, 8, 2, 1, 3, 3, 4, 2]
>>> s.extend(x)
>>> s
[5, 3, 4, 8, 2, 1, 3, 3, 4, 2, 1, 2, 3]
>>> s.index(4)
2
>>> s.insert(1,9)
>>> s
[5, 9, 3, 4, 8, 2, 1, 3, 3, 4, 2, 1, 2, 3]
>>> s.reverse()
>>> s
[3, 2, 1, 2, 4, 3, 3, 1, 2, 8, 4, 3, 9, 5]
>>> s.sort(reverse=True)
>>> s
[9, 8, 5, 4, 4, 3, 3, 3, 3, 2, 2, 2, 1, 1]
Mit der range() Methode kann eine Liste von ganzen Zahlen effizient erzeugt werden. Derartige Listen werden besonders häufig in for-Schleifen als Objekt, über dessen Elemente die Zählvariable iteriert, eingesetzt. Die Definition der Range Funktion ist
Alle drei Argumente müssen ganze Zahlen sein. Die Argumente start und step sind optional. Die Funktion liefert eine Liste, deren Elemente ganze Zahlen von start bis stop in der Schrittweite step sind. Wird step nicht angegeben, dann ist die Schrittweite 1. Wird start nicht angegeben, dann ist der Startwert 0.
Beispiel:
>>> l=range(3,9,2)
>>> l
[3, 5, 7]
Da Listen Elemente beliebigen Typs enthalten können, ist es natürlich auch möglich Listen als Listenelemente zu benutzen. Damit lassen sich mehrdimensionale Arrays realisieren. Wie folgendes Beispiel zeigt:
>>> matrix= [
... [1,2,3],
... [4,5,6],
... [7,8,9]
... ]
>>> matrix
[[1, 2, 3], [4, 5, 6], [7, 8, 9]]
Auf einzelne Elemente und auf ganze Zeilen des Arrays kann wie folgt zugegriffen werden:
>>> matrix[0][2]
3
>>> matrix[0]
[1, 2, 3]
>>> matrix[0:2]
[[1, 2, 3], [4, 5, 6]]
Der Zugriff auf Spalten ist nur indirekt möglich:
>>> col1=[matrix[i][1] for i in range(len(matrix))]
>>> col1
[2, 5, 8]
Auf Listen können wie oben gezeigt relativ viele Operationen und Methoden ausgeführt werden. Diese Vielfalt bedingt jedoch auch einen relativ hohen Aufwand an notwendiger Rechenleistung. Falls die Vielfalt in der Modifikation gar nicht benötigt wird, jedoch auf Recheneffizienz zu achten ist, bietet sich der sequenzielle Datentyp Tuple an. Im Gegensatz zu Listen sind Tuple immutable, sie können also nach dem Erzeugen nicht mehr verändert werden. Genauer: Beim Erzeugen eines Tuple werden die Element-Referenzen festgelegt, die sich danach nicht mehr ändern können. Verweist jedoch eine Referenz auf ein Objekt vom Typ mutable, und ändert sich dieses Objekt, dann ändert sich auch der Inhalt der Liste.
Tuple werden nicht mit eckigen, sondern mit runden Klammern angelegt. Der Zugriff auf einzelne Elemente wird jedoch wie im Fall der Listen mit eckigen Klammern realisiert. Lässt man die umschliessenden Klammern weg, wird die Sequenz aus mit Komma getrennten Elementen inherent als Tuple angelegt.:
>>> t=(3,6,1,2,8,1)
>>> t[2]
1
>>> t[3]=0
Traceback (most recent call last):
File "<console>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
>>> x=[1,3,2,3]
>>> r=x,3
>>> r
([1, 3, 2, 3], 3)
>>> x.reverse()
>>> r
([3, 2, 3, 1], 3)
Strings sind sequenzielle Datentypen, deren Elemente Characters sind. Auf Strings können deshalb alle in Operatoren für Sequenzen definierten Operationen angewandt werden. Strings können in Python vom Typ str oder unicode sein. In dieser Einführung wird nur der Typ str behandelt. Ein String wird erzeugt indem eine Zeichenkette (ohne Zeilenumbruch) innerhalb von doppelten oder einfachen Hochkommata geschrieben wird:
>>> s1="Name Vorname"
>>> s1
'Name Vorname'
>>> s2='Strasse Hausnummer'
>>> s2
'Strasse Hausnummer'
Soll ein sich über mehrere Zeilen erstreckender String angelegt werden, ist die Zeichenkette innerhalb von dreifachen Hochkommata (doppelt oder einfach) zu schreiben. Stehen mehrere Strings unmittelbar oder durch Leerzeichen getrennt hintereinander, dann werden diese zu einem String zusammengefasst:
>>> s3='''erste zeile
... zweite zeile
... dritte zeile'''
>>> s3
'erste zeile\nzweite zeile\ndritte zeile'
>>> print s3
erste zeile
zweite zeile
dritte zeile
>>> s4='eins ' 'zwei'
>>> s4
'eins zwei'
>>> s5=('eins'
... 'zwei'
... 'drei')
>>> s5
'einszweidrei'
Neben dem bereits benutzten \n für Zeilenumbruch, sind andere wichtige Steuerzeichen innerhalb von Strings: \t (horizontaler Tab), \v (vertikaler Tab), \b (Backspace), \" (Doppeltes Hochkomma innerhalb eines String), \' (Einfaches Hochkomma innerhalb eines String).
Zusätzlich zu den für alle sequenziellen Datentypen definierten Operationen, stellt Python String-spezifische Methoden bereit, von denen einige hier aufgeführt sind. Bei der Beschreibung der Methoden wird häufig allgemein der Begriff Whitespace benutzt. Damit können neben einem Leerzeichen auch Steuerzeichen für Zeilenumbruch, vertikaler oder horizontaler Tab gemeint sein.
Für das Aufspalten von Strings in mehrere Bestandteile können u.a. folgende Methoden benutzt werden:
trennt den String s an den Stellen, wo das Trennzeichen sep in s vorkommt. Wird der Methode kein Trennzeichen als Argument übergeben, dann wird s an allen Whitespaces getrennt. Die Methode gibt eine Liste von Strings zurück.
Spaltet den String an den Zeilenumbruchstellen (\n oder \r) auf und gibt eine Liste mit der einzelnen Zeilen zurück.
>>> s6="das ist das Haus vom\nNikolaus"
>>> s6
'das ist das Haus vom\nNikolaus'
>>> s6list=s6.split()
>>> s6list
['das', 'ist', 'das', 'Haus', 'vom', 'Nikolaus']
>>> type(s6list)
<type 'list'>
>>> s6="das-ist-das Haus vom\nNikolaus"
>>> s6list2=s6.split('-')
>>> s6list2
['das', 'ist', 'das Haus vom\nNikolaus']
>>> s7="das ist \ndas Haus \nvom Nikolaus"
>>> print s7
das ist
das Haus
vom Nikolaus
>>> s7lines=s7.splitlines()
>>> s7lines
['das ist ', 'das Haus ', 'vom Nikolaus']
Suchen in Strings
In den folgenden Methodendefinitionen sind die Parameter start,end jeweils optional und legen Start- und Endposition des Intervalls fest, innerhalb dessen gesucht werden soll. Falls der Parameter nicht angegeben wird, wird im gesamten String gesucht.
liefert den Index des ersten Vorkommens von x im String s
liefert den Index des letzten Vorkommens von x im String s
Beispiele:
>>> text='Es war was war und es kommt was kommt'
>>> text.find('was')
7
>>> text.find('w',9,15)
11
>>> text.rfind('was')
28
Ersetzen von Teilstrings / Entfernen von Zeichen
ersetzt alle Vorkommen von old durch new
ersetzt alle Grossbuchstaben in s durch Kleinbuchstaben
ersetzt alle Kleinbuchstaben in s durch Grossbuchstaben
entfernt die in [char] definierten Zeichen am linken und rechten Rand von s
Beispiele:
>>> text='Es war was war und es kommt was kommt'
text.replace('war','wird')
'Es wird was wird und es kommt was kommt'
>>> text.lower()
'es war was war und es kommt was kommt'
>>> text.upper()
'ES WAR WAS WAR UND ES KOMMT WAS KOMMT'
>>> t='<tag> Das ist der gewünschte Text <tag>'
>>> t.strip('<tag>')
' Das ist der gewünschte Text '
In Python ist für Strings der Formatierungsoperator % definiert. Dieser Operator erwartet zwei Operanden: Als ersten einen String, der die Formatierung beschreibt und als zweiten eine Sequenz, in der die Werte gespeichert sind, die formatiert ausgegeben werden sollen.
Beispiele:
>>> x1=3.2
>>> x2=4.678
>>> "Punktkoordinaten sind x1 = %5.1f, x2 = %5.1f" % (x1,x2)
'Punktkoordinaten sind x1 = 3.2, x2 = 4.7'
>>> print "Punktkoordinaten sind x1 = %5.1f, x2 = %5.1f" % (x1,x2)
Punktkoordinaten sind x1 = 3.2, x2 = 4.7
Im Beispiel definert %5.1f den Ausgabedatentyp, nämlich eine Gleitkommazahl mit 5 Vor- und einer Nachkommastelle. Für ganze Zahlen ist der Ausgabedatentyp %d.
Mit Dictionarys (Python-Typ dict) wird eine Zuordnung zwischen Objektpaaren hergestellt. Ein Dictionary kann beliebig viele Schlüssel/Wert - Paare (Key/Value - Pairs) aufnehmen. Im Gegensatz zu den Listen müssen die Keys nicht ganze Zahlen, sondern dürfen beliebige Objekte sein. Das Anlegen eines Dictionary und der Zugriff auf alle/einzelne Keys und Values kann folgendem Beispiel entnommen werden:
>>> TrainElement={"feature" : (1.0,True,'kalt',2), "class" : 1, "partition" : 4}
>>> print TrainElement
{'partition': 4, 'feature': (1.0, True, 'kalt', 2), 'class': 1}
>>> TrainElement.keys()
['partition', 'feature', 'class']
>>> TrainElement.values()
[4, (1.0, True, 'kalt', 2), 1]
>>> TrainElement['partition']
4
>>> TrainElement['feature']
(1.0, True, 'kalt', 2)
>>> TrainElement['feature'][2]
'kalt'
Dictionaries sind iterierbare Objekte, d.h. sie können in einer for-Schleife durchlaufen werden. Dabei werden jedoch nur die Schlüsselelemente besucht:
>>> for a in TrainElement:
... print a
partition
feature
class
Die Länge eines Dictionaries d, also die Anzahl der in d angelegten Schlüssel/Wert Paare, kann über len(d) abgefragt werden. Mit del d[k] wird das Element mit Schlüssel k gelöscht, mit k in d kann geprüft werden, ob sich der Schlüssel k in d befindet.
Methoden die für jedes Dictionary d aufgerufen werden können sind:
löscht den Inhalt des Dictionaries
erzeugt eine Kopie von d. Die Werte des neuen Dictionary bleiben Referenzen auf die selben Objekte. Es handelt sich also um eine flache Kopie
erzeugt eine Liste, die alle Schlüssel/Wert Paare von d als Tupel enthält
liefert Liste mit allen in d definierten Schlüssel
liefert Liste mit allen in d definierten Werten
liefert den Wert zu Schlüssel k falls dieser existiert, sonst x
setzt d[k]=x, wenn der Schlüssel k in d noch nicht vorhanden ist, ansonsten liefert es den Wert von k.
damit können in einer for-Schleife alle Schlüssel/Wert-Paare durchlaufen werden
damit können in einer for-Schleife alle Schlüssel durchlaufen werden
damit können in einer for-Schleife alle Werte durchlaufen werden
Beispiele hierzu sind:
>>> for a in TrainElement.iteritems():
... print a
...
('partition', 4)
('feature', (1.0, True, 'kalt', 2))
('class', 1)
>>> TrainElement.get('class',0)
1
>>> TrainElement.setdefault('class',0)
1
>>> TrainElement.setdefault('neu','element')
'element'
>>> TrainElement
{'neu': 'element', 'partition': 4, 'feature': (1.0, True, 'kalt', 2), 'class': 1}
>>> del TrainElement['neu']
>>> TrainElement
{'partition': 4, 'feature': (1.0, True, 'kalt', 2), 'class': 1}
Eine Menge ist ein ungeordneter Zusammenschluss von Elementen, wobei jedes Element nur einmal vorkommen kann. In Python gibt es für mutable Mengen den Typ set, für immutable Mengen den Typ frozenset. In dieser Einführung wird nur das set behandelt. Die Elemente einer Menge dürfen unterschiedlichen Typs sein.
Eine leere Menge wird mit
>>> m=set()
angelegt. Alternativ kann dem Konstruktor beim Anlegen eines neuen Mengenobjektes schon ein iterierbares Objekt x (z.B. eine Liste, ein String oder ein Dictionary) übergeben werden.
>>> m=set(x)
Ist x ein Dictionary, dann enthält die angelegte Menge nur die Schlüssel von x. In der Textanalyse müssen häufig für Texte die in diesen vorkommenden Worte (Bag of Words) ermittelt werden. Dies lässt sich wie folgt bewerkstelligen:
>>> text='Es war was war und es kommt was kommt'
>>> textlist=text.split()
>>> textlist
['Es', 'war', 'was', 'war', 'und', 'es', 'kommt', 'was', 'kommt']
>>> bagOfWords=set(textlist)
>>> bagOfWords
set(['und', 'es', 'kommt', 'was', 'war', 'Es'])
Ist m ein Objekt vom Typ set oder frozenset, dann können auf m folgende Operationen ausgeführt werden:
Nur für Objekte der veränderlichen Mengen vom Typ set sind folgende Methoden definiert:
fügt das Element t in das Set m ein
löscht das Element t aus dem Set m (wird ignoriert falls t in m nicht vorhanden
löscht alle Elemente aus m
Beispiel für Mengenoperation:
>>> text='Es war was war und es kommt was kommt'
>>> textlist=text.split()
>>> häufig=[x for x in textlist if textlist.count(x)>=2]
>>> häufig
['war', 'was', 'war', 'kommt', 'was', 'kommt']
>>> einmal=set(textlist)-set(häufig)
>>> einmal
set(['und', 'Es', 'es'])
Auf die Elemente einer Menge kann nicht direkt über einen Index zugegriffen werden. Hierfür muss die Menge m wieder in eine Liste l mit l=sorted(m) transformiert werden.