Eine Benutzeroberfläche für ein Python-Skript zu erstellen, das geht mit diversen Tools. Soll es aber nutzerfreundlich und ansprechend im Design sein und den Anforderungen der User Experience genügen, dann muss man einen professionellen Ansatz wählen. Die Kombination mit der integrierten Entwicklungsumgebung Delphi kann eine Lösung sein.

Python ist eine fantastische Programmiersprache, wenn es darum geht, Probleme aus den Bereichen Datenauswertung, künstliche Intelligenz, Big Data usw. zu lösen. Die Beliebtheit dieser Programmiersprache kommt insbesondere dadurch zu Stande, dass es unzählige Bibliotheken aus den genannten und angrenzenden Bereichen gibt. Diese stehen meist kostenfrei zur Verfügung, und zahlreiche Beispiele und Tutorials erleichtern den Einstieg. Das Toolset, bestehend aus Python, ausgewählten Bibliotheken und der Interaktion über die Kommandozeile (Command Line Interface/CLI), ist daher zu einem etablierten Hilfsmittel in vielen Bereichen der Wissenschaft, des Lernens, der Forschung und der wissensbasierten Arbeitswelt geworden. Dabei wollen sich die Datenwissenschaftler:innen, Fachexpert:innen und Anwender:innen auf ihre oft hoch komplexe Problemstellung konzentrieren. Im Mittelpunkt stehen das Erstellen von Modellen der künstlichen Intelligenz, intelligente Datenauswertungen oder die Anwendung von Verfahren des Data Minings, um den zu analysierenden Daten bisher nicht entdeckte Informationen zu entlocken. Wie auch in anderen Anwendungsbereichen der Softwarenutzung, kommt es auf den Fokus und den fachlichen Background der Anwender:innen an. Die Arbeit mit der Kommandozeile ist nicht jedermanns Sache und oftmals nicht allzu effizient. Müssen sich Expert:innen aus den Bereichen Medizin, Biologie usw. erst mühsam in die Funktionsweise, die Befehlsfolge und deren Syntax einarbeiten, dann leidet darunter ggf. die Motivation zur Nutzung dieser Werkzeuge. Aus anderen Fachanwendungen ist man die Nutzung grafischer Benutzeroberflächen gewohnt. Ihre Gestaltung richtet sich stets an den Fachkontext, sie sorgt jedoch dafür, dass technische Aspekte vernachlässigt werden müssen.

Spätestens dann, wenn man erste Experimente erfolgreich abgeschlossen hat und die entwickelten Modelle zur Datenanalyse oder für die künstliche Intelligenz wiederholend genutzt werden sollen, stellt sich die Frage nach einer zeitgemäßen Benutzeroberfläche. Es gibt unterschiedliche Ansätze, um ein Python-Programm mit einer grafischen Oberfläche auszustatten. Einen Überblick haben wir in [1] vorgestellt. Am bekanntesten ist Tkinter [2]. Diese Bibliothek kann direkt aus Python heraus verwendet werden, ist plattformübergreifend einsetzbar und auch in der Syntax der Befehle wenig kompliziert. Dennoch muss man an dieser Stelle zugeben, dass die Möglichkeiten eindeutig begrenzt sind, das Potenzial einer modernen grafischen Benutzeroberfläche auf dem jeweiligen Zielbetriebssystem kann man mittels Tkinter nicht ausschöpfen. Ebenso ist dieses Vorgehen nicht ideal. Skripte, Modelle usw. werden durch die Fachanwender:innen erstellt.

Auch wenn sie mit Sicherheit mit einer hohen Expertise in ihren Bereichen und den Hilfsdisziplinen Mathematik, Statistik usw. ausgestattet sind, sind nur die wenigsten Datenwissenschaftler:innen auch Expert:innen für User-Interface-Design. Um ansprechende grafische Oberflächen für Python-basierte Applikationen zu bauen, wäre ein grafischer Designer eine große Hilfe, sodass man sich das Schreiben von kompliziertem Code erspart. Im unter [1] genannten Artikel haben wir auch eine interessante Kombination der Programmiersprachen Python und Delphi vorgestellt. Delphi ist dabei gleichermaßen Entwicklungsumgebung und Programmiersprache und steuert in diesem Doppel primär die grafische Oberfläche und weitere Systemfunktionen wie Datenbankzugriffe. Zur Verfügung steht ein umfassender grafischer Designer, der es ermöglicht, vollständige Benutzeroberflächen zu erstellen. Die Verbindung zwischen den Welten von Python (Datenmodell, Auswertung) und Delphi (Anwendungsprogramm mit grafischer Benutzeroberfläche, Zugriff auf Datenbanken usw.) wird durch spezielle Bibliotheken ermöglicht, die in Delphi eingebunden werden und für den Datenaustausch sorgen.

