MyWiki

Diese Seite ist nicht editierbar. Sie können den Quelltext sehen, jedoch nicht verändern. Kontaktieren Sie den Administrator, wenn Sie glauben, dass hier ein Fehler vorliegt.
<WRAP center round important 60%>
Zweite Seite Dokumentation Python
</WRAP>


====== Methoden ======

===== Beliebig viele Parameter (Tuppel)/Optionale Parameter =====

Es gibt zwei Arten wie man beliebig viele Parameter realisieren kann, über benannte Parameter und über Tuppel (Einzelparameter). \\ Diese Sektion beschreibt den Weg über Tuppel. \\ \\

  * kann beliebig viele Parameter übergeben bekommen
      * inklusive gar keine
  * Repräsentation erfolgt als Tuple
  * kann nur einmal pro Methode vorkommen (am Ende)
  * kann kombiniert werden mit der benannten Parameter-Funktion


Syntax Definition: 
<code>
def Methodenname (*Parametername):
     Code
</code>


Syntax Aufruf:
<code>
Methodenname (Wert1, Wert2, Wert3)
</code>

In der Methode ist dann //Parametername// (also der Name der Variablen) ein Tuple (also unveränderliche Liste im weiteren Sinne) die alle die übergebenen Werte enthält.

Man kann auch "normale" Parameter haben, in Kombination mit dieser Art Parameter -> der optionale Parameter muss am Ende der Methodendeklaration stehen:

<code>
def Methodenname (Parameter1, Parameter2, *OptionalerParameter):
     Code
</code>

In diesem Fall nimmt jeder der Parameter einen Wert auf beim Funktionsaufruf und der OptionaleParameter alle die darüber hinaus gehen.


Beispiel:
<code>
def mymethode (param1,param2,optionalparam):
    print optionalparam
    
mymethod("eins","zwei","drei","vier","funf")
</code>

Die Ausgabe wäre:
("drei","vier","funf")


====== Exceptions =======

Exceptions/Tracebacks können (wenn man sie erwartet und händeln will) durch try und except-Blöcke abgefangen werden:
\\
<code>
tr
     Code welcher eventuell eine Exception auslösen wird.
except:
     Code welcher beim Eintreten einer Exception ausgeführt werden soll.
     
</code>

Man kann sich das wie eine if-Anweisung Vorstellen - if Exception, dann führe except-Block aus.

**Achtung**: Stehen mehrere Zeilen Code im try-Block, wird nur bis zu der Zeile ausgeführt die die Exception produziert! Sind es 4 Zeilen und die Exception wird durch Zeile 2 ausgelöst, werden Zeilen 2, 3 und 4 nicht ausgeführt (2 nicht weil es da ja ne Exception gab) - statt dessen wird in den Except-Block gesprungen und danach ggf. der Code der nach dem except-Block kommt ausgeführt.

\\ \\
Die Except-Anweisung kann auch angewiesen werden nur auf bestimmte Exceptions zu reagieren:
<code>
try:
     Code der ggf. zur Exception führt.
except Exception-Klasse:
     Code zum Hanhaben der Exception
</code>

Die Exception-Klasse definiert welche Exceptions durch den except-Block abgefangen werden, alle Exceptions die nicht dort stehen führen zu einem Backtrace. \\
Es kann eine Liste von Exception-Klassen angeben werden, durch Komma getrennt.
\\ Die Klassen findet man in der Dokumentation der jeweiligen Funktion oder im Backtrace:
<code>
Traceback (most recent call last):
  File "/tmp/ex.py", line 2, in <module>
    5/0
ZeroDivisionError: integer division or modulo by zero
</code>

In obigem Traceback ist die Klasse "ZeroDivisionError".

\\ \\
Mehrere Exception-Blöcke für verschiedene Exception-Klassen des gleichen try-Blocks können ebenfalls definiert werden:

<code>
try: 
    Code der eine Exception auslösen kann
except NameError:
    print "NameError aufgetreten"
except ZeroDivisionError:  
    print "Division durch 0 geht nicht"
</code>

In obigem Beispiel würden NameError und ZeroDivisionError Exceptions jeweils durch einen eigenen Block abgefangen. \\
Würde eine Exception auftreten die weder NameError, noch ZeroDivisionError ist würde sie geraised werden (sprich durchfallen und zum Programmabruch und Traceback führen). \\

Man kann aber auch eine Art else-Zweig einbauen, der alle nicht durch einen spezifischen except-Block abgefangenen Exceptions abfängt:

<code>
try: 
    Code der eine Exception auslösen kann
