2. Einrichtung einer Arbeitsumgebung

2.1. Python 3.8.1

Die Beispiele in diesem Dokument wurden mit dem Python-Interpreter 3.8.1 getestet, der unter URL |https://www.python.org/downloads/| (Februar 2020) auf einem Windows 10-Rechner verfügbar ist:

Durch die Installation von Python werden der Verzeichnisbaum [1] und der Menüeintrag [2] in der Programmliste erstellt:

[3-4]: zwei interaktive Python-Interpreter;
[5]: die Python-Dokumentation;
[6]: die Dokumentation der Python-Module;

Wir werden den interaktiven Python-Interpreter nicht verwenden. Man sollte lediglich wissen, dass die Skripte in diesem Dokument mit diesem Interpreter ausgeführt werden könnten. Er eignet sich gut zum Testen der Funktionsweise einer Python-Funktion, ist jedoch für Skripte, die wiederverwendet werden sollen, wenig geeignet. Hier ein Beispiel mit der oben genannten Option [4]:

An der Eingabeaufforderung >>> kann ein Python-Befehl eingegeben werden, der sofort ausgeführt wird. Der oben eingegebene Code hat folgende Bedeutung:

>>> nom="tintin"
>>> print("nom=%s" % nom)
nom=tintin
>>> print("type=%s" % type(nom))
type=<class 'str'>
>>>

Zeilen:

1: Initialisierung einer Variablen. In Python wird der Typ von Variablen nicht deklariert. Sie erhalten automatisch den Typ des Werts, der ihnen zugewiesen wird. Dieser Typ kann sich im Laufe der Zeit ändern;
2: Ausgabe des Namens. „nom=%s“ ist ein Ausgabeformat, bei dem %s ein formaler Parameter ist, der eine Zeichenkette bezeichnet. nom ist der tatsächliche Parameter, der anstelle von %s ausgegeben wird;
3: das Ergebnis der Anzeige;
4: Anzeige des Typs der Variablen „nom“;
5: Die Variable „nom“ ist hier vom Typ „class“. Unter Python 2.7 hätte sie den Wert <type 'str'>;

Öffnen wir nun eine Windows-Konsole:

Die Tatsache, dass wir sowohl „[python]“ als auch „[1]“ eingeben konnten und die ausführbare Datei „[python.exe]“ gefunden wurde, zeigt, dass sich diese im Verzeichnis „PATH“ des Windows-Rechners befindet. Das ist wichtig, da dies bedeutet, dass die Python-Entwicklungstools den Python-Interpreter finden können. Man kann dies wie folgt überprüfen:

in [2], man verlässt den Python-Interpreter;
in [3] zeigt der Befehl die PATH der ausführbaren Dateien des Windows-Rechners an;
bei [4] sieht man, dass der Ordner des Python-Interpreters 3.8 Teil von PATH ist;

2.2. Das IDE PyCharm Community

2.2.1. Einleitung

Zum Erstellen und Ausführen der Skripte in diesem Dokument haben wir den Editor [PyCharm] in der Community-Edition verwendet, der (Stand Februar 2020) unter URL |https://www.jetbrains.com/fr-fr/pycharm/download/# verfügbar istsection=windows| :

Laden Sie die Community-Edition IDE, PyCharm und [1-3] herunter und installieren Sie sie.

Starten Sie das Programm IDE PyCharm und erstellen Sie dann ein erstes Python-Projekt:

Erstellen Sie in [2-4] ein neues Projekt;

IDE PyCharm zeigt das erstellte Projekt in folgender Form an:

in [2-3], sehen wir uns die Eigenschaften von IDE an;

in [4], der Python-Interpreter, der für das Projekt verwendet wird;
in [5], eine Dropdown-Liste der verfügbaren Interpreter;
in [6] wählt man den im Abschnitt |Python 3.8.1| heruntergeladenen Interpreter aus;

in [7], dem ausgewählten Interpreter;
in [8] die Liste der mit diesem Interpreter verfügbaren Pakete. Die Pakete enthalten Module, die von Python-Skripten verwendet werden können. Es stehen Hunderte von Modulen zur Verfügung;

Beginnen wir damit, einen Ordner anzulegen, in dem wir unser erstes Python-Skript ablegen werden:

Rechtsklick auf das Projekt, dann auf [1-2], um einen Ordner zu erstellen;
Geben Sie unter [3] den Namen des Ordners ein: Er wird im Projektordner erstellt;

Anschließend erstellen wir ein Python-Skript:

Klicken Sie mit der rechten Maustaste auf den Ordner „[bases]“ und wählen Sie dann „[1-3]“ aus;
Geben Sie in „[4-5]“ den Namen des Skripts ein;