Mit diesem Werkzeugkasten kann der Data Scientist sich weiterhin auf die fachlichen Anforderungen seines Datenmodells konzentrieren. Gleichwohl hat er mit begrenzten Aufwand die Möglichkeit, moderne und ansprechende grafische Oberflächen für seine Fachanwendungen zu erstellen. Die Arbeitsweise ist dabei auf Effizienz ausgelegt und mit dem Vorgehen einer Low-Code-Entwicklung vergleichbar.

In den nachfolgenden Abschnitten dieses Artikels wollen wir genau diese Perspektive einnehmen, d. h. wir sehen uns genauer an, wie man grafische Oberflächen in Delphi gestalten und dann mit Python-Programmen verbinden kann. Vielleicht motiviert ja ein Blick auf das Ergebnis. Das könnte eine Anwendung sein – unter Windows zum Beispiel eine klassische exe-Datei – die direkt auf dem Rechner ausgeführt und ohne größere Hürden auf anderen Systemen bereitgestellt werden kann. Statt mit kommandobasierten Oberflächen arbeiten die Anwender:innen dann mit komfortablen Benutzeroberflächen, wie sie es aus anderen Fachanwendungen gewohnt sind.

Grafische Oberflächen mit Delphi

Dieser Abschnitt zeigt Ihnen, wie Sie mit Hilfe der integrierten Entwicklungsumgebung Delphi eine Benutzeroberfläche für eine Anwendung erstellen können. Aufgrund des grafischen Designers ist das Vorgehen sehr intuitiv. Nach der Installation von Delphi (Kasten: „Installation von Delphi“) kann es direkt losgehen. Über den Assistenten Datei | Neu beginnen wir die Arbeit mit einem neuen Projekt. Die beiden hier wichtigen Projekttypen sind die VCL-Anwendung (Windows) und geräteübergreifende Anwendung mit dem Grafikframework FireMonkey.

Unabhängig davon, welches Grafikframework Sie wählen, die Vorgehensweise zum Erstellen der Benutzeroberfläche ist nahezu identisch. Nach dem Erstellen des Projekts landen wir in Delphi (Abb. 1).

Abb. 1: Die Entwicklungsumgebung Delphi mit einem neuen Projekt

Delphi arbeitet mit einer hierarchischen Projektstruktur. Dabei ist es möglich, dass mehrere Projekte zu einer Projektgruppe zusammengefasst werden. Unterhalb eines Projektknotens haben wir die Einträge Build-Konfiguration, Zielplattformen und zum Beispiel Unit1.pas. Bei den Build-Konfigurationen können wir zwischen Debug und Release hin- und herschalten und über das Kontextmenü entsprechende Einstellungen vornehmen bzw. ein Kompilieren der Anwendung veranlassen. Unterhalb des Knotens Zielplattformen finden wir alle Zielsysteme, für die die laufende Anwendung erstellt werden kann, zum Beispiel 64-Bit-Windows. Auch weitere Plattformen können konfiguriert werden. Der Programmcode in der Programmiersprache Delphi wird in Units organisiert, zum Beispiel wird Unit1.pas angelegt. Für Formulare wird einer Unit noch zusätzlich eine .fmx-Datei zugeordnet. Diese speichert das mit dem Designer erstellte Formular und wird nicht manuell editiert. Weiterer Programmcode wird über neue Units hinzugefügt. Dabei ist es üblich, die Units in Ordnerstrukturen zu organisieren.

Kommen wir zur Gestaltung der Benutzeroberfläche. Diese wird vollständig mit Hilfe des Designers erstellt. Die Oberfläche wird dabei aus visuellen Steuerelementen (Controls) zusammengesetzt. Diese Controls kapseln die typischen Elemente, wie zum Beispiel Buttons, Textfelder, Menüelemente, Listen, Radio-Buttons oder Auswahlfelder. Delphi bringt bereits eine umfassende Auswahl an Controls mit, die nach Kategorien sortiert in der Toolpalette angeordnet sind (Abb. 2).

Abb. 2: Toolpalette zur Gestaltung der Oberfläche in Delphi