except NameError:
    print "NameError aufgetreten"
except ZeroDivisionError:  
    print "Division durch 0 geht nicht"
except:
    print "Irgend eine Exception die nicht NameError oder ZeroDevisionError ist ist aufgetreten"
</code>
    
In obigem Beispiel würde der letzte except-Block alle nicht explizit durch einen anderen except-Block gehändelten Exceptions händeln.
===== Finally ======

Der Finally-Block enthält Anweisungen die egal ob eine Exception eintritt oder nicht ausgeführt werden. \\ Im Falle einer Exception (es ist dabei egal ob die Klasse im Except-Block steht oder nicht -> sprich ob der Except-Block ausgeführt würde oder nicht) wird dieser Block vor dem Springen in den Except-Block ausgeführt bzw. wenn die Klasse nicht im Except-Block steht vor dem Ausgeben der Exception und dem Abbruch des Programms. \\ Sinn ist es diese Anweisungen auf jeden Fall auszuführen - zum Beispiel um Aufräumarbeiten noch durchzuführen -> Schließen von Dateien oder Verbindungen.

<code>
try
    Code der zu einer Exception führen kann.
except <ggf. Klasse>:
    Code der im Falle einer Exception (ggf. nur wenn es die entsprechende Exception-Klasse ist) ausgeführt wird.
finally:
    Code der immer ausgeführt wird, auch im Falle einer Exception
</code>

Beispiel:

<code>
try:
        5/0
        print ("Danach")
except NameError:
        print ("Exception")

finally:
        print ("Wird noch erledigt")
print "Nach der Exception"
</code>

In obigem Beispiel wird es eine Exception mit der Klasse "ZeroDivisionError" geben, weil versucht wird mit 0 eine Division durchzuführen. \\
Die Anweisung >>print ("Danach")<< wird nicht ausgeführt, weil davor die Exception stattfindet.
\\Der try-Block wird ausgeführt (egal ob es eine Exception gibt oder nicht), es wird also immer "Wird noch erledigt" ausgegeben werden.
\\ Danach würde der Exception-Block ausgeführt werden, was in diesem Fall nicht passiert, weil er nur Exceptions der Klasse NameError händelt. Statt dessen wird die Exception geraised (unbehandelt durchfallen), es wird also ein Traceback geben und das Programm beendet werden. \\ Da die Exception nicht abgefangen/behandelt wird, wird das Programm mit erreichen des Exception-Blocks beendet, "Nach der Exception" wird also nicht ausgegeben.


===== else =====

Wird nur ausgeführt wenn es keine Exception gab.

<code>
try:
     Code der potentiell eine Exception produziert.
except:
     Code der ausgeführt wird wenn es eine Exception gibt.
else:
     Code der ausgeführt wird wenn es keine Exception gibt.
</code>



===== raise =====

Rais kann eine Exception eines bestimmten Typs auslösen oder eine Exception die durch einen Except-Block aufgefangen wurde innerhalb diesen auslösen.

<code>
raise <Exception-Klasse>
</code>

Beispiel:
<code>
raise NameError
</code>
In obigem Beispiel wird eine Exception vom Typ NameError erzeugt. \\ 
Passiert das innerhalb eines Try-Blocks und es gibt dafür einen Except-Block, wird dieser aufgerufen.
\\ 
<code>
try:
    Code der möglicherweise eine Exception auslöst
except:
    Irgendwelcher Code der im Falle einer Exception ausgeführt werden soll
    raise
</code>

Beispiel:
<code>
try:
      5/0
except:
    print "Exception eingetreten"
    raise
print "Nach der Exception"
</code>
In diesem Beispiel wird "Exception eingetreten" ausgeben und danach ein Traceback der Exception, ausgelöst durch "raise". \\
Da der Aufruf innerhalb des Exception-Blocks stattfindet und es somit keinen händelnden Exception-Block gibt, wird das Traceback ausgebenn und das Programm beendet (so als wäre die Exception nicht gehändelt worden). \\
"Nach der Exception" wird also nicht ausgegeben.


===== Schleifen/praktischer Hinweis =====

Es macht unter Umständen Sinn den Teil der in eine Exception führen kann in eine Schleife zu packen, falls man die Exception abfangen und den fehlgeschlagenen Teil erneut ausführen will.\\ 
Zum Beispiel bei Benutzereingaben die falsch waren oder Verbindungen die erneut versucht werden herzustellen. \\ \\
Beispiel:
<code>
while True:
   try:
       <Code um sich mit einer Seite zu verbinden>
   except:
       <Warte für x Sekunden>
       continue
   <Irgendwelcher anderer Code>
   break
