To GUI or not to GUI...

Schaut man in den Programmierforen nach, so kommt von Einsteiger öfters die Frage: "Ich möchte mein erstes Programm schreiben, das auch eine GUI haben soll.". Eine oft gehörte Antwort ist dann: "Programmier' erst Mal ohne GUI".

Das mag befremdlichen klingen, da seit vielen Jahren eine grafische Benutzeroberfläche absoluter Standard ist. Warum soll man also nun für das (erste) eigene Programm darauf verzichten? Diese Frage wird im folgenden ein wenig beleuchtet.

Dazu gibt es folgende kleine Aufgabe: Es soll ein Programm geschrieben werden, welches eine ganze Zahl als Eingabe nimmt und das Quadrat dieser Zahl als Ausgabe zurück liefert. Um das Programm einfach zu halten und den Fokus auf "To GUI or not to GUI" zu legen, soll das Programm lediglich prüfen, ob die Eingabe eine ganze Zahl ist. Wenn nicht soll eine Fehlermeldung ausgegeben werden. Weiterhin enthalten die Quelltexte keinerlei Kommentare.

Als Programmiersprache kommt Python zum Einsatz, wobei sich die Beispiele  sicherlich auch recht einfach auf andere Sprachen übertragen lassen.

Zurück zu "Programmier' erst Mal ohne GUI": Selbst Linux-Nutzer, welchen die Kommandozeile tendenziell geläufiger ist als z.B. Windows-Nutzer, erscheint es vielleicht doch ein wenig antiquiert "nur Text" zu Arbeiten. Der Grund für den Rat hierzu ist aber recht simpel: Selbst eine minimale GUI (wie im folgenden zu sehen) verlangt einiges mehr an Codezeilen. Plus, und das ist der wichtigere Punkt, die Einarbeitung in eine entsprechende Bibliothek mit entsprechend umfangreicher Dokumentation kann zeitaufwendig sein. Das heißt, dass der geneigte Programmieranfänger nicht nur die Grundlagen einer für ihn neuen Programmiersprache lernen soll, sondern auch direkt die Nutzung der GUI-Bibliothek - was die Sache definitiv nicht einfacher macht. Außerdem wäre es ja auch Schade, wenn er frustriert aufgibt, weil er (als Anfänger) nicht mit der GUI-Programmierung zurecht kommt.

Bevor wir zu den verschiedenen Versionen des Programms kommen noch eine Anmerkung vorab: Vor den Listings ist immer die Anzahl der Codezeilen angegeben. Die beinhalten nicht den Shebang und die Coding-Info (welche bei allen Listings so wie so gleich ist), weiterhin werden Leerzeilen nicht mit gezählt. Codezeilen, welche Zeilenumbrüche zur Verbesserung der Lesbarkeit enthalten, werden ebenfalls als eine Zeile gezählt.

Alle Programm sind unter Ubuntu 11.10 Oneiric getestet, die verwendete Python-Version bzw. GUI-Bibliotheken und Python-Anbindungen stammen alle aus den offiziellen Paketquellen.

Der erste Kandidat ist ein reines Kommandozeilen-Programm. Dieses erwartet, dass die zu quadrierende Zahl als Argument beim Programmaufruf mit übergeben wird. Heißt das Programm z.B. "quadrat.py", so lautet der Aufruf:

python quadrat.py 12

Hier das Programm für die Kommandozeile, 12 Zeilen:

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import sys

if len(sys.argv) < 2:
    print 'Es wurde kein Wert vorgegeben!'
    sys.exit()

eingabe = sys.argv[1]
try:
    zahl = int(eingabe)
except ValueError:
    print 'Der Wert ist keine ganze Zahl!'
    sys.exit()
else:
    print zahl * zahl

---

Update 21.1.2012:
Das obige Beispiel läuft zu ziemlich unter allen Python-Version, selbst unter sehr alten. Wer Python 2.7  bzw. 3.2 und neuer nutzt, der kann den Code noch kürzer gestalten, und zwar unter Verwendung des argparse-Moduls:

Kommandozeile mit argparse, 5 Zeilen:

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import argparse

parser = argparse.ArgumentParser('Programm zum Quadrieren von Integerzahlen.')
parser.add_argument('value', type=int)
args = parser.parse_args()
print args.value * args.value

Danke an Hyperion für den Hinweis hierzu in deutschen Python-Forum!

---

Nun ist der Vergleich eines reinen Kommandozeilen-Programms vielleicht nicht ganz fair, weil dieses für jede Rechnung erneut aufgerufen werden muss. Die Programme mit grafischer Oberfläche müssen nur ein Mal gestartet werden, dann können beliebig viele Rechnungen durchgeführt werden.

Doch auch auf der Kommandozeile gibt es dafür ein pythonische Lösung, das cmd-Modul. Eine Einführung in dieses Modul ist im Blogeintrag cmd - Python-Modul für text-basierte Programme hier bei mir im Blog zu finden.

