====== Besonderheiten ======

  * Python markiert Anweisungsblöcke durch einrücken
      * Es gibt keine { } oder Spezialwörter die einen Anweisungsblock (zum Beispiel nach einem if-Statement) eingrenzen
  * Python betrachtet Zeilenumbrüche als Ende einer Anweisung
      * Es kennt kein ; um eine Anweisung als zu Ende zu markieren

====== Technisches ======

===== Variablen, Instanzen, Referenzen =====

  * Referenzen -> Zeiger die auf eine Instanz verweisen
      * auch bekannt als Bezeichner/Variablenname
  * Instanz -> ein konkretes Objekt von einem Typ
      * auch bekannt als Variable, Wert usw.
      * also eine konkrete Stelle im Speicher/ein konkretes Objekt
  * Variablennamen sind in Python Referenzen auf eine Instanz
      * verweisen also auf einen Speicherbereich
  * =-Operator weißt einem Bezeichner (Variablenname) eine Referenz zu 
  * verweisen zwei Referenzen auf die gleiche Instanz und wird eine geändert - wird eine zweite Instanz angelegt die den neuen Wert enthält und die geänderte Referenz verweist auf die neue Instanz
      * so lange beide Referenzen unverändert sind -> gleiche Instanz
      * wenn Instanz über eine Referenz geändert wird -> wird eine Kopie der Instanz angelegt

<code>
a=5
b=a
</code>
a und verweisen auf die gleiche Instanz - print würde in beiden Fällen 5 ausgeben.

<code>
a=5
b=a

a=a+1
</code>
a und b verweisen zuerst auf die gleiche Instanz (print würde bei beiden 5 ausgeben).\\
Nach dem a um 1 erhöht wurde verweisen a und b auf unterschiedliche Instanzen, a würde 5 ausgeben, b 6.

====== Hilfsprogramme ======

^Name ^Beschreibung ^
|pydoc|Dokumentation zu python \\ \\ Syntax: pydoc //Funktionsname//|
|pip|Paketmanager - erlaubt es Pakete zu installieren und zu verwalten \\ \\ Greift Standardmäßig auf pypi.python.org/ (Verzeichnis von Paketen) zu \\ \\ **Hinweis:** Es empfiehlt sich python-dev (Entwicklungsdateien für python) zu installieren - einige Pakete müssen kompiliert werden und benötigen diese|

====== Datentypen  ======

  * Mutable -> Veränderliche Datentypen -> Datentypen die nach der Deklaration noch geändert werden können
  * Immutable -> Datentypen die nach der Deklaration nicht mehr verändert werden können
      * wobei hier zu beachten ist, dass veränderbar sich nicht auf die Variable bezieht, sondern auf den Speicherbereich auf welchen sie verweis
      * das bedeute wird ein immutable geändert verändert sich der Speicherbereich auf den er verweist und enthält den neuen Wert
      * Variable in Python die auf ein immuteable verweisen sind "Copy on Write" -> in dem Moment in dem auf sie geschrieben wird, wird ein neuer Speicherbereich referenziert mit dem neuen Wert auf den sie ab dann verweisen


**Praktisch:**

  * int sind immutable
  * wird in einer Varibalen vom Typ int 4 gespeichert und per "+= 1" die Variable um 1 erhöht, wir ein neuer Speicherbereich mit dem Wert 5 erstellt

<code>
#a ist vom Typ int und wird der Wert 4 zugewiesen
a=int(4)
#b ist vom Typ int, aber leer
b=int()
#b wird a zugewiesen - a und b haben den gleichen Wert
b=a
#Abfrage des Speicherplatzes auf den b verweist 
id(b)
152711856
#Abfrage des Speicherplatzes auf den a verweist
id(a)
152711856
#Erhöhen von b um 1
b+=1
#Abfrage des Speicherplatzes auf den b verweist 
id(b)
152711844
#Abfrage de Speicherplatzes von a
id(a)
152711856
</code>

  * A und B verweisen nach dem ändern von B auf verschiedene Speicherbereiche 



===== Sequentielle Datentypen =====

  * Datentypen bei denen die Informationen sequentiell (nacheinander) abgelegt sind