</code>

In obigem Beispiel wird versucht sich mit einer Seite zu verbinden (in einer Endlosschleife), schlägt das Fehl löst das eine Exception aus. \\ Im Exception-Block wird einige Sekunden gewartet, dann wird zurück an den Beginn der Schleife gesprungen und der Versuch wiederholt. \\ Schlägt es wieder fehl wiederholt sich der Vorgang. Ist es erfolgreich wird der Code hinter der Exception abgearbeitet und letztendlich mit break die Schleife verlassen. \\ \\
Eine Exception ist nichts anderes als ein erweitertes if-Statement was prüft ob eine Bedingung (die Exception) eingetreten ist und dann irgendetwas tut.
====== Schleifen ======

===== Break =====

Bricht das Durchlaufen der Schleife an der Stelle wo das Schlüsselwort steht ab und setzt die Ausführung hinter der Schleife fort (verlässt die Schleife).
<code>
while <Bedingung>:
  Code-Zeile 1
  Code-Zeile 2
  break
  Code-Zeile3
</code>

In obigem Beispiel würde Code-Zeile3 nie ausgeführt, da sie hinter dem Break-Statement steht, an der Stelle des break-Statements würde die Schleife verlassen werden.\\
Natürlich würde man normalerweise die Break-An




===== Continue =====

Bricht den Schleifendurchlauf an dieser Stelle ab und springt wieder an den Anfang der Schleife und durchläuft sie mit dem nächsten Durchlauf.

<code>
while <Bedingung>
  Code-Zeile 1
  Code-Zeile 2
  continue
  Code-Zeile 3
</code>

In obigem Beispiel würde Code-Zeile 3 nie ausgeführt werden, da das continue-Statement welches davor steht die Ausführung des Schleifenkörpers abbricht und wieder an den Anfang der Schleife zurückspring um mit dem nächsten Durchgang weiter zu machen. \\ In der Praxis würde man natürlich continue in ein if-Statement einbauen.


====== Blöcke oder das Programm verlassen ======

Die folgenden Anweisungen sorgen dafür das die folgenden Blöcke sofort an dieser Stelle verlassen werden -> der weitere Code des Blockes wird nicht mehr ausgeführt.

^Anweisung ^Block ^Beschreibung ^
|contiǹue|Schleife|Springt zurück an den Schleifenkopf und setzt mit dem nächsten Schleifendurchlauf fort|
|break|Schleife|Verlässt die Schleife und setzt die Ausführung des Codes nach der Schleife fort|
|exit()|Methode/Funktion, Programm|Verlässt die Methode/Funktion oder wenn außerhalb einer solchen aufgerufen beendet es das Programm \\ \\ **Achtung:** Exit ist kein Schlüsselwort, sondern eine Funktion!|
|quit()|Programm|Beendet das Programm (im Gegensatz zu Exit spielt die Position wo es aufgerufen wird keine Rolle)|


====== list =======

  * Sequentieller Datentyp 
      * alle Operationen die auf sequentielle Datentypen angewendet werden können, können hierauf angewendet werden
  * Listen bleiben in der Reihenfolge wie die Elemente hinzugefügt wurden
  * Listen können (im Gegensatz zu sets) Elemente mehrfach enthalten (wenn sie mehrfach hinzugefügt wurden)