Die Auswahl an Komponenten kann durch externe Bibliotheken erweitert werden. Nach dem Platzieren der Controls auf der Oberfläche und deren Anordnung (Layout) passt man für jedes Control im Objektinspektor die Eigenschaften an. Für einen Button sind insbesondere die folgenden Eigenschaften von Relevanz: Caption: Beschriftung; Height/Width: Höhe/Breite in Pixel; Style: Art des Buttons, d. h. klassisch, Split-Button usw.

Im Objektinspektor kann man ebenso die Registerkarte Ereignisse aufrufen. Ereignisse binden die Elemente der Oberfläche an den Programmcode. Dabei wird ein Ereignis unter bestimmten Voraussetzungen aufgerufen. Das am meisten genutzte Ereignis eines Buttons ist das OnClick-Ereignis. Es wird ausgelöst, wenn der Nutzer den Button drückt. Typische Ereignisse eines Formulars sind beispielsweise: OnCreate (Erstellen), OnActivate (Aktivieren) oder OnClose (Schließen). Über die Ereignisse wird bestimmt, welcher Code beim Aufrufen oder Schließen des Formulars ausgeführt wird. Eine gute Programmarchitektur entkoppelt möglichst weitgehend die einzelnen Programmschichten voneinander. Um das zu erreichen, kann man die einzelnen Eigenschaften der Controls an Datenobjekte binden. Ebenso kommt es häufig vor, dass man Controls untereinander verbinden möchte. Für diese Szenarien gibt es LiveBindings. Die Entwickler:innen können damit visuell die Eigenschaften eines Controls binden, ohne Quellcode schreiben zu müssen.

Die Programmlogik schreibt man in der Programmiersprache Delphi, einer Weiterentwicklung von Pascal. Beachten Sie dazu den Kasten „Delphi im Überblick“, wenn Sie mit der Sprache nicht vertraut sind. Für das Verständnis des Programmaufbaus hilft das Beispiel in Listing 1.

unit Unit1;
interface
uses
  System.SysUtils, System.Types, System.UITypes, …;
type
  TForm1 = class(TForm)
    Button1: TButton;
    procedure Button1Click(Sender: TObject);
  private
    { Private-Deklarationen }
  public
    { Public-Deklarationen }
  end;
var
  Form1: TForm1;
implementation
{$R *.fmx}
procedure TForm1.Button1Click(Sender: TObject);
begin
  // hier steht der Code, der beim Drücken des Buttons ausgeführt werden soll
end;
end.

Die Programmlogik wird in einzelnen Units abgelegt. Zu sehen ist eine Unit für ein Formular mit einem Ereignis, das auf das Drücken des Buttons reagiert. Dazu einige Bemerkungen: Eine Unit wird mit Hilfe des Schlüsselworts unit eingeleitet. Danach notiert man den Namen der Unit (Unit1). Es folgt der öffentliche Teil, der mit dem Schlüsselwort interface beginnt. In diesem Abschnitt erfolgen die Deklarationen, auf die von anderen Programmteilen aus zugegriffen werden kann. Eine Prozedur wird hier nicht vollständig implementiert, sondern es wird lediglich der Prozedurkopf notiert. Die eigentliche Implementierung erfolgt im Abschnitt implementation. Dieser ist der nichtöffentliche Teil der Unit. Variablen, Typen usw., die hier deklariert werden, sind auch nur innerhalb der Unit sichtbar. Dieser Abschnitt wird mit dem Schlüsselwort end und einem Punkt abgeschlossen. Über die uses-Klausel werden andere Units eingebunden. Da es sich hier um ein Formular handelt, gibt es neben Basisbibliotheken auch Bibliotheken für die grafische Benutzerschnittstelle. Mit type TForm1 =class (…) wird eine Klasse vom Typ TForm, also ein Formular deklariert. Von der Prozedur Button1Click(Sender: TObject) wird nur der Rumpf notiert. Was genau beim Klicken auf den Button passieren soll, das muss man im Abschnitt implementation festlegen. Im Beispiel ist es nur durch einen Kommentar angedeutet.

Die Interaktion mit Python

Damit Delphi mit Python Daten austauschen kann, gibt es Bibliotheken für die jeweiligen Grafikframeworks VCL und FireMonkey. Mit der Python4Delphi (P4D) Library [3] erhält man Zugriff auf das Python-API, eine Möglichkeit der bidirektionalen Interaktion von Delphi und Python und einen Zugriff auf Python-Objekte mit benutzerdefinierten Delphi-Variablen. Ebenso können Delphi-Objekte aus Python-Skripten genutzt werden. Voraussetzung für eine Interaktion von Delphi ist eine aktuelle Version von Python. Diese dürfte jedoch höchstwahrscheinlich schon auf Ihrem Rechner sein, wenn Sie bereits mit Python-Tools gearbeitet haben. Hinweise zur Einrichtung der P4D-Bibliothek finden Sie im Kasten „Installation von Python4Delphi“.

