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:

def Methodenname (*Parametername):
     Code

Syntax Aufruf:

Methodenname (Wert1, Wert2, Wert3)

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:

def Methodenname (Parameter1, Parameter2, *OptionalerParameter):
     Code

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

Beispiel:

def mymethode (param1,param2,optionalparam):
    print optionalparam
    
mymethod("eins","zwei","drei","vier","funf")

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

Exceptions/Tracebacks können (wenn man sie erwartet und händeln will) durch try und except-Blöcke abgefangen werden:

tr
     Code welcher eventuell eine Exception auslösen wird.
except:
     Code welcher beim Eintreten einer Exception ausgeführt werden soll.
     

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:

try:
     Code der ggf. zur Exception führt.
except Exception-Klasse:
     Code zum Hanhaben der Exception

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:

Traceback (most recent call last):
  File "/tmp/ex.py", line 2, in <module>
    5/0
ZeroDivisionError: integer division or modulo by zero

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:

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

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:

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"

In obigem Beispiel würde der letzte except-Block alle nicht explizit durch einen anderen except-Block gehändelten Exceptions händeln.

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.

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

Beispiel:

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

finally:
        print ("Wird noch erledigt")
print "Nach der Exception"

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.

Wird nur ausgeführt wenn es keine Exception gab.

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.

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

raise <Exception-Klasse>

Beispiel:

raise NameError

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.

try:
    Code der möglicherweise eine Exception auslöst
except:
    Irgendwelcher Code der im Falle einer Exception ausgeführt werden soll
    raise

Beispiel:

try:
      5/0
except:
    print "Exception eingetreten"
    raise
print "Nach der Exception"

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.

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:

while True:
   try:
       <Code um sich mit einer Seite zu verbinden>
   except:
       <Warte für x Sekunden>
       continue
   <Irgendwelcher anderer Code>
   break

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.

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).

while <Bedingung>:
  Code-Zeile 1
  Code-Zeile 2
  break
  Code-Zeile3

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

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

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

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.

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.

• 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:

lista=["Eins","Zwei","Drei"]
listb=["Vier","Fünf","Sechs"]
listc=lista+listb

a.append("Susi")

• 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

a=dict()
if "Vorname" in a:
     b=a[Vorname]
else:
     b="Peter"

a=dict()
b=get("Vorname","Peter")

"Peter":100
"Jan":50
"Dieter":30

[(Peter,100),(Jan,50),(Dieter,30)]

for schluessel,werte in a.items():
     Das was getan werden soll

• 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:

a=tuple(('eins','zwei','drei')

Oben stehender Code erstellt ein Tupple mit den Werten „eins“,„zwei“,„drei“.

• 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

import re
a="Hallo Welt"
re.search("l{2}",a)

a="Hallo Wellt"
re.findall("l{2}")

import re
a="From: Peter.Deichsel@something.de"
re.findall("^\W*From:\W*(\S+)",a)