^Name ^Beschreibung ^
|unicode|Eine Unicode-Zeichenkette |
|str|Eine Byte-Kette/eine ASCI-Zeichenkette \\ \\ Speichert (im Gegensatz zu Unicode) die Daten Byte-Genau, man kann darin also Binärdaten speichern|
|list|Eine geordnete Liste von beliebigen Objekten/Datentypen \\ \\ Geordnet -> die Reihenfolge in der die Objekte gespeichert wurden wird beibehalten (hat nichts mit sortiert zu tun)|
|tuple|Immutable (unveränderliche) Liste - kann nach der Deklaration nicht mehr verändert werden|


==== Sequentielle Operatoren ====

  * Alle sequentielle Datentypen unterstützen die unten stehenden Operationen

^Operator ^Beschreibung ^
|+|Verknüpft zwei sequentielle Objekte nacheinander \\ \\ a="Hallo " \\ b="Mensch" \\ c=a+b \\ print c \\ "Hallo Mensch" |
|+=|Verknüpft zwei sequentielle Objekte nacheinandern und weißt dem links stehenden das Ergebnis zu \\ \\ a="Hallo " \\ b="Mensch" \\ a+=b \\ print a \\ "Hallo Mensch" |
|*|Wiederholt den Inhalt des sequentiellen Objektes n mal \\ \\ \\ **Syntax:** a * n \\ \\ <WRAP> 
  * a -> sequentielles Objekt
  * n -> Ganzzahl
</WRAP> <code>
a="Hallo"
b=a*5
print b
HalloHalloHalloHalloHallo
</code> |
|*=|Wiederholt den Inhalt des sequentiellen Objektes n mal und weist das Ergebnis ihm zu \\ \\ **Syntax:** a * n \\ \\ <WRAP> 
  * a -> sequentielles Objekt
  * n -> Ganzzahl
</WRAP> <code>
a="Hallo"
a*=5
print a
HalloHalloHalloHalloHallo
</code> |
|in|Prüfung ob ein Wert im seriellen Objekt vorkommt - liefert true oder false \\ \\ \\ Syntax: a in b  \\ \\  <WRAP>
  * a -> Wert der gesucht wird
  * b -> Objekt in dem gesucht wird
</WRAP> \\ Liefert true (Wert ist im seriellen Objekt) oder false (Wert ist nicht im seriellen Objekt)|
|not in|Prüft ob ein Wert **nicht** im seriellen Objekt vorkommt - liefert true oder false \\ \\ \\ Syntax: a not in b \\ \\ <WRAP>
  * a -> Wert der gesucht wird
  * b -> Objekt in dem gesucht wird
</WRAP> |
|len(s)|Liefert die Anzahl der Elemente des seriellen Objektes (s) zurück \\ \\ \\ Syntax: x=len(s) \\ \\ <WRAP>
  * s -> das Objekt dessen Anzahl Elemente festgestellt werden soll
</WRAP> |
|min(s)|Gibt den kleinsten Wert im seriellen Objekt zurück \\ \\ Geht nur wenn sich die Objekte innerhalb des seriellen Objektes sortieren lassen. Also zum Beispiel Strings, Unicode oder Zahlen in einem list oder dict (da werden die Keys genutzt) zum Beispiel. \\ \\ \\ Syntax: len(s) \\ \\ <WRAP>
  * s -> das serielle Objekt aus dem das kleinste Objekt/Wert/Element ermittelt werden soll
</WRAP> |
|max(s)|Gibt den größten Wert im seriellen Objekt zurück \\ \\ Geht nur wenn sich die Objekte innerhalb des seriellen Objektes sortieren lassen. Also zum Beispiel Strings, Unicode oder Zahlen in einem list oder dict (da werden die Keys genutzt) zum Beispiel. \\ \\ \\ Syntax: max(s) \\ \\ <WRAP>
  * s -> das serielle Objekt aus dem das größte Objekt/Wert/Element ermittelt werden soll