Installation von Python4Delphi

Die Installation ist am schnellsten über den internen Paketmanager GetIt von Delphi erledigt. Rufen Sie diesen über Tools | GetIt-Package-Manager auf und suchen Sie nach Python (Abb. 3). Installieren Sie die Bibliothek. Ergänzen Sie jeweils in Delphi über Tools | Optionen | Sprache | Delphi | Bibliothekspfad für die 32- und die 64-Bit-Version die Pfade in den folgenden Ordnern: \Source, \Source\VCL und \Source\FMX. Diese Ordner finden Sie als Unterordner der Python4Delphi-Bibliothek, d. h. unter $(BDSCatalogRepository)\Python4Delphi-1.0\. Damit ist die Installation von Python4Delphi abgeschlossen.

Abb. 3: Installation von P4D über GetIt und Zuweisung der Bibliothekspfade

Wir demonstrieren die Vorgehensweise zur Erstellung des User Interface und der Interaktion von Delphi mit Python an einem Beispiel. Dazu wollen wir die Bibliothek Python Pillow (PIL) [4] nutzen. PIL ist eine Bibliothek, um Bilder zu bearbeiten. Dazu gehören Modifikationen wie Drehung, Verschiebung, Skalierung, aber auch Bildmanipulation mit Filtern usw. Wir wollen ein Programm inklusive einer Benutzeroberfläche erstellen, das die Möglichkeit bietet, das Bild zu laden und über ein Skript die gewünschten Bildmanipulationen auszuführen. Der Vorteil eines solchen Programms gegenüber der bloßen Nutzung des CLI besteht darin, dass man das Bild über ein Dialogfeld komfortabel aus dem Dateisystem auswählen kann und die Anzeige des Originalbilds und der veränderten Form direkt im Programm erfolgt. Möchte man feste Algorithmen für die Bildbearbeitung definieren oder eine Stapelverarbeitung von Bildern – d. h. mehrere Bilder programmgesteuert automatisch bearbeiten – ist das auch kein größerer Aufwand.

Als Erstes ist die Programmoberfläche in Delphi zu gestalten. Dazu ist ein neues Projekt über Datei | Neu | Windows-VCL-Anwendung anzulegen. Dann werden die entsprechenden Komponenten aus der Toolpalette ausgewählt und auf dem Formular platziert. Konkret sind das:

• TImage zur Anzeige des Bilds

• TPanel nimmt zwei Komponenten des Typs TButton (Schaltfläche) auf

• TMemo ist eine mehrzeilige Eingabeoberfläche für die Erfassung des Python-Skripts

• TButton: zwei Schaltflächen, eine für die Auswahl des Bilds und eine für die Ausführung des Skripts

Das waren bereits die sogenannten visuellen Komponenten, also diejenigen, die man zur Laufzeit der Anwendung sieht. Ebenso werden die beiden folgenden – nichtvisuellen – Komponenten aus der Toolpalette ausgewählt:

• TOpenPictureDialog: Auswahl einer Bilddatei aus dem Dateisystem

• TPythonEngine: Verbindung zwischen Delphi- und Python-Anwendung; diese Komponente stammt aus der gerade installierten Bibliothek Python4Delphi

Die Komponenten sind auf dem Formular anzuordnen und entsprechend auszurichten, d. h. die TMemo– und die TPanel-Komponente werden am unteren Rand platziert (Eigenschaft Align = Bottom), und die TImage-Komponente nimmt den restlichen Platz ein (Eigenschaft Align = Client), wie in Abbildung 4 zu sehen ist. Mit diesen Einstellungen ist die Benutzeroberfläche bereits funktionsfähig und kann auf unterschiedlichen Bildschirmgrößen fehlerfrei ausgeführt werden.

Abb. 4: Aufbau der Benutzeroberfläche in Delphi

Kommen wir zur Beschreibung des Programmcodes. Dieser beschränkt sich auf die Behandlung der Ereignisse der beiden Schaltflächen. Beim Klick auf die Schaltfläche Open Picture… soll ein Dialogfeld zur Dateiauswahl (Bild) geöffnet werden, die ausgewählte Bilddatei geladen und der Bildvorschau (TImage-Komponente) zugewiesen werden. Dieser Vorgang ist mit zwei Zeilen Code erledigt:

