| Was werden wir behandeln? |
|---|
| Verschiedene neue Anwendungen von Kommentaren, wie man das Layout von Code macht, damit sich durch Verwendung von Einzügen die Lesbarkeit verbessert und eine Einführung in den Gebrauch von Modulen zum Speichern unserer Programme. |
Wir haben schon über Kommentare in der Abteilung 'Mehr Befehlsfolgen' gesprochen. Dennoch gibt es mehr Dinge, die wir mit Kommentaren machen können, und ich werde dies hier erweitern:
Es ist eine gute Angewohnheit, eine Dateiüberschrift zu Beginn einer jeden Datei zu erzeugen. Diese sollte Details darstellen, wie Tag der Entstehung, Autor, Datum, Version und eine allgemeine Beschreibung des Inhaltes; eventuell mit Auflistung der Änderungen. Dieser Block wird als Kommentar erscheinen:
#############################
# Module: frikadelle
# Author: A.J.Gauld
# Date: 2001/01/29
# Version: Entwurf 0.4
#
# Beschreibung: Dieses Modul unterstützt ein frikadelle-Objekt, das mit
# jeder anderen Art von Essensobjekten kombiniert werden kann, um
# interessante Kombinationen für Mahlzeiten zu erzeugen.
#
###############################
# Log:
# 2001/01/26 AJG - File erzeugt
# 2001/01/27 AJG - Fehler in der Preistrategie behoben
# 2001/01/28 AJG - Macht diesmal alles richtig!
# 2001/01/29 AJG - Grillmethode hinzugefügt(cf Change Req #1234: Pfannenwechsel)
################################
import sys, string, essen
...
Diese Technik wird oftmals angewendet, um einen fehlerhaften Code-Abschnitt zu isolieren. Nehmen wir zum Beispiel einmal an, ein Prgramm liest ein paar Daten, bearbeitet diese, druckt etwas aus und speichert das Ergebnis zurück auf das Datenfile. Wenn das Ergebnis nicht so ist, wie wir es erwarten, wäre es sinnvoll, momentan zu verhindern, dass die (fehlerhaften) Daten zurück auf die Datei gespeichert werden und diese beschädigen. Wir könnten einfach den zuständigen Code löschen, aber ein weniger radikales Verfahren ist es, die Zeilen einfach in Kommentar umzuwandeln, wie:
data = readData(datafile)
for item in data:
results.append(calculateResult(item))
printResults(results)
######################
# Kommentiere aus, bis der Bug in calculateResult entfernt ist
# for item in results:
# dataFile.save(item)
######################
print 'Programm beenden'
Ist der Fehler irgendwann ausfindig gemacht, so kann man ganz einfach die Kommentarzeichen löschen, um den Code wieder aktiv zu machen.
Alle Sprachen ermöglichen es dir, Kommentare zu erzeugen, die dokumentieren, was eine Funktion oder ein Modul bewirkt; aber ein paar Wenige, wie Python und Smalltalk gehen eine Stufe weiter und erlauben es, die Funktion in einer Weise zu dokumentieren, dass die Sprache/Umgebung eine interaktive Hilfe während der Programmierung unterstützt. In Python wird dies durch die Verwendung vom """Dokumentations""" - String - Stil:
class Frikadelle:
"""Ein Gericht zur Kombination mit anderem Essen
Es kann mit anderem Essen benutzt werden, um interessante Mahlzeiten zu machen.
Es kommt mit vielen Nahrungsmitteln und kann unter Verwendung
unterschiedlicher Techniken gekocht werden"""
def __init__(self):
...
print Frikadelle.__doc__
Note: Wir können auf den Dokumentations-String zugreifen, indem wir die spezielle __doc__ Variable ausdrucken. Module, Funktionen und Klassen/Methoden können alle einen Dokumentations-String enthalten. Probiere zum Beispiel:
import sys print sys.__doc__
Dies ist eines der in der Programmierung am heißesten debattierten Themen. Es sieht beinahe so aus, als dass jeder Programmierer/in seine/ihre eigene Idee von der besten Art des Code-Einzuges zu haben scheint. Wie im Folgenden ausgeführt, wurden einige Studien durchgeführt, die zeigen, das schließlich einige Faktoren besonders wichtig sind, vor aller Kosmetik - z.B. helfen sie uns den Code besser zu verstehen.
Die Ursache für die Debatte ist simpel. In den meisten Programmiersprachen ist der Einzug reine Kosmetik; eine Unterstützung des Lesers. (In Python ist sie tatsächlich erforderlich und ist essentiell für den sauberen Ablauf eines Programms!). Also:
FOR I = 1 TO 10
PRINT I
NEXT I
Das ist exakt dasselbe wie:
FOR I = 1 TO 10 PRINT I NEXT I
soweit es den BASIC-Interpreter angeht. Es ist für uns mit Einzug eben einfacher zu lesen.
Der Knackpunkt ist, dass der Einzug die logische Struktur des Codes wiederspiegeln sollte, indem er so visuell dem Programmfluss folgen sollte. Um dies zu tun, hilft es, wenn die Blöcke wie dieser aussieht:
XXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXX
was besser zu lesen ist als:
XXXXXXXXXXXXXXXXXXXXX
XXXXX
XXXXXXXXXXXX
XXXXXXXXXXXX
XXXXXXXXXXXX
XXXXX
weil es eindeutig ein Block ist. Studien haben signifikante Verbesserungen im Verständnis gezeigt, wenn der Einzug die logische Blockstrucktur wiedergibt. In den kleinen Beispielen, die wir bislang gesehen haben, scheint dies noch nicht wichtig, aber wenn wir beginnen, Programme mit hunderten oder tausenden von Zeilen zu schreiben, wird das viel wichtiger.
Die Variablennamen, die wir bisher benutzt haben, waren eigentlich bedeutungslos, weil sie hauptsächlich nur eine einfache erläuteringstechnische Bedeutung hatten. Im Allgemeinen ist es viel besser, wenn deine Variablennamen das widerspiegeln, was du mit ihnen repräsentieren möchtest. Zum Beispiel in unserer Übung mit der Vielfachen-Tabelle benutzten wir 'multiplikator' als Variable, die anzeigte, welche Tabelle wir ausdruckten. Dies ist viel bedeutungsvoller als einfach 'm' - damit hätten wir genau so gut arbeiten können und hätten weniger Tipparbeit gehabt.
Es ist ein Abwägen zwischen Verständlichkeit und Mühe. Grundsätzlich ist die beste Wahl, kurze, aber bedeutungsvolle Namen. Zu lange Namen verwirren auf Dauer und es ist schwierig sie richtig übereinstimmend zu bekommen (Ich könnte zum Beispiel die _tabelle_die_wir_drucken_werden anstatt von multiplikator verwenden, aber das ist viel zu lang und auch nicht wirklich klarer.)
Ich werde davon mehr Einzelheiten später erläutern, aber im Moment möchte ich das Konzept beschreiben und - viel wichtiger - wie ich Module benutzen kann, um unsere Arbeit abzuspeichern - momentan sind alle deine Programme verloren, sobald du Python verlässt.
Obwohl die interaktive Interpretereingabe (>>>) von
Python sehr nützlich ist, um mal schnell Ideen auszuprobieren,
sie verliert alles in der Minute, in der du es beendest. Mit
anderen Worten, wir möchten die Möglichkeit haben, Programme zu
schreiben um diese dann immer wieder und wieder laufen lassen zu
können. Um dies in Python zu tun, erzeugen wir eine Textdatei
mit der Extension .py (Dies ist eigentlich nur eine
Absprache, du könntest verwenden, was du magst. Aber es ist eine
gute Idee mit Absprachen übereinzustimmen, meiner Meinung nach...).
Du kannst dann dein Programm starten, indem du von einer
Befehlseingabezeile eintippst:
$ python frikadelle.py
Wobei frikadelle.py der Name der Python-Programmdatei ist.
Anmerkung für Unix-Benutzer: Die erste Linie eines Python-script-file sollte die Befehlsfolge #! gefolgt von dem vollständigen Pfad von Python auf deinem System enthalten. (Du kannst ihn durch die Eingabe von $ which python in dein Shell-Prompt erhalten.)
Auf meinem Sytem sieht die Zeile so aus:
#! /usr/local/bin/python
Die ermöglicht es dir, die Datei ohne den gleichzeitigen Aufruf
von Python laufen zu lassen:
$ frikadelle.py
Diese Zeile ist ohne Wirkung unter Windows/Mac; diese Benutzer können
sie auch eingeben, wenn ihr Programm irgendwann auf einer Unix-Kiste
laufen soll.
Anmerkung für Windows - Benutzer: Unter Windows kannst du eine Verknüpfung zu Dateien mit der Endung .py innerhalb des Explorers erstellen. Dies erlaubt dir das Ablaufen deiner Pythonprogrammme durch einfaches Doppelklicken auf das Datei-Icon. Dies sollte eigentlich schon durch den Installer duchgeführt worden sein. Du kannst dies überprüfen, indem du einige .py-Files suchst und probierst, sie laufen zu lassen. Wenn sie starten (wenn auch nur mit einer Python-Fehlermeldung), ist das so eingestellt.
Der andere Vorteil des Gebrauches von Dateien zum Abspeichern von Programmen ist, dass du Fehler editieren kannst, ohne das komplette Fragment neu eingeben zu müssen, oder, in IDLE, den Cursor den ganzen Weg entlang der Fehler vorbeilaufen zu lassen, um den Code neu zu selektieren. IDLE unterstützt das Öffnen von Dateien zum Editieren und Laufenlassen vom Menü 'Edit|Run module' aus.
Ab jetzt werde ich normalerweise das >>> Prompt in Beispielen nicht mehr angeben, ich werde davon ausgehen, dass du die Programme in separaten Dateien erzeugst und diese entweder von IDLE oder von einer Befehlseingabezeile (mein persönlicher Favorit) eingibst.
| Zur Erinnerung |
|---|
|
Bei Fragen oder Anmerkungen sende eine Nachricht in Englisch an alan.gauld@yahoo.co.uk
oder in Deutsch an bup.schaefer@freenet.de