Die Umsetzung sieht dann so aus:

cmd-Modul, 14 Zeilen:

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import cmd

class SimpleCmd(cmd.Cmd):
      
    def do_quadrat(self, line):
        try:
            zahl = int(line)
        except ValueError:
            print 'Der eingegebene Wert ist keine ganze Zahl!'
        else:
            print zahl*zahl

    def do_EOF(self, line):
            print 'Programm beenden...'
            return True

simplecmd=SimpleCmd()
simplecmd.cmdloop()

Kommen wir zu den GUI-Bibliotheken. Betrachtet werden hier die beiden wohl populärsten Frameworks, nämlich Qt4 und GTK+. Erster wird dabei über PySide genutzt, letzter über das PyGObject.
Pyside + Qt4, 27 Zeilen:

#!/usr/bin/env python
# ~*~ coding: utf-8 ~*~

import sys
from PySide import QtGui

class SimpleQt(QtGui.QDialog):
    def __init__(self,parent=None):
        super(SimpelQt, self).__init__(parent)
        self.setWindowTitle('Qt4')
        layout = QtGui.QVBoxLayout()
        self.eingabe = QtGui.QLineEdit()
        layout.addWidget(self.eingabe)
        self.button = QtGui.QPushButton(u'Quadrieren')
        layout.addWidget(self.button)
        self.label = QtGui.QLabel(u'Ergebnis...')
        layout.addWidget(self.label)
        self.setLayout(layout)
        self.button.clicked.connect(self.rechnen)

    def rechnen(self):
        wert = self.eingabe.text()
        try:
            zahl = int(wert)
        except ValueError:
            msgBox = QtGui.QMessageBox()
            msgBox.setText(u'Der eingegebene Wert ist keine ganze Zahl')
            msgBox.exec_()
        else:
            self.label.setText(unicode(zahl*zahl))

app=QtGui.QApplication(sys.argv)
simple_qt=SimpleQt()
simple_qt.show()
sys.exit(app.exec_())

Und hier noch die Version mit grafischer Oberfläche, welche auf GTK+ setzt:

PyGObject + GTK+, 29 Zeilen:

#!/usr/bin/python
# -*- coding: utf-8 -*-
 
from gi.repository import Gtk
 
class SimpelGtk(object): 
    def Gtk.Window.__init__(self, title='Simpel Gtk+')
        self.window.set_default_size(200, 100)
        vbox = Gtk.Box(False, 20)
        vbox.orientation = Gtk.Orientation.VERTICAL
        self.window.add(vbox)
        self.eingabe = Gtk.Entry()
        vbox.pack_start(self.eingabe,True,True,0)
        button = Gtk.Button("Quadrieren")
        button.connect("clicked", self.rechnen)
        vbox.pack_start(self.button,True,True,0)    
        self.label = Gtk.Label("Ergebnis...")
        vbox.pack_start(self.label,True,True,0)
        
    def rechnen(self,data=None):
        try:
            wert = int(self.eingabe.get_text())
        except ValueError:
            text = 'Die Eingabe ist keine ganze Zahl!'
            dialog = Gtk.MessageDialog(self, 0, Gtk.MessageType.ERROR,
            Gtk.ButtonsType.CANCEL, 'Fehler bei der Eingabe')
            dialog.format_secondary_text(
                'Der eingegebene Wert ist keine ganze Zahl!')
            dialog.run()
        else:
            self.label.set_text(str(wert*wert))

    def main(self):
        win = Gtk.Window()
        win.connect("delete-event", Gtk.main_quit)
        win.show_all()
        Gtk.main()
 
if __name__ == "__main__":
    e = SimpelGtk()
    e.main()
    
#http://python-Gtk-3-tutorial.readthedocs.org/en/latest/introduction.html

Wie zu sehen ist, sind die GUI-basierten Varianten deutlich länger, nämlich rund 2,5x länger als die Kommandozeile-Version und circa 2x so lange wie die Version, welche das cmd-Modul nutzt. Das mehr an Codezeilen ist dabei natürlich durch das Hinzufügen der GUI-Elemente bedingt. Weiterhin ist der Quelltext für Anfänger (wahrscheinlich) deutlich schwieriger nach zu vollziehen.

Nur damit keine Missverständnisse entstehen: Dies ist kein Plädoyer gegen Programme mit GUI. Überhaupt nicht. Es soll lediglich gezeigt werden, wodurch der oft gehört und gut gemeinte Rat "Programmier' erst Mal ohne GUI" motiviert ist.

Abgesehen davon: beherrscht man die Grundlagen einer Progammiersprache ist es oft deutlich einfacher, die APIs weiterer Bibliotheken wie z.B. den zur GUI-Erstellung, nachzuvollziehen.