if OpenPictureDialog1.Execute then
  Image1.Picture.LoadFromFile(OpenPictureDialog1.FileName);

Hier sehen wir den Vorteil eines ausgereiften Entwicklungssystems mit hochintegrierten Komponenten. Beim Klick auf den Button Execute soll das Python-Skript ausgeführt werden. Es wird in der TMemo-Komponente als mehrzeilige Zeichenkette eingegeben, muss aus dieser ausgelesen und zusammen mit dem Datenstrom für das Bild an das Python-Modul PIL übertragen werden. Das Python-Skript enthält den oder die Befehle, welche Modifikationen am Bild vorgenommen werden sollen. Für den Datenaustausch zwischen Delphi-Code und Python ist unsere Bibliothek Python4Delphi zuständig. Der Quellcode für den Datenaustausch hält sich auch hier in Grenzen (Listing 2).

procedure TForm1.Button2Click(Sender: TObject);
var
  _im: Variant;
  _stream: TMemoryStream;
  _dib: Variant;
  pargs: PPyObject;
  presult: PPyObject;
  P: PAnsiChar;
  Len: NativeInt;
begin
  if (Image1.Picture.Graphic = nil) or Image1.Picture.Graphic.Empty then
    raise Exception.Create('You must first select an image');
  PythonEngine1.ExecStrings(Memo1.Lines);
  _im := MainModule.ProcessImage(ImageToPyBytes(Image1.Picture.Graphic));
  Image1.Picture.Bitmap.SetSize(Image1.Width, Image1.Height);
  _dib := Import('PIL.ImageWin').Dib(_im);
  Image1.Picture.Bitmap.SetSize(Image1.Height, Image1.Width);
  _dib.expose(NativeInt(Image1.Picture.Bitmap.Canvas.Handle));
end;

Das Skript zur Bildbearbeitung wird in Python geschrieben. Das kann entweder zur Laufzeit der Anwendung erfolgen und interaktiv in die TMemo-Komponente eingegeben werden, oder man kann statische Python-Algorithmen definieren, die zum Beispiel bei einem Klick auf einen Button ausgeführt werden. Starten wir die Anwendung (Abb. 5).

Abb. 5: Ausführung des Programms zur Bildbearbeitung über ein Python-Skript

Das Python-Skript (Listing 3) enthält keine Überraschungen. Die Quellcodezeile für eine Bildrotation lautet beispielsweise:

new_im = im.rotate(90, expand=True)

Möchten Sie alternativ das Bild spiegeln, dann tauschen Sie diese Zeile gegen

new_im=ImageOps.mirror(im)

aus. Es steht Ihnen die gesamte Funktionspalette der Python-Bibliothek PIL zur Bildmanipulation in der Anwendung zur Verfügung. Abbildung 6 zeigt das Ergebnis, wenn das Bild gedreht wurde. Damit das Programm funktioniert, muss in Python die Bibliothek PIL installiert werden. Das geht am einfachsten über die Kommandozeile mit pip install Pillow. Das ist aber keine Besonderheit, sondern gehört zur Ausführung des Python-Skripts.

Abb. 6: Bildbearbeitung über eine Programmoberfläche mit Hilfe eines Python-Skripts

from io import BytesIO
from PIL import Image
from PIL import ImageOps
import sys
 
def ProcessImage(data):
  print(sys.version)
  stream = BytesIO(data)
  im = Image.open(stream)
  print ("Processing image %s of %d bytes" % (im.format, len(data)))
  new_im = im.rotate(90, expand=True)
  #new_im=ImageOps.mirror(im)
  new_im.format = im.format
  return new_im

Fazit und Ausblick

Mit Hilfe dieses Entwicklungsansatzes können wir effizient ansprechende grafische Benutzeroberflächen für Python-Programme erstellen. Anwendungsentwickler:innen können die gesamte Power des Python-Universums nutzen und Python-Entwickler:innen profitieren von den Möglichkeiten einer modernen Anwendungsentwicklung. Da Delphi-Applikationen über FireMonkey auf allen relevanten Clientbetriebssystemen, d. h. Windows, macOS, Linux, iOS und Android ausgeführt werden können, ergeben sich hier sehr viele Möglichkeiten, Fachanwendungen mit Python-Support bereitzustellen. Hinweis: Der Quellcode zum Beispiel wird unter [5] bereitgestellt.

Weitere Informationen zu diesen und anderen Themen der IT finden Sie unter http://larinet.com. Folgen Sie uns auch auf Instagram unter https://www.instagram.com/larinetcommunication.