PDF-Version - freiesMagazin

weshalb es auch an diesem Beispiel erörtert werden
soll. Für gewöhnlich wird beim Umgang mit
Dateien ein Konstrukt wie das folgende benötigt:
1 handler = open("datei.txt", "r")
2 try:
3 print handler.read()
4 finally:
5 handler.close()
In Zeile 1 wird dabei eine Datei geöffnet und das
daraus resultierende Datei-Objekt an den Namen
handler gebunden. In Zeile 3 wird der Inhalt der
Datei ausgegeben. Der try...finally-Block
stellt sicher, dass das Datei-Objekt anschließend
in jedem Fall geschlossen wird – auch wenn beim
Auslesen der Datei in Zeile 3 eventuell Fehler
aufgetreten sind. Die Konstruktion „Vorbereiten,
Bearbeiten, Aufräumen“ ist allerdings auch in anderen
Zusammenhängen so häufig anzutreffen,
dass ab Python 2.5 mit with eine deutliche Vereinfachung
für derartige Fälle eingeführt wurde:
1 with open("datei.txt", "r") as
handler:
2 print handler.read()
Auch hier wird zunächst die Datei open.txt
zum Lesen geöffnet und das daraus resultierende
Datei-Objekt an den Namen handler gebunden.
Allerdings erfolgt die Zuweisung des Namens
hier durch das Schlüsselwort as. In Zeile 2
wird – wie gehabt – der Inhalt der Datei ausgegeben.
Damit sind die beiden Schritte „Vorbereiten“
und „Bearbeiten“ abgehandelt. Das Aufräumen
erfolgt mit dem Verlassen der Kontrollstruktur, al-
so am Ende des with-Blocks. Es muss nicht explizit
durchgeführt werden. Wie funktioniert das?
Seit Python 2.5 gibt es zwei neue spezielle
Methoden, die Objekte implementieren können:
__enter__ und __exit__. Die Methode
__enter__ ist für die Vorbereitung zuständig und
wird implizit beim Betreten des with-Blocks aufgerufen.
Der Rückgabewert dieser Methode wird
dann an den mit as angegebenen Namen gebunden
– oben also an den Namen handler. Die Methode
__exit__ wird beim Verlassen des with-
Blocks aufgerufen – unabhängig davon, ob ein
Fehler aufgetreten ist oder nicht.
Diese Konstruktion wird im Folgenden auch
für die Datenbank verwendet. Da die SQLite-
Schnittstelle für Python von Haus aus noch keinen
Gebrauch von diesem neuen Sprachmittel
macht, wird es hier selbst implementiert.
Der Cursor
SQLite kennt sogenannte Cursor, mit denen Datensätze
in Datenbanken ausgelesen und bearbeitet
werden [10]. In der Regel folgt auch das
Arbeiten mit Cursorn dem Schema „Vorbereiten,
Bearbeiten, Aufräumen“, weshalb sich hier die
Verwendung der with-Anweisung empfiehlt.
Das bisherige Skript aus dem letzten Teil wird
nun um diese Klasse ergänzt:
class Cursor(object):
def __init__(self , connection):
self.connection = connection
def __enter__(self):
self.cursor = self.connection.cursor()
return self.cursor
PROGRAMMIERUNG
def __exit__(self , type , value , traceback):
self.cursor.close()
Es handelt sich hierbei letztlich nur um einen
sogenannten „Wrapper“, der die Verwendung
von SQLite-Cursorn mit with ermöglicht. Später
könnte ein Aufruf wie folgt aussehen:
1 with Cursor(connection) as cursor:
2 cursor.machetwas()
connection ist dabei eine Referenz auf ein
SQLite-Connection-Objekt, das eine offene Datenbankverbindung
verwaltet. In Zeile 1 wird
nun zunächst eine Instanz der Cursor-Klasse
erstellt und connection als Parameter übergeben.
In der Methode __init__ wird die Referenz
auf das Connection-Objekt an das Attribut
self.connection gebunden. Erst danach
wird durch den with-Block die Methode
__enter__ des Cursor-Objektes aufgerufen.
Hier wird nun das SQLite-Cursor-Objekt durch
den Aufruf self.connection.cursor() erstellt.
Das Objekt wird an das Attribut self.cursor gebunden
und mittels des Schlüsselwortes return
zurückgegeben. Da der Rückgabewert der Methode
__enter__ in with-Blöcken an den hinter
as angegebenen Namen gebunden wird, steht
nun eine Referenz auf das SQLite-Cursor-Objekt
unter dem Namen cursor zur Verfügung. In Zeile
2 des Beispiels kann so bequem auf das SQLite-
Cursor-Objekt zugegriffen werden. Mit dem Verlassen
des with-Blocks würde schließlich die
Methode __exit__ aufgerufen werden, in der
das Cursor-Objekt korrekt geschlossen wird.
© freiesMagazin CC-BY-SA 3.0 Ausgabe 03/2011 22