Schreiben wir unser erstes Skript:

In „[3]“ schreiben wir das folgende Skript:
- Zeilen 1, 3: Kommentare beginnen mit dem Zeichen #;
- Zeile 2: Initialisierung einer Variablen. Python deklariert den Typ seiner Variablen nicht;
- Zeile 4: Ausgabe auf dem Bildschirm. Die hier verwendete Syntax lautet [format % données] mit folgendem Format:
  - Format: name=%s, wobei %s die Position einer Zeichenkette angibt. Diese befindet sich im Teil [données] des Ausdrucks;
  - Daten: Der Wert der Variablen [nom] ersetzt das Format %s in der Formatzeichenfolge;
- Mit [4-5] wird der Code gemäß den Empfehlungen der Python-Verwaltungsorganisation neu formatiert;

Das Skript wird durch einen Rechtsklick auf den Code [6] ausgeführt:

in [7], der ausgeführte Befehl;
in [8], das Ergebnis der Ausführung;

Um das Skript des Dokuments auszuführen, laden Sie den Code unter URL |https://tahe.developpez.com/tutoriels-cours/python-flask-2020/documents/python-flask-2020.rar| und gehen Sie anschließend in PyCharm wie folgt vor:

In [1-2], Öffnen eines bestehenden Projekts: Geben Sie den Ordner mit dem heruntergeladenen Code an;
in [3] das geöffnete Projekt;
in [4-5]: Führen Sie eines der Skripte des Projekts aus;

in [7-8] die Ergebnisse der Ausführung;

2.2.2. Virtuelle Ausführungsumgebung

Unsere Arbeitsumgebung ist nun betriebsbereit. Wir werden sie jedoch anpassen, um die Skripte dieses Kurses zu schreiben. Zunächst ändern wir die Konfiguration von PyCharm:

Im rechten Fenster:

Standardmäßig ist das Kontrollkästchen [1] aktiviert. Wir deaktivieren es, damit PyCharm nicht standardmäßig das zuletzt geöffnete Projekt öffnet, sondern uns die Wahl lässt, welches Projekt geöffnet werden soll;
Bei „[2]“ wird das Beenden von PyCharm nicht bestätigt, wenn man das Anwendungsfenster schließt;
Bei „[3]“ werden neue Projekte in einem separaten Fenster geöffnet;
In [4] wird ein laufendes Programm beendet, wenn PyCharm geschlossen wird;

Schließen wir nun PyCharm und öffnen wir es anschließend wieder:

In [1] erstellen wir ein neues Projekt;
In [2] geben Sie den Projektordner an;
In [3] sollte eine virtuelle Umgebung verwendet werden. Eine virtuelle Umgebung ist spezifisch für das jeweilige Projekt, das erstellt wird. Sie vermischt sich nicht mit den virtuellen Umgebungen anderer Projekte. Ein Python-/Flask-Projekt nutzt zahlreiche externe Bibliotheken, die installiert werden müssen. Ein Projekt mit dem Namen P1 kann die Bibliothek B in der Version v1 verwenden, während ein Projekt mit dem Namen P2 dieselbe Bibliothek B, jedoch in der Version v2, nutzt. Diese beiden Versionen sind möglicherweise mehr oder weniger kompatibel. Wenn man jedoch eine Bibliothek in der Version v2 installiert und bereits eine Version v1 installiert ist, wird diese durch die Version v2 überschrieben. Dies kann für das Projekt, das die Version v1 verwendet hat, problematisch sein, wenn die neue Version v2 nicht vollständig mit der Version v1 kompatibel ist. Um diese Probleme zu vermeiden, isoliert man jedes Projekt in einer virtuellen Umgebung;
Geben Sie in [4] den Ordner an, in dem die Python-Bibliotheken abgelegt werden sollen, die im Laufe des Projekts heruntergeladen werden. Wir haben hier einen Ordner [venv] (virtuelle Umgebung) innerhalb des Projektordners gewählt. Dies ist jedoch nicht zwingend erforderlich;
In [5] wählen Sie den Python-Interpreter für das Projekt aus. Dies ist der Interpreter, den wir im vorherigen Schritt installiert haben;
in [6] das Projekt erstellen;

in [7-8] das erstellte Projekt;
in [9] die Ausführungsumgebung des Projekts, auch virtuelle Umgebung genannt;
in [10] ist der Ordner [site-packages] der Ordner, in dem die später heruntergeladenen Bibliotheken abgelegt werden;

2.2.3. Git

Anschließend wird ein System zur Quellcodeverwaltung aktiviert. In diesem Fall ist das Git [1-4]:

Eine Software zur Quellcodeverwaltung (VCS: Version Control System) ermöglicht es, die Entwicklungen eines Projekts zu verfolgen. Durch einen Vorgang namens „Commit“ kann man zu verschiedenen Zeitpunkten im Lebenszyklus des Projekts „Momentaufnahmen“ davon erstellen. Wenn man zwei Commits zu den Zeitpunkten T und T+1 durchführt, lässt sich mit dem VCS feststellen, was sich zwischen den beiden festgeschriebenen Versionen geändert hat. Normalerweise wird das VCS von einem Entwicklerteam genutzt. Die Entwickler führen Commits ihres Codes durch, sobald dieser ordnungsgemäß getestet wurde. Über das VCS können andere Entwickler diesen validierten Code abrufen und verwenden.

In diesem Fall gibt es nur einen Entwickler. Die Erfahrung zeigt, dass eine Anwendung zum Zeitpunkt T funktionieren kann, zum Zeitpunkt T+1 jedoch nicht mehr. Dann möchte man gerne zum Zeitpunkt T zurückkehren, um von vorne zu beginnen. Der VCS ermöglicht dies, und aus diesem Grund werden wir ihn hier verwenden.

Wir zeigen, wie man dabei mit Git vorgeht.

Wählen Sie in [1] die Registerkarte [Git] (unten links) aus;
In [2] sehen Sie, dass 495 Dateien des Projekts nicht von Git versioniert sind. Das bedeutet, dass sie beim Commit nicht Teil der Projektdateien sein werden;
In [3] befindet sich die Schaltfläche aus [commit] bzw. die Schaltfläche zur Bestätigung des Projekts. Wie bereits erwähnt, erstellt Git nun einen Snapshot des Projekts und speichert ihn in einem Ordner [.git] im Stammverzeichnis des Projekts (wird von PyCharm nicht angezeigt, ist aber im Windows-Explorer sichtbar);

Bestätigen wir das Projekt in seinem aktuellen Zustand mit [3].

In [4] die Liste der nicht versionierten Dateien;
In [5] sind alle diese nicht versionierten Dateien diejenigen der virtuellen Umgebung [venv];
in [6] muss jeder Commit mit einer Commit-Meldung versehen sein. Der Entwickler beschreibt hier die Änderungen, die die zu commitende Version gegenüber der zuletzt gecommittenen Version mit sich bringt;

Bestimmte Ordner oder Dateien können von Git ignoriert werden. Sie sind dann nie Teil des Git-Repositorys. Klicken wir oben in [5] mit der rechten Maustaste auf den Ordner [venv].

In [1-3] wird festgelegt, dass der Ordner [venv] nicht Teil des Git-Repositorys sein soll. Die Liste der von Git ignorierten Ordner und Dateien wird in einer Datei namens [.gitignore] [4] gespeichert;

Nach dem vorherigen Schritt verschwinden alle Dateien aus dem Ordner „[venv]“ aus der Liste der nicht versionierten Dateien. Übrig bleibt nur die soeben erstellte Datei „[.gitignore]“;
Wir wählen die Datei „[5]“ aus, damit sie gespeichert wird;
unter [6] erstellen wir eine Commit-Nachricht:
in [7] bestätigen wir. Das Projektfoto wird daraufhin aufgenommen;

in [8-9], der Inhalt der Datei [.gitignore]: eine einzige Zeile mit dem Namen des Ordners [/venv], der angibt, dass dessen Inhalt bei den Fotos ignoriert werden soll;

Zeigen wir nun, wozu Git uns dienen kann. Zunächst erstellen wir einen Ordner [git] (Sie können einen beliebigen anderen Namen verwenden – er kann am Ende der Demonstration gelöscht werden):

In „[1-5]“ erstellen wir einen Ordner „[git]“;

bei [6-10] erstellen wir ein Python-Skript mit dem Namen [git_01];

In [11-12] enthält das Skript nur einen Kommentar;
in [13-14] wird eine Kopie von [git_01] erstellt. Wählen Sie dazu [git_01] aus, drücken Sie Strg+C (Kopieren), dann Strg+V (Einfügen) und geben Sie [git_02] als Dateinamen an;

Nun führen wir ein Commit für unser Projekt durch. Es wird ein Foto mit den beiden Dateien [git_01, git_02] aufgenommen;

in [1-3], führen wir das Commit des Projekts durch;
in [4] wählen wir die nicht versionierten Dateien aus, die wir committen möchten – in diesem Fall alle;
in [5] gibt man die Commit-Beschreibung ein;
in [6] wird bestätigt;