Methoden:
^Methode^Beschreibung^
|+|Listen könne durch den +-Operator zusammengeführt werden (das Ergebnis ist eine Liste die Liste A und Liste B in der Reihenfolge beinhaltet. \\ <WRAP>
<code>
lista=["Eins","Zwei","Drei"]
listb=["Vier","Fünf","Sechs"]
listc=lista+listb
</code>
listc enthält hiernach die Elemente in A und B. 
</WRAP> |
|append(Element)|Fügt ein Element an das Ende der Liste hinzu. \\ <WRAP>
<code>
a.append("Susi")
</code>
"Susi" wird an das Ende der Liste hinzugefügt. 
</WRAP>|
|sort|Sortiert die Liste lexikalisch|
|len(list)|Gibt die Anzahl der Elemente in einer Liste zurück (NICHT die Länge der Elemente)|


====== Dictionary =======

  * Schlüssel-Wert-Paare
  * die Ordnung wie die Daten eingefügt werden wird nicht beibehalten
      * das heißt die Daten stehen in irgend einer Ordnung darin
  * Schlüssel müssen ein-eindeutig sein
      * ein Schlüssel darf nur einmal im Dictionary vorkommen
  * die meisten Operationen (vor allem die für serielle Datentypen) beziehen sich auf den Schlüssel


^Methode ^Beschreibung ^
|get(index/key,default-value) |Gibt den Wert der zum angegeben Key gehört zurück oder wenn der Key nicht vorhanden ist das was in  "default-value" angegeben ist. \\ \\ Natürlich kann man einfach per Index auf den Wert zugreifen, riskiert aber im Falle das der Key nicht vorhanden ist eine Exception oder müsste erst per if-Anweisung prüfen ob der Key vorhanden ist. <WRAP>
<code>
a=dict()
if "Vorname" in a:
     b=a[Vorname]
else:
     b="Peter"
</code>
In obigem Beispiel wird um sicher zu gehen das es einen Key "Vorname" gibt erstmal per if geprüft und dann wenn er vorhanden ist der Wert von ihm ausgelesen oder wenn er nicht vorhanden ist ein Default-Wert zugewiesen. \\ \\ 
Das kann man einfacher haben:
<code>
a=dict()
b=get("Vorname","Peter")
</code>
get prüft ob es einen Schlüssel namens "Vorname" gibt, gibt es keinen gibt es den Default-Wert (in diesem Fall "Peter" zurück. \\
Man spart sich die explizite Prüfung.
</WRAP>|
|values()|Gibt eine liste (typ list) mit den Werten zurück. \\ \\ Führt man values() und keys() kurz hintereinander (aufeinander folgend) aus, so entsprechen sich die Werte -> das heißt der Key in der einen Liste hat die gleiche Position wie sein Wert in der anderen Liste. Das geht aber nur kurz nacheinander (vermutlich kann sich es ändern sobald man Änderungen am dict vornimmt).|
|keys()|Gibt eine Liste (typ list) mit den Keys zurück. \\ \\ Führt man values() und keys() kurz hintereinander (aufeinander folgend) aus, so entsprechen sich die Werte -> das heißt der Key in der einen Liste hat die gleiche Position wie sein Wert in der anderen Liste. Das geht aber nur kurz nacheinander (vermutlich kann sich es ändern sobald man Änderungen am dict vornimmt).|
|items()|Liefert eine Liste mit Tuppels zurück in der jeweils ein Tupple ein Key-Value-Pair darstellt. \\ \\<WRAP>
Ist das dict so:
<code>
"Peter":100
"Jan":50
"Dieter":30
</code>
Ergibt items():
<code>
[(Peter,100),(Jan,50),(Dieter,30)]
</code>
Wir haben also eine Liste mit 3 Elementen, jedes Element ist ein Tuppel. \\ \\
Das kann man verwenden wenn man zum Beispiel in einer Loop durch die Keys und die dazugehörigen Values laufen will:
<code>
for schluessel,werte in a.items():
     Das was getan werden soll
</code>

In diesem Fall liefert items() eine Liste zurück durch die die Schleife läuft, da 2 Iterationsvariablen vorhanden sind (schluessel und werte) spaltet Python die einzelnen Einträge in der Liste weiter auf, nämlich in die beiden Bestandteile des Tuppels und verteilt diese auf die Variablen. 
</WRAP>|



====== Tuple ======

  * Nicht Modifizierbare Liste (inmutable)
  * Verbraucht weniger Resourcen als eine Liste
  * Im Gegensatz zu list welches [] nutzt um eine Liste zu definieren, nutzt Tuple ()

Defininition eines Tuppels:
<code>
a=tuple(('eins','zwei','drei')
</code>
Oben stehender Code erstellt ein Tupple mit den Werten "eins","zwei","drei".


====== Regular Expressions ======

  * Bibliothek ist re

**Hinweis:** By Default arbeitet das Matching "Greedy", das heißt es wird einen String so lang wie durch das Regular-Expression erlaubt matchen: "Subject: Petersen meint: Muss schneller gehen" - Regex: "*+:" - Das Ergebniss in diesem Fall ist nicht "Subject:" wie man meinen könnte, sondern "Subject:  Petersen meint:", da nach irgendwelchen Zeichen (*) und einem Doppelpunkt gesucht wird -> der Doppelpunkt am meisten Rechts ist der nach "meint". \\ Man kann das Abschalten in dem man "?" an das Ende Regular-Expression-Kombination schreibt: "*+?:", das würde dann zwei Elemente (statt einem) ausgeben: "Subject:", "Petersen meint:" ausgeben.

Special-Charakters, nicht komplette Liste
^Character ^Erklärung ^
|.|Steht für beliebige Zeichen|
|*|Bedeutet das vorhergehende Zeichen 0 mal oder beliebig oft - das vorhergehende Zeichen kann also gar nicht oder beliebig oft nacheinander auftauchen. \\ \\ Häufig genutzt in der Kombination: .* \\Beliebiges Zeichen, beliebig oft |
|+|Das vorhergehende Zeichen mindestens einmal, maximal beliebig oft.|
|?|Abschalten der Greedy-Funktion für das davor stehende Zeichen/Zeichenkombination, d.h. Abschalten des Verhaltens den regulären Ausdruck auf ein möglichst großes Gebiet anzuwenden. \\ Beschränkt den regulären Ausdruck auf den kleinsten Teil einer Teilzeichenkette der dem regulären Ausdruck passt, anstatt einen möglichst großen Teil einer Zeichenkette zu finden auf den der reguläre Ausdruck noch anwendbar ist (siehe Abschnitt oben)|
|\S|Ein Zeichen was kein Leerzeichen ist - oder anders alles was kein Leerzeichen ist|
|[ ]|Steht für eine frei definierbare Gruppe von Zeichen. \\ \\ Grundsätzlich (ohne extra Zeichen dahinter) steht es für genau ein Zeichen aus dieser Gruppe. In Zusammenhang mit +, * usw. erhält es die Bedeutung als wäre es ein normales Zeichen gefolgt von dem Spezialzeichen, das heißt irgend ein Zeichen der Gruppe kann ggf. mehrfach hintereinander auftreten, es muss sich dabei aber nicht um das gleiche Zeichen handeln, es müssen nur Zeichen der Gruppe sein -> also ist die Gruppe a,b,c, dann könnte es aabca sein. \\ \\ <WRAP>
Gruppendefinition:
  * [A-Z] - der "-" Operator definiert einen Bereich (inklusive dem ersten und letzten angegeben Zeichen) von Zeichen
  * [ACG] - definiert eine Liste von Zeichen 

Die beiden Vorgehensweisen können gemischt werden:
  * [A-Da-dF] - matched Zeichen A-D und a-d und F

**Hinweis:** Die Angaben sind Case-Sensitiv, Groß- und Kleinschreibung haben also Bedeutung  
</WRAP>|
|[^ ]|Matcht alles außer die Zeichen die in der eckigen Klammer definiert sind - ist eine Umkehr|

^Funktion ^Beschreibung ^
|re.search|Tut das gleiche wie find in strings, prüft ob der regular Expression in dem Objekt vorkommt - gibt True oder False zurück. <WRAP>
<code>
import re
a="Hallo Welt"
re.search("l{2}",a)
</code>
Oben stehendes Beispiel würde ein Objekt zurück geben, würde es nicht matchen würde es None zurück geben.
</WRAP> |\\ \\
|re.findall|Liefert eine Liste mit Strings zurück auf die der regluläre Ausdruck zutraf. \\ <WRAP>
<code>
a="Hallo Wellt"
re.findall("l{2}")
</code>
Das Ergebnis ist eine Liste mit 2 Elementen mit jeweils "ll" in diesen.

**Beschränken des Rückgabe-Bereichs**
\\
Es kann sein, dass man zwar auf einen bestimmten Bereich matchen will, aber nur einen Teilstring extrahieren (der nicht identisch ist mit dem Gesamtstring auf den man matcht).
\\
Dazu kann man einen Teilausdruck in Klammern definieren, es wird dann zwar auf den gesamten regulären Ausdruck gematcht, aber nur das das Ergebnis des Ausdrucks in Klammern wird in den Ergebnissen berücksichtigt. \\
<code>
import re
a="From: Peter.Deichsel@something.de"
re.findall("^\W*From:\W*(\S+)",a)
</code>
In obigem Beispiel ist die E-Mailadresse im From von Interesse. \\
  * ^\W*From:\W* -> stellt sicher das der From-Header gefunden wird, es können davor und dahinter Leerzeichen sein (\W*)
  * \S+ -> stellt sicher das nach dem Header mindestens ein Zeichen kommt was kein Leerzeichen ist
  * () -> bedeutet das nur das Ergebnis des reguläre Ausdruck innerhalb der Klammern zurückgeliefert wird

In obigem Beispiel würde "Peter.Deichsel@something.de" als Ergebnis zurückgeliefert.
</WRAP> |
MyWiki

Benutzer-Werkzeuge

Webseiten-Werkzeuge

Seiten-Werkzeuge
