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	ganze Zahlen	floats	complex	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

1. 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
2. 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

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"

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 

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

• 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'] 

Anhänge:

typenUndOperatoren.py

[ ]

0.3 KB