in [1-2]: Bestätigung des Commits;
in [3] wählt man die Registerkarte [Log] aus;
in [4], eine Ansicht der Projektzweige. Hier gibt es nur einen einzigen Zweig namens [master];
in [5-6]: der soeben durchgeführte Commit;

Erstellen wir nun auf die gleiche Weise ein Skript mit dem Namen [git_03]:

Ändern wir das Skript [git_02] und löschen wir das Skript [git_01]:

Anschließend committen wir die neue Version:

Nun haben wir zwei Commits in den Logs:

Wenn man einen bestimmten Commit auswählt, erscheint rechts davon der Dateibaum des Projekts:

Nehmen wir nun an, der letzte Commit hat uns in eine Sackgasse geführt und wir möchten zu einem Zustand zurückkehren, der einem der vorherigen Commits entspricht:

zu [1-2], wählen wir den Commit aus, zu dessen Zustand wir zurückkehren möchten;
in [3-5] gibt es mehrere Reset-Modi. Wir wählen den Modus [hard], der zum ausgewählten Zustand zurückkehrt, wobei die seitdem vorgenommenen Änderungen verloren gehen;

In [6] wurde [git_01] wiederhergestellt, das zuvor gelöscht worden war;
bei [7-8] findet man [git_02] in seinem ursprünglichen Zustand wieder, ohne die zuvor vorgenommene Änderung;

Nun ändern wir „[git_02]“ und fügen „[git_03]“ sowie „[1-4]“ hinzu:

Nun führen wir den Vorgang erneut durch, um zum ursprünglichen Commit zurückzukehren:

zu [1-4] – damit kehren wir zum Bild des Commits Nr. 1 zurück;
mit [5-6] wählen wir die Option [Keep] anstelle von [Hard]. Diese Optionen sind nicht leicht zu verstehen. Man muss sie daher ausprobieren:

Bei [1] ist die Datei [git_03] weiterhin vorhanden;
bei [2-3] hat die Datei [git_02] ihre Änderungen beibehalten;

Schwer zu sagen, was diese Datei „[Revert Commit]“ bewirkt hat. Nun committen wir den aktuellen Stand:

in [1-6] der Commit;

in [9] sehen wir den neuen Commit;

Versuchen wir nun, zum Commit 1 zurückzukehren, wie es bereits geschehen ist:

In [1-6] kehren wir im Modus [Hard] zum Commit Nr. 1 zurück;

zu [7-8] – diesmal sind tatsächlich alle seit dem ersten Commit vorgenommenen Änderungen verloren gegangen;

Im weiteren Verlauf werden wir nicht mehr auf [Git] zurückkommen. Der Leser kann wie folgt vorgehen:

Er kann die angegebenen Beispiele entweder selbst eingeben oder von der Kurs-Website herunterladen;
Jedes Mal, wenn ein Beispiel funktioniert, kann er sein Projekt committen;
Wenn er seinen eigenen Code entwickelt und in eine Sackgasse gerät, weiß er, dass er zu einem stabilen Zustand zurückkehren kann, indem er zu einem früheren Commit zurückgeht;

2.3. Konventionen für das Schreiben von Python-Code

Man kann Python-Code auch ohne Schreibkonventionen schreiben, und das hindert ihn nicht daran, zu funktionieren. Er könnte jedoch von der Python-Community, die Schreibkonventionen festgelegt hat, nicht gut aufgenommen werden. Diese sind in einem Beitrag unter der Adresse |https://stackoverflow.com/questions/159720/what-is-the-naming-convention-in-python-for-variable-and-function-names| zusammengefasst:

Der Name eines Moduls (module_name) folgt einer Konvention, die manchmal als [snake_case] bezeichnet wird: ausschließlich Kleinbuchstaben, wobei Wörter gegebenenfalls durch Unterstriche getrennt werden. Diese Konvention [snake_case] gilt für die Namen von Methoden, Paketen, Variablen und Funktionen;
Der Name einer Klasse (ClassName) folgt einer Konvention, die manchmal als [PascalCase] bezeichnet wird: eine Aneinanderreihung von Wörtern ohne Leerzeichen, wobei der erste Buchstabe jedes Wortes großgeschrieben wird;
Die Namen von Konstanten folgen der Konvention [SNAKE_CASE]: eine Folge von Wörtern in Großbuchstaben, die durch einen Unterstrich getrennt sind;

Diese Konventionen wurden in diesem Dokument weitgehend befolgt. Bei Modulen, die eine Klasse definieren, habe ich dem Modul jedoch denselben Namen wie der darin enthaltenen Klasse gegeben. Es folgt somit der Konvention [PascalCase] anstelle von [snake_case]. Ich wollte Klassenmodule schnell erkennen können.