Typen und Operatoren

Konzepte

Typklassen

Immutabel: Zahlen, Strings und Funktionen
- können nicht verändert werden
- können nur auf der rechten Seite (rvalue) einer Zuweisung stehen
- so ist

a="test"
b=a[2:]

erlaubt,
hingegen führt

a[0]="T"

zur Exception

Mutabel: Dateien, Listen, Dictionaries, Klassen und deren Instanzen
- können verändert werden
- können auch auf der linken Seite (lvalue) einer Zuweisung stehen

a={}
a["1"]=1

daß Klassen mutabel sind, unterscheidet Python von Java und C++
zur Laufzeit kann die Definition einer Klasse modifizieren werden

class A:
  pass

A.b= 3
A.test = lambda self : 10

Aufrufbar: Funktionen und Klassen
Indizierbar: Tupel, Strings, Listen und Dictionaries
Sequenzen: Tupel, Strings und Listen

Zuweisung

Die Unterscheidung zwischen Referenz- und Kopiersemantik bei der Zuweisung ist in Python insbesondere auch eine Unterscheidung zwischen mutablen und immutablen Datentypen.

Durch einen Ausdruck der Form

y=x

wird nicht der Speicherinhalt der Variable kopiert, sondern nur eine neue Bindung an den Speicherinhalt erzeugt.
Da hier nur eine neue Referenz (Alias) auf das von x referenzierte Speicherobjekt erzeugt wird, spricht man von der Referenzsemantik beim Kopieren.
Wird hingegen der Speicherinhalt mitkopiert, nennt man dies Kopiersemantik .

Kopiersemantik:
- C, Pascal, C++
Referenzsemantik:
- Python, Java, C++, Fortran

Folgendes Bild soll dies noch verdeutlichen:

Referenz- versus Kopiersemantik:
der Unterschied zwischen zuweisen und kopieren

a=5
b=a
b=4

print a,b

aber

a=[5]

b=a
b[0]=100
print a,b

im ersten Fall wird ein (immutables) Objekt neu zugewiesen, hingegen im zweiten Fall ein (mutables) Objekt modifiziert
Der klassische swap Algorithmus setzt call by value voraus und führt daher bei Python call by objectnicht zu dem gewünschten Ergebnis.

def swap1(a,b):

   tmp=a
   a=b
   b=tmp

hier werden Aliase für die Aufrufargumente a,b erzeugt, die im Funktionskörper vertauscht werden
das Vertauschen der Objektreferenzen findet nur im Funktionskörper statt
führt man hingegen eine Operation auf dem referenzierten Objekte aus, so bleibt die Modifikation bestehen

def swap2(a,b):
   tmp=a
   a=b
   b=tmp
   b[0]=10

um Daten zu vertauschen, muß man auf den Objekten arbeiten

a,b=b,a

Freie Funktionen versus Methoden

alles in Python ist ein Objekt
Methoden sind an Objekte gebunden und können daher nur mit einem Objekt aufgerufen werden. Im Gegensatz hierzu erhalten freie Funktionen das Objekt als Argument.

obj=[1,2,3]

print len(obj)
obj.count(2)

während bei len(obj) die freie Funktion obj als Parameter bekommt, ruft der Ausdruck obj.count() die Methode count auf dem Objekt auf

Lebensdauer

Objekte leben, solange es eine Referenz auf sie gibt; siehe Garbage Collection

Namensraum

vereinfachend gesprochen gibt es drei Namensräume lokal, global und built in, in denen Namensbezüge in der Suchreihenfolge
lokal global built in aufgelöst werden

Datentypen

um zu sehen, welche Operationen ein Datentyp zur Verfügung stellt, hilft die Introspektionsfähigkeit von Python und eine interaktive Pythonshell

dir (5)

dir( " " )
dir ( [] )
dir( () )

dir( {} )

Einfache Datentypen - Zahlen

Folgende Datentypen stehen zur Verfügung:

Boolean Typ bool mit den Werten True und False seit Python 2.3
ganze Zahlen
- int: ganze Zahlen fester Länge, abhängig von der Python Implementierung
- long int: ganze Zahlen fast beliebiger Länge
float: Fließkommazahlen fester Länge, abhängig von der Python Implementierung
complex: Paare von floats
Python besitzt keinen Datentyp char

Numerische Operationen

Die Schreibweise und Präzedenz von Literalen entspricht der von C bzw. Java.
Die Zuweisung kann auch in der kompakteren - performanteren - Form geschrieben werden.
So sind die beiden Ausdrücke und die konkreten Beispiele äquivalent:

  <var>= <var><op><exp>
  <var><op>=<expr>

  a=a+1
  a+=1

Operationstyp	Operationen	Erläuterung
Grundoperationen	+ - * / ** % //	** (Potenzieren) % (Modulo) // (Floor Division)
Standardfunktionen	abs divmod pow	pow(x,y[,m])= (x ** y % m ) divmod(x,y)= (int(x/y),x%y)
bitweise shift	<< >>	<< bitweise verschieben nach links
bitweise Operation	& \| ^ ~	& (and) \| (or) ^ (xor) ~ (Negation)
Runden	round	round(a,b) wobei b die Tiefe darstellt

Logische Operatoren

folgende Ausdrücke evaluieren zu False, wenn sie in logischen Ausdrücken verwendet werden
- die Integer 0 und die float 0.0
- der empty Placeholder None, vergleichbar mit den Null Pointer in C
- die leere List [], das leere Tupel () und das leere Dictionary {}
- alle anderen Werte evaluieren zu True
logische not, and und orOperatoren
- der and und or Operator wird in C Manier (Kurzschlussauwertung) als Spezialfall der (lazy evaluation) immer nur soweit ausgewertet wie nötig
- so ist der Ausdruck

False and (False or True)

schon durch das erste False bestimmt

Vergleichsoperatoren: is, ==, <>, !=, <, >, <=, >=
- is testet die Objektidentität, die anderen Vergleichsoperatoren den Wert des Objekts auf Gleichheit

Zusammengesetzte Datentypen

Sequentielle Typen - Strings, Tupel und Listen

alle Sequenzen unterstützen folgende Operationen

Operation	Beschreibung
s[i]	i-te Elemente
s[i:j]	Slice von s[i] auschließlich s[j]
s[i:j:k]	vom Slice s[i:j] jedes k-te Element beginnend bei s[i]
e in s	ist e Element von s
len(s)	Anzahl der Elementen von s
min(s)	Minimum von s
max(s)	Maximum von s

bei den Operationen auf den Sequenzen sollte man folgendes beachten:
- die Indizes beginnen bei 0
- für die Parameter i,j,k eines Slices s[i:j:k]gilt:
  - i ist immer einschließlich
  - j ist immer ausschließlich zu sehen
  - k besitzt den Defaultwert 1
  - fehlende Parameter werden abhänig von k bestimmt
    1. k > 0 :
      - fehlende Parameter werden auf -sys.maxint und sys.maxint gesetzt, so daß gilt:
        s[::k] ist äquivalent zu s[-sys.maxint:sys.maxint:k]
    2. k < 0 :
      - fehlende Parameter werden auf sys.maxint und -sys.maxint gesetzt, so daß gilt:
        s[::k] ist äquivalent zu s[sys.maxint:-sys.maxint:k]
- Strings und Tupel sind immutabel, d.h. alle Operationen sind im Gegensatz zu Listen nur lesend möglich
- während der Indexzugriff gegebenfalls ein Exception wirft, gibt der Slicezugiff auf eine Sequenz eine leeren Slice zurück

mutable Sequenzen unterstützen noch die zwei zusätzlichen Löschfunktionen

Operation Beschreibung

del s[i] lösche das i-te Elemente

del s[i:j] lösche den Slice von s[i] auschließlich s[j]
- erzeuge eine Liste
  - erzeuge Schnitte dieser Liste
    - ab einer Position
    - vorwärts/rückwärts
    - nur jedes i-te Element
  - lösche einzelne Elemente/Bereiche

Operation	Beschreibung
del s[i]	lösche das i-te Elemente
del s[i:j]	lösche den Slice von s[i] auschließlich s[j]

Strings

immutable Folgen von ASCII- oder Unicode-Zeichen
Schreibweise:
- " ": native String
- r" ": raw String
- u" ": Unicode String

neben den Operationen für Strings als immutabler Sequenz, gibt's für Strings noch weitere Methoden

Operation	Beschreibung
s.capitalize()	Schreibe den ersten Buchstabe von s groß
s.center( w )	stelle s mittig in einem Feld der Länge w dar
s.count(sub[,start[,end]])	Zähle das Vorkommen eines Substrings sub
s.encode([encoding[,errors]])	Gib eine encodierte Version von s zurück
s.endswith( suffix[,start [,end]] )	Prüfe das Ende von s auf den Substring suffix
s.expandtabs( [tabsize] )	Expandiere tabs
s.find(sub[,start [,end]] )	Finde das erste Vorkommen von sub in s
s.index(sub [,start [,end]] )	Finde das erste Vorkommen von sub in s oder wirf eine Exception
s.isalnum()	Prüfe, ob alle Zeichen alphanumerisch sind
s.isalpha()	Prüfe, ob alle Zeichen alphabetisch sind
s.isdigit()	Prüfe, ob alle Zeichen Zahlen sind
s.islower()	Prüfe, ob alle Zeichen Kleinbuchstaben sind
s.isspace()	Prüfe, ob alle Zeichen whitespace sind
s.istitle()	Prüfe, ob s ein Titel ist
s.isupper()	Prüfe, ob alle Zeichen Großbuchstaben sind
s.join(t)	Verbinde die Strings in t mit s als Trenner
s.ljust(w)	Links-align s in einem String der Länge w
s.lower()	Gibt den String von s in Kleinbuchstaben zurück
s.lstrip()	Entferne führende Leerzeichen
s.replace( old, new [,maxreplace])	Ersetze von Substring von old mit new
s.rfind(sub [,start [,end]])	Finde das letzte Vorkommen von sub in s
s.rindex(sub [,start [,end]] )	Finde das letzte Vorkommen von sub in oder wirf eine Exception
s.rjust(w)	Rechts-align s in einem String der Länge w
s.rstrip()	Entferne endende Leerzeichen
s.split([sep [,maxsplit]])	Splitte s mit sep als Trenner
s.splitlines([keepend])	Splitte eine String in eine Liste von Zeilen. Falls keepend auf 1 gesetzt ist, werden folgende newlines berücksichtigt
s.startswith(prefix[,start [,end]])	Prüfe das Anfang von s auf den Substring prefix
s.strip()	Entferne führende und endende Leerzeichen
s.swapcase()	Gib einen String zurück, indem Groß- und Kleinzeichen vertauscht sind
s.title()	Gib eine Titelversion des Strings zurück
s.translate( table (, deletechars])	Gibt eine mit table übersetzten String zurück
s.upper()	Gibt den String von s in Großbuchstaben zurück

Besonderheiten

rawString

durch

 r"mein String

wird ein rawString definiert

in diesem wird ein mit \ beginnender Escapeausdruck nicht interpretiert
insbesondere beim regulären Ausdrücken und dem Öffnen von Dateien unter Windows sollten rawStrings verwendet werden:
- "C:\new\test.dat" wird sonst als "C:(newline)ew(tab)est.dat" interpretiert

unicodeString

Python unterstützt Unicode Strings
Unicode Strings werden durch

u"test"

definiert

für unicode Strings steht die ganze String Funktionalität zur Verfügung
wird ein String mit einem unicode String verknüpft, ist der resultierende String ein unicode String
durch str(u"test") bzw. unicode("test") kann zwischen den Codierungen konvertieren werden
testString="Dies ist ein Teststring."
- zerlege den String in seine Worte und baue ihn wieder zusammen
- alignden String "test" auf 40 Zeichen( links, rechts und center )
  - speichere diese Strings ab
  - schneide die Leerzeichen wieder ab
- besitzt testString das Zeichen T
- besitzt testString das Zeichen A
Veränderung mit Python 3.*

Umsetzung Python 2.* Python 3.*

8Bit String "string" b"string"

Unicode String u"string" "string"

Umsetzung	Python 2.*	Python 3.*
8Bit String	"string"	b"string"
Unicode String	u"string"	"string"

Tupel

immutable Folgen von beliebigen Objekten
Schreibweise: ()

Listen

mutable Folgen von beliebigen Objekten
Schreibweise: []
im Gegensatz zu immutablen Sequenzen, die das Ergebnis der Operation zurückgeben, wirken Listenoperationen auf der Liste
- folgender Code soll die Problematik verdeutlichen

a=[1,2,3]
a.reverse()

print a
a=a.reverse()
print a

Methode	Beschreibung
range(n)	erzeugt eine Liste [0,1,2,..,n-1]
range(n,m)	erzeugt eine Liste [n,n+1,...,m-1]
range(n,m,d)	reduziert die Liste range(n,m) auf jedes d-te Element
list(s)	Konvertiert die Sequenz s zu einer Liste
s.append(x)	hängt das Element x an die Liste an
s.extend(t)	erweitert die Liste um die Elemente von t
s.count(x)	zählt vorkommen von x in s
s.index(x)	gibt den kleinsten Index i zurück, für den gilt s[i] == x
s.insert(i,x)	fügt x am Index i ein
s.pop([i])	gibt das Element s[i] zurück und entfernt es aus der Liste. Falls i nicht angegeben wird, wird die Operation auf das letzte Argument angewandt
s.remove(x)	sucht nach x und entfernt es aus s
s.reverse()	dreht die Reihenfolge der Elemente von x in place um
s.sort([cmpfunc])	sortiert die Elemente von s gegebenfalls mit Hilfe von cmpfunc in place

Assoziative Typen - Dictionaries

Datencontainer von Paaren (key,values)
Schreibweise: { }
auch bekannt als: Dictionary, Map, Hash oder Assoziatives Array
der Zugriff auf ein Element ist konstant.

das Interface des Dictionaries

Methode	Beschreibung
len(m)	Anzahl der Elemente von m
m[k]	Gibt den Wert m[k] zurück
m[k]= x	Setze m[k] auf x
del m[k]	Entferne m[k] von m
m.clear()	Entferne alle Elemente von m
m.copy()	Gibt eine copy von m
m.has_key(k)	Existiert der Schlüssel k?
k in m	Existiert der Schlüssel k?
m.items()	Gibt eine Liste aller Paare (key,values) von m zurück.
m.keys()	Gibt eine Liste aller Schlüssel von m zurück.
m.update(b)	Füge alle Elemente vom Dictionary b zu m hinzu.
m.values()	Gibt eine Liste aller Werte von m zurück.
m.get(k[,v])	Gib m[k] zurück, falls es existiert, anderfalls v (default None)
m.setdefault(k[,v])	Gib m[k] zurück, falls es existiert, anderfalls v und setzte m[k]=v.
m.pop(k[,v])	Gib m[k] zurück, entferne das Element, falls es existiert. Wenn es nicht existiert oder kein Defaultargument angegeben wird, wirf ein Ausnahme.
m.popitem()	Entferne ein zufälliges Element (key,value) von m und gib es als Tupel zurück.

d={"red":1, "green":2, "blue":3}
- Welcher Wert hat red?
- Gibt es white?
- Falls white nicht existiert, gib 0 zurück.
- Falls white nicht existiert, gib 0 zurück und trage das Paar in d ein.
- d2={"white":0,"red":1,"purple":4}: Aktualisiere d mit d2
- Gib d nach Schlüsseln und nach Werten sortiert aus.
- Gib d nach Schlüsseln und nach Werten rückwärts sortiert aus.

Konvertierungsoperationen

Konvertierung	Beschreibung
int(x [,base] )	Konvertiert x nach int
long(x [,base] )	Konvertiert x nach long int
float(x)	Konvertiert x nach float
complex(real [,imag])	Erzeugt eine komplexe Zahl
str(x)	Konvertiert x zu einer Stringrepräsentation
repr(x)	Konvertiert x zu einem expression string Kurzform `x`
eval(str)	Wertet einen String aus und gibt ein Objekt zurück
tuple(s)	Konvertiert eine Sequenz in ein Tupel
list(s)	Konvertiert die Sequenz s in eine Liste
chr(x)	Konvertiert ein Integer zu seinem Zeichen
unchr(x)	Konvertiert ein Integer zum einem Unicode Zeichen
ord(x)	Konvertiert ein Zeichen in eine natürliche Zahl
hex(x)	Konvertiert eine natürliche Zahl in einen hexadezimal String
oct(x)	Konvertiert eine natürliche Zahl in eine oktalen String

die Konvertierungsoperationen repr und eval sind zueinander invers, so dass gilt: a=eval(repr(a))
Gib die Strings test20, test18, ....., test-4 aus

built-ins

Python bringt ein Fundus an built-in Funktionen und Klassen mit
einen einfachen Überblick ergibt

>>> dir ()
['__builtins__', '__doc__', '__name__']
>>> dir ( __builtins__ )

['ArithmeticError', 'AssertionError', 'AttributeError', 'DeprecationWarning','EOFError', 'Ellipsis', 'EnvironmentError', 

'Exception', 'False', 'FloatingPointError', 'IOError', 'ImportError', 'IndentationError', 'IndexError', 'KeyError', 

'KeyboardInterrupt', 'LookupError', 'MemoryError', 'NameError', 'None', 'NotImplemented', 'NotImplementedError', 

'OSError', 'OverflowError', 'OverflowWarning', 'ReferenceError', 'RuntimeError', 'RuntimeWarning', 'StandardError',

'StopIteration', 'SyntaxError', 'SyntaxWarning', 'SystemError', 'SystemExit', 'TabError', 'True', 'TypeError', 

'UnboundLocalError', 'UnicodeError', 'UserWarning', 'ValueError', 'Warning', 'ZeroDivisionError', '_', '__debug__', 

'__doc__', '__import__', '__name__', 'abs', 'apply', 'bool', 'buffer', 'callable', 'chr', 'classmethod', 'cmp', 'coerce', 

'compile', 'complex', 'copyright', 'credits', 'delattr', 'dict', 'dir', 'divmod', 'eval', 'execfile', 'exit', 'file', 

'filter', 'float', 'getattr', 'globals', 'hasattr', 'hash', 'help', 'hex', 'id', 'input', 'int', 'intern', 'isinstance', 

'issubclass', 'iter', 'len', 'license', 'list', 'locals', 'long', 'map', 'max', 'min', 'object', 'oct', 'open', 'ord', 

'pow', 'property', 'quit', 'range', 'raw_input', 'reduce', 'reload', 'repr', 'round', 'setattr', 'slice','staticmethod', 

'str', 'super', 'tuple', 'type', 'unichr', 'unicode', 'vars', 'xrange', 'zip']