</WRAP> |
|sum(s)|Summiert die Werte im seriellen Objekt (also deren Werte, nicht deren Anzahl|
|s[x]|Auch bekannt als Sub-Operator. \\ Ermöglicht den Zugriff auf das xte Element innerhalb eines seriellen Objektes \\ \\ \\ Syntax: s[x] \\ \\ <WRAP>
  * s -> das serielle Objekt 
  * x -> das Element auf welches man zugreifen möchte/dessen Inhalt man haben will - **Achtung:** Die Zählung beginnt bei 0 \\ \\
Man kann innerhalb des Suboperators auch Operationen ausführen:
<code>
s[x-1]
</code>
In dem Beispiel würde der Wert aus x - 1 berechnet und das Ergebnis als Index verwendet.
</WRAP> |
|s[x:y]|Zugriff auf auf Bereich von Elementen innerhalb eines seriellen Objektes \\ \\ \\ Syntax: s[x:y] \\ \\ <WRAP>
  * s -> serielle Objekt auf das zueggriffen werden soll
  * x -> Optional; Erstes Element des Bereiches - **Achtung:** Zählung beginnt bei 0
      * Wird es nicht angegeben wird der Bereich beim 0en (ersten) Element begonnen
          * Notation: s[:y] -> a[:5]
  * y -> Optional; Gesamtanzahl der auszugebenden Elemente - **Achtung:** Das erste Element zählt mit in die Anzahl; das letzte zurück gegebene Element ist also x+y-1
      * Wird es nicht angegeben wird der Bereich bei x begonnen und geht bis zum letzten Element
          * Notation: s[x:] -> a[2:] \\ \\
Auf diese Weise können auch die so adressierten Elemente gelöscht werden: del s[x:y:z). \\
Oder ersetzt werden: a[x:y:z]=value

</WRAP> |
|s[x:y:z]|Zugriff jedes z'ste Element innerhalb eines definierten Bereiches eines seriellen Objektes - Schrittdefinition \\ \\ \\ Syntax: s[x:y:z] \\ \\ <WRAP>
  * s -> serielle Objekt auf das zueggriffen werden soll
  * x -> Optional; Erstes Element des Bereiches - **Achtung:** Zählung beginnt bei 0
      * Wird es nicht angegeben wird der Bereich beim 0en (ersten) Element begonnen
          * Notation: s[:y:z] -> a[:5:2]
  * y -> Optional; Gesamtanzahl der auszugebenden Elemente - **Achtung:** Das erste Element zählt mit in die Anzahl; das letzte zurück gegebene Element ist also x+y-1
      * Wird es nicht angegeben wird der Bereich bei x begonnen und geht bis zum letzten Element
          * Notation: s[x::z] -> a[2::2]
  * z -> Schrittzahl aka jedes wie vielte Element im gewählten Bereich soll berücksichtigt werden
      * 1 bedeutet jedes Element des seriellen Objektes wird genommen, 2 -> jedes zweite (also 1,3,5 usw.)
      * kann auch alleine angegben werden - es wird dann das gesamte serielle Objekt schrittweise durchlaufen
          * Notation: s[::z] -> a[::2]
\\ \\
Auf diese Weise können auch die so adressierten Elemente gelöscht werden: del s[x:y:z). \\
Oder ersetzt werden: a[x:y:z]=value
</WRAP> |
|s[y][y]|Zugriff auf Unter-Elemente eines Objektes/Elements innerhalb eines sequentiellen Objektes - Zugriff auf inneinander verschachtelte Elemente/sequentielle Objekte \\ \\ \\ Syntax: a[x][y] \\ \\ <WRAP> 
  * x -> Index/x-te Element in a 
  * y -> Index/y-te Element des x-ten Elements von a 
</WRAP>|


===== Set =====

Bringen spezielle Operatoren mit die u.a. erlauben Mengen zu:

  * vergleichen
  * auf Übereinstimmung zu prüfen
  * auf Differenzen zu prüfen
  * zu prüfen ob eine Menge eine Teilmenge einer anderen menge ist

|set|Menge - jedes Elememt darf nur einmal vorkommen|
|frozenset|Immutable (Unveränderliches) set - kann nach der Deklaration nicht mehr verändert werden|


===== Mapping =====

  * in Python Standard-Mapping: Dictionary
  * Speichert Key-Value-Pairs aka Wert-Paare
====== Sprachkonstrukte  ======
===== Funktionen =====

  * Entsprechen weitgehenst Methoden (siehe unten)
  * sind eigenständige Objekte

===== Methoden  =====

Syntax: 
<code>
def Funktionsname (Parameter1,Parameter2):
    Funktionscode
    return //Variable//
</code>

Methodenaufruf:
<code>
Rückgabevariable=Funktionsname(Parameter1, Parameter2)
</code>

  * Rückgabevariable: Optional Variable die einen eventuellen Rückgabewert der Funktion aufnimmt
  * Funktionsname: Name der Funktion
  * Parameterx: Parameter die an die Funktion übergeben werden; Als bennannter Parameter in beliebiger Reihenfolge -> Parametername=Wert, Parameter2=Wert2, oder als unbenannte Parameter in Reihenfolge -> Parameter1, Parameter2 usw. 
      * **Achtung**: Alle Variablen werden als Referenz übergeben - bei mutable (veränderlichen Datentypen) wird bei Veränderungen innerhalb der Methode auch die Variable die übergeben wurde mit geändert -> soll das verhindert werden sollte innerhalb der Methode eine Kopie gemacht werden
  * return: Optional, Gibt beim herausspringen den Wert/Variable hinter return zurück.







==== Optionale Parameter  ====

  * In der Literatur/Dokumentation als Parameter1,Parameter1[,Parameter3, Parameter4] dargestellt -> Parameter1 und 2 sind dabei anzugeben, 3 und 4 sind optional

Syntax:
<code>
def Funktionsname (Parameter1, Parameter2=Wert2, Parameter3=Wert3):
    Funktionscode
</code>

Parameter 2 und 3 sind optionale Parameter, wird kein Wert für sie angegeben, wird der Wert in der Funktionsdefinition genutzt. \\
Es bietet sich an optionale Parameter ans Ende der Funktion zu schreiben, dann ist auch beim weglassen eines Parameters noch eine Parameterübergabe ohne Bezeichner möglich.


==== Benannte Parameter  ====

  * Ermöglicht das angeben von Parametern in beliebiger Reihenfolge

Syntax:
<code>
def Funktionsname (Parameter1, Parameter2):
      Code
      
Funtionsname(Parameter1=Wert1, Parameter2=Wert2)
</code>

  * Parameter 1 und 2 sind Referenzen/Bezeichner/Variablennamen
  * über den Parameternamen können die Paraemter direkt angesprochen werden



==== Beliebige Anzahl Parameter  ====

  * Bei Defeinition der Methode wird der letzte Parameter *//Parametername// angeben
      * dieser Parameter kann dann beliebig viele Argumente aufnehmen
  * das geht nur beim letzten Parameter in der Parameterliste
  * die einzelnen Werte in dem Parameter werden in einem Tuppel gespeichert
      * der Abruf der einzlnen Werte kann zum Beispiel durch eine for-each-Schleife (for x in y) erfolgen

Syntax:

<code>
def //methodenname// (//Parameter1//,//Parameter2//,*//Parameter3//):
     Code

//methodenname//(//Wert1//, //Wert2//, //Wert3//, //Wert4//, //Wert5//)
</code>

  * //Parameter 3// hat ein vorangestellten * und nimmt alle Werte auf die überzählig sind (mehr sind als es Parameter gibt)
      * in diesem Beispiel sind das die Werte 1-5

Beispiel:

===== Klassen  =====

  * Klassen sollten (wenn sie nicht von einer anderen Klasse erben) von Object erben 
      * Object implementiert einige nützliche Funktionen -> u.a. kann nur wenn von Object geerbt wurde per type(Objekt) der Typ (Klassenname) abgerufen werden


==== Klassenvariablen  ====

  * Variablen die die global über alle Objekte der Klasse existieren
  * diese Variablen existieren nur einmal für alle Objekte der Klasse zusammen
      * wird in einem Objekt der Inhalt der Variable geändert, ändert er sich in allen Objekten der Klasse 
  * Klassenvariablen werden unmittelbar nach der Klassendeklaration definiert

Syntax:
<code>
class test(object):
   a=list([1,2,3,]
</code>

  * a ist in diesem Fall eine Klassenvariable


==== Objektvariablen  ====

  * Variablen die innerhalb des Objektes global verfügbar sind
  * Jedes Objekt/Instanz der Klasse hat diese Variablen für sich alleine
      * ändert sich der Wert innerhalb eines Objektes, ändert er sich nicht in den anderen Objekten
  * Objektvariablen werden in der __init__-Methode defklariert
  * Objektvariablen werden über self.Variablenname angesprochen
      * self -> Verweis auf das aktuelle Objekt

Syntax:
<code>
class test (object):
   def __init__(self):
      self.a=list([1,2,3,4,5])
</code>


==== Überladen  ====

  * Überladen von Methoden ist in Python nicht vorgesehen
  * Abhilfe kann man durch mehrere Methoden schaffen oder
  * durch Parameter die man per Default auf none setzt, von denen nur ein teil gesetzt wird und wo man anschließend prüft welche der parameter gesetzt wurden


==== Überschreiben  ====

  * Überschreiben von Methoden geht
  * man definiert die gleiche Methode die man geerbt hat ein zweites mal -> damit ist sie überschrieben


==== Private Variablen/Methoden  ====

  * Gibt es in Python nicht
  * Es gibt die Konvention das Variablen/Methoden auf die nicht direkt zugegriffen werden darf _Variablenname geschrieben werden

Syntax: _Variable=Type() \\
Syntax: def _Methodenname(self)

==== Statische Variablen/Methoden  ====

**This section is not tested and based on assumptions:**

  * Werden per %%_%%_Methodenname deklariert
  * sind vorhanden ohne das eine Instanz der Klasse geschaffen wurde

==== Spezialmethoden  ====

  * Es gibt einige Methoden die nur durch den Compiler aufgerufen werden sollen
  * Diese werden mit %%_%%_Methode%%_%%_ deklariert

Syntax:  def %%_%%_init%%_%%_()
===== Funktionen =====

^Name ^Beschreibung ^
|print|Ausgabe von Text auf dem Bildschirm \\ \\ Syntax: print //Text// \\ \\ <WRAP>
  * Kommagetrennte Abschnitte resultieren in Leeruzeichen zwischen den Abschnitten
      * print "Hallo","%s" %Name -> "Hallo Name"
  * Nach dem Ende einer Print-Anweisung folgt ein Zeilenumbruch
      * mit einem "," am Ende erfolgt kein Zeilenumbruch in der Ausgabe
<code>
print "Hallo",
print "Mensch"
</code>
Obiges Beispiel ergibt: "Hallo Mensch" (ohne Zeilenumbruch, wegen des "," am Ende \\ \\ \\ 
Ausgabe in Dateien:
\\
Syntax: print >> //Dateiobjekt//, //String// \\ \\ 

Wichtig ist das //Dateiobjekt// kommt zuerst, durch Komma getrennt kommt danach der zu schreibende //String//. \\
**Hinweis:** Es ist wichtig in welchem Modus die FDatei geöffnet wird. Wird open() mit "w" geöffnet wird eventuell bestehender Inhalt in der Datei überschrieben. Wird es mit "a" geöffnet (append) wird der neue Inhalt angefügt - der bestehende Inhalt bleibt bestehen
</WRAP>|
|input|Liest Text auf der Kommandozeile ein - die Eingabe wird durch das Drücken von <Enter> beendet \\ \\ Syntax: //Variable//=input (//Ausgabetext//) \\ \\ <WRAP>
  * //Variable// -> Bezeichner der auf die eingelesenen Daten verweist
  * //Ausgabetext// -> Optionaler Text der direkt vor der Eingabe erscheint
</WRAP> **Achtung:** input interpretiert die Eingaben bevor sie in die Variable übergeben werden - aus der Eingabe 1+1 würde 2 werden; lalal -> würde als Zugriff auf die Variable "lala" interpretiert werden (was zum Programmabbruch führt wenn diese nicht existiert). Es empfiehlt sich in der Regel raw_input statt input zu benutzen!|
|raw_input|Liest Text auf der Kommandozeile ein - die Eingabe wird durch das Drücken von <Enter> beendet \\ \\Im Gegensatz zu input wird die Eingabe nicht interpretiert, sondern wie eingegeben abgelegt. \\ \\ Syntax: //Variable//=raw_input (//Ausgabetext//) \\ \\ <WRAP>
  * //Variable// -> Bezeichner der auf die eingelesenen Daten verweist
  * //Ausgabetext// -> Optionaler Text der direkt vor der Eingabe erscheint

**Hinweis:** Über die Konvertier-Funktionen (also zum Beispiel int()) kann die Eingabe vor dem Speichern bereits einen bestimmten Typ erhalten: \\
a=int(raw_input()) 
</WRAP> |
|open|Öffnet eine Datei zum lesen oder schreiben \\ \\ Syntax: //Dateiobjekt//=open("//Dateiname//","//Modus//") \\ \\ <WRAP>
  * //Dateiobjekt// -> Variable die eine Referenz auf die Datei aufnimmt
  * //Dateiname// -> gesamter Pfad zur gewünschten Datei
  * //Modus// -> Für was die Datei geöffnet erden soll. \\ r -> Lesen, w -> Schreiben, a -> Daten an das Ende anfügen, r+ -> Lesen und Schreiben, w+ -> Schreiben und lesen - vorher die Datei leeren, a+ Anfügen und Datei zum lesen öffnen. \\ Die Optionen gibt es auch mit vorangestelltem b - in dem Fall werden die Dateien binär geöffnet 
</WRAP> |
|type (Objekt)|Gibt den Typ (die Klasse) eines Objektes zurück|
|dir(Objekt)|Gibt alle Methoden eines Objektes zurück|

====== HowTos ======

===== Arbeiten mit Dateien =====

Eine Datei in Python wird durch ein Dateiobjekt repräsentiert. \\
Beim öffnen einer Datei durch die eingebaute Methode open() wird eben jenes Dateiobjekt zurückgeliefert. \\
Alle Operationen, wie lesen und schreiben sind Methoden dieses Dateiobjektes. \\ \\
Viele Operationen beziehen sich nicht auf die ganze Datei, sondern nur eine bestimmte Anzhal Bytes oder Zeilen.
Dabei wird ab der Stelle die Aktion durchgeführt an der sich der Zeiger innerhalb der Date befindet - es gibt also immer eine bestimmte Stelle an der man innerhalb der Datei steht. \\ Diese verschiebt sich, zum Beispiel nach einem readline an den Beginn der nächsten Zeile. \\ Per tell() kann man sich die aktuelle Position geben lassen und per seek eine Position setzen. \\ \\ Schreiboperationen werden nicht immer sofort auf die Platte geschrieben, sondern landen eventuell erst im Schreibpuffer des Betriebsyystems -> die Date enthält dann noch nicht den geänderten Inhalt. Per flush() oder close() wird die Datei auf die Festplatte geschrieben. \\ \\
Dateiobjekte können ein Iterable mit den Zeilen der Datei zur Verfügung stelen, damit wird es u.a. möglich eine Datei folgendermaßen Zeile für Zeile zu durchlaufen:
<code>
fobj=open("/tmp/somefile","r")
for line in fobj:
  print line
fobj.close()
</code>
\\ 
Per Default schreibt Python Daten hintereinanderweg in die Datei, auch wenn sie aus verschiedenen Schreiboperationen stammen, es wird standardmäßig kein Zeilenumbruch gemacht:
<code>
fobj=open("/tmp/somefile","r")
fobj.write("Hallo ")
fobj.write("Mensch")
</code>
Beide Strings stehen in der Date hintereinander: Hallo Mensch, ohne Zeilenumbruch. \\
Man kann in die Strings Steuerzeichen einfügen, wie "\n" -> es gibt je nach Platform verschiedene Steuerzeichen für Newline. \\
<code>
<code>
fobj=open("/tmp/somefile","r")
fobj.write("Hallo \n")
fobj.write("Mensch")
</code>
In diesem Fall stehen Hallo und Mensch auf verschiedenen Zeilen in der Datei (untereinander). \\
Um nach dem lesen aus der Datei die Steuerzeichen wieder zu entfernen hat die String-Klasse die Methode "strip()" die eine Kopie des Strings zurückgibt, ohne Zeilenumbruch am Ende (Hinweis: die Methode entfernt weitere Steuerzeichen).
\\ \\
^Methode ^Funktion ^
|open(//Dateipfad//,//Modus//)|Öffnet eine Datei. \\ Rückgabewert ist ein Dateiobjekt \\ \\ Modi: <WRAP>
  * r -> Read/Lesen
  * w -> write/schreiben
      * Achtung: Ist die Datei bereits vorhanden wird sie überschrieben
  * a -> Append/Anfügen
      * Fügt die neuen Daten (per Default) an das Ende der Datei an

Zusätzlich kann man bei "r" und "w" ein "+" anfügen. Die Datei ist dann zum lesen und zum schreiben geöffnet. \\ Ein angehängtes b öffnet die Datei im Binärmodus
\\ \\ 
Beispiel: open("/tmp/test","w")
</WRAP> |
|write(//String//)|Schreibt einen String in eine Datei \\ \\ Zwischen zwei Strings die geschrieben werden, wird nicht automatisch ein Zeilenumbruch in der Datei hinzugefügt -> der muss gegebenenfalls (zum Beispiel als \n) vorher in den String geschrieben werden. |
|writelines(Iterateable of Strings)|Nimmt ein Objekt entgegen welches interable ist und Strings zur Verfügung stellt. \\ Solche Objekte sind zum Beispiel Listen. \\ \\ Die einzelnen String werden hintereinander Weg in die Datei geschrieben, es wird kein Newline/Zeilenumbruch zwischen den Strings gesetzt - wenn keine entsprechenden Steuerzeichen in den Strings selbst vorhanden sind. \\ \\ \\  Beispiel: <WRAP>
<code>
a=list(["eins","zwei","drei"])
fobj=open("/tmp/test","w")
fobj.writelines(a)
fobj.close()
</code>
</WRAP> |
|read(//Size//)| <WRAP>
Ließt Daten aus einer Datei, liefert einen String mit den gelesenen Daten zurück \\ \\ 
Size ist die zu lesende Anzahl Bytes. Der Parameter ist optional, wird er nicht angegeben wird bis zum Ende der Datei (EOF) gelesen.
\\ \\
Beispiel: a=fobj.read()
\\ 
a -> enthält den gelesenen String \\
fobj -> das Dateiobejkt welches von open zurückgegeben wurde \\
Size -> Optionaler Parameter der die Länge in Byte angibt die gelesen werden soll 
</WRAP>|
|readline(//Size//)|Ließt eine Zeile aus der Datei - optionaler Parameter Länge in Bytes die zu lesen sind \\ \\ Eine Zeile definiert sich bis ein Newline (Steuerzeichen welches das Ende einer Zeile markiert, es gibt verschiedene Standards die systemabhängig sind) kommt. \\ Der Zeiger steht danach hinter dem letzten gelesenen Zeichen/am ersten der nächsten Zeile. Ein erneutes Aufrufen von readline liefert also die nächste Zeile. \\ \\ Beispiel: a=fobj.readline() |
|readlines()|Ließt alle Zeilen einer Datei aus und gibt sie als Liste von Strings zurück|
|tell|Gibt die derzeitige Position in der Datei an (Integer)|
|seek|Spingt an eine bestimmte Psoition der Datei|


===== Benutzen von anderen Zeichensätzen =====

Standardmäßig akzeptiert Python nur Zeichen des ASCII-Zeichensatzes im Code (alle anderen Zeichen müssen per Escape-Sequenz angegeben werden). \\ \\
<code>
#coding=utf-8
</code>

Mit dem Kommentar #coding=Charset in der ersten oder zweiten Zeile einer Datei setzt den Zeichensatz auf den angegebenenen.

Hinweis: Der verwendete Editor muss ebenfalls in UTF8 kodieren können (siehe [[vim]]
====== Troubleshooting ======

^Problem ^Mögliche Lösung/Ursache ^
|type gibt instance zurück| Anstatt des Objekttypes/Variablenttypes gibt type(Variablenname) instance zurück. \\ \\ Die Klasse hat nicht von Object geerbt. Die Object-Klasse implementiert die notwendige Funktionalität für type.|

====== Compiler-Medlungen ======

^Meldung  ^Mögliche Lösung ^
|NameError: global name x is not defined| Wahrscheinlich Attribut in Klasse deklariert (Variable in Klasse) und ZUgriff erfolgt innerhalb einer Methode/Funktion der Klasse ohne voran gestelltes self (self.Name)|
|IndentationError: expected an indented block| Entweder Code außerhalb eines Blockes eingerückt (Blöcke beginnen hinter einer Anweisung und :) oder einen Block begonnen und keinen (eingerückten) Code hineingeschrieben |
|global name 'self' is not defined|Self wird innerhalb von Klassen benutzt um auf Klassen-Methoden/Funktionen oder Klassen-Attribute/Variablen zuzugreifen. \\ \\ Es wurde vergessen in der Methode die self aufruft als ersten Parameter self entgegen zu nehmen. \\ \\ \\ Beispiel, hier gibt es das Problem: \\ def testmethode(a,b,c): \\ Die Methode hat keine Variable namens self die einen Verweis auf das Objekt selbst aufnehmen könnte -> self ist nicht definiert. \\ \\  \\ Beispiel so ist es richtig: \\ def testmethode(self,a,b,c): |
|IndentationError: unexpected indent|Man hat etwas eingerückt ohne das davor ein Blockstatement (wie if, class usw.) kommt.  \\ \\ In Python werden Zeilen eingerückt um ihre zugehörigkeit zu einem Block zu definieren|
|TypeError: //Methodenname// takes exactly //x// arguments (//x+y// given)|Eine Methode wurde aufgerufen und mehr Parameter angeben als die Methode erwartet maximal übergeben zu bekommen. \\ \\ Die komplette Meldung sieht zum Beispiel so aus: \\ TypeError: bla() takes exactly 2 arguments (3 given) \\ \\ \\ **Häufigster Grund:** Method eeiner Klasse aufgerufen und bei der deklaration der Methode wurde vergessen als ersten Parameter self anzugeben: \\ def testmethode(a,b): \\ Wenn man diese Methode aufruft: \\ testmethode("Hans","Wurst") \\ bekommt man: \\ TypeError: testmethode() takes exactly 2 arguments (3 given) \\ Man hat zwar explizit nur 2 Parameter "Hans" und Wurst übergeben, aber intern wird übergeben: self, "Hans", "Wurst". Self ist ein Verweis auf das Objekt selbst. \\ Richtig müsste die deklaration der Methode so aussehen: \\ def testmethode(self,a,b):|
|NameError: name 'self' is not defined|Beim deklarieren einer Methode wurde ein Parameter standardmäßig auf ein Klassenattribut gesetzt. \\ \\ Beispiel: def testmethode(parametereins=self.globaleins) \\ \\ Der Kompiler wird bei oben genanntem Beispiel meckern, weil auf self.globaleins zugegriffen wird. \\ Methodendeklarationen werden geprüft vor dem instanzieren der Klasse (also bevor es ein Objekt gibt) und damit bevor es globale Attribute/Variablen gibt. \\ \\ **Workaround:** \\ <code>
def testmethode(parametereins=None):
  if parametereins is None:
      parametereins=self.globaleins
</code> \\ \\ Der Parameter der eigentlich den Wert eines globalen Attributes/Variable bekommen sollte, wird einfach standardmäßig auf None gesetzt und in der Methode geprüft ob er None als Wert hat und wenn das der Fall ist wird ihm der Wert des globalen Attributes/Variable zugeweisen (was erst beim aufrufen der Methode passiert, was vorraussetzt das die Klasse instanziert wurde und was bedeutet das es auch globale Attribute gibt).|

====== Dokumentation/Turotials ======

^Name ^Typ ^Beschreibung ^Quelle ^
|Python Das umfassende Handbuch|Buch/Kurs|Openbook von Galileo |http://openbook.galileocomputing.de/python/|


====== Notizen ======

===== CGI =====

==== CGI FieldStorage ====

  * Dropdowns haben immer einen Wert -> ist ein Dropdown im Formular ist die Länge des CGI FieldStorages immer mindestens 1