2. Einrichten einer Entwicklungsumgebung

2.1. Python 3.8.1

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

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

[3-4]: zwei interaktive Python-Interpreter;
[5]: Python-Dokumentation;
[6]: Python-Modul-Dokumentation;

Wir werden den interaktiven Python-Interpreter nicht verwenden. Es ist lediglich wichtig zu wissen, dass die Skripte in diesem Dokument mit diesem Interpreter ausgeführt werden könnten. Er ist zwar nützlich, um zu testen, wie eine Python-Funktion funktioniert, aber für Skripte, die wiederverwendet werden sollen, ist er nicht sehr praktisch. Hier ist ein Beispiel für die Verwendung der oben genannten Option [4]:

An der Eingabeaufforderung >>> können Sie eine Python-Anweisung eingeben, die 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 deklariert man den Typ von Variablen nicht. Sie nehmen automatisch den Typ des ihnen zugewiesenen Werts an. Dieser Typ kann sich im Laufe der Zeit ändern;
2: Anzeige des Namens. „name=%s“ ist ein Anzeigeformat, wobei %s ein formaler Parameter ist, der eine Zeichenkette bezeichnet. name ist der tatsächliche Parameter, der anstelle von %s angezeigt wird;
3: Das Ergebnis der Anzeige;
4: Anzeige des Typs der Variablen „name“;
5: Die Variable „name“ ist hier vom Typ „class“. In Python 2.7 hätte sie den Wert <type 'str'>;

Öffnen wir nun eine Windows-Konsole:

Die Tatsache, dass wir in [1] [python] eingeben konnten und dass die ausführbare Datei [python.exe] gefunden wurde, zeigt, dass sie sich im PATH des Windows-Rechners befindet. Dies ist wichtig, da es bedeutet, dass Python-Entwicklungstools den Python-Interpreter finden können. Wir können dies wie folgt überprüfen:

In [2] beenden wir den Python-Interpreter;
in [3] den Befehl, der den PATH für ausführbare Dateien auf dem Windows-Rechner anzeigt;
in [4] sehen wir, dass der Ordner des Python 3.8-Interpreters Teil des PATH ist;

2.2. Die PyCharm Community IDE

2.2.1. Einführung

Um die Skripte in diesem Dokument zu erstellen und auszuführen, haben wir den Editor der [PyCharm] Community Edition verwendet, der (Stand: Februar 2020) unter der URL |https://www.jetbrains.com/fr-fr/pycharm/download/#section=windows| verfügbar ist:

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

Starten Sie die PyCharm-IDE und erstellen Sie Ihr erstes Python-Projekt:

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

Die PyCharm-IDE zeigt das erstellte Projekt wie folgt an:

Sehen wir uns in [2-3] die Eigenschaften der IDE an;

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

in [7] den ausgewählten Interpreter;
in [8] die Liste der mit diesem Interpreter verfügbaren Pakete. Pakete enthalten Module, die Python-Skripte verwenden 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:

Klicken Sie mit der rechten Maustaste auf das Projekt und wählen Sie dann [1-2], um einen Ordner zu erstellen;
Geben Sie in [3] den Ordnernamen ein: Der Ordner wird im Projektordner erstellt;

Als Nächstes erstellen wir ein Python-Skript:

Klicken Sie mit der rechten Maustaste auf den Ordner [bases] und wählen Sie dann [1-3];
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 Symbol #;
Zeile 2: Initialisierung einer Variablen. Python deklariert den Typ seiner Variablen nicht;
Zeile 4: Bildschirmausgabe. Die hier verwendete Syntax lautet [Format % Daten] mit:
- format: name=%s, wobei %s den Platzhalter für eine Zeichenkette bezeichnet. Diese Zeichenkette befindet sich im Teil [data] des Ausdrucks;
- data: Der Wert der Variablen [name] ersetzt den Platzhalter %s in der Formatzeichenfolge;

Mit [4-5] formatieren wir den Code gemäß den Empfehlungen der Python-Verwaltungsstelle neu;

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 im Dokument auszuführen, laden Sie den Code von der URL |https://tahe.developpez.com/tutoriels-cours/python-flask-2020/documents/python-flask-2020.rar| herunter und gehen Sie dann in PyCharm wie folgt vor:

in [1-2] ein bestehendes Projekt öffnen: Wählen Sie den Ordner aus, der den heruntergeladenen Code enthält;
in [3] ist das Projekt geöffnet;
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 einsatzbereit. Wir werden sie jedoch anpassen, um die Skripte für diesen Kurs zu schreiben. Zunächst ändern wir die PyCharm-Konfiguration:

Im rechten Fenster:

Standardmäßig ist das Kästchen [1] angekreuzt. Deaktivieren Sie es, damit PyCharm nicht standardmäßig das letzte Projekt öffnet, sondern uns die Wahl lässt, welches wir öffnen möchten;
Unter [2] bestätigen wir beim Schließen des Anwendungsfensters nicht, dass PyCharm beendet werden soll;
Unter [3] werden neue Projekte in einem separaten Fenster geöffnet;
Unter [4] wird ein laufendes Programm beendet, wenn Sie PyCharm schließen;

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

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

in [7-8] das erstellte Projekt;
in [9] die Laufzeitumgebung des Projekts, die als virtuelle Umgebung bezeichnet wird;
in [10] ist der Ordner [site-packages], in dem später heruntergeladene Bibliotheken gespeichert werden;

2.2.3. Git

Als Nächstes aktivieren wir ein Versionskontrollsystem. Hier verwenden wir Git [1-4]:

Ein Versionskontrollsystem (VCS) ermöglicht es Ihnen, Änderungen an einem Projekt nachzuverfolgen. Sie können durch einen Vorgang namens „Commit“ Momentaufnahmen des Projekts zu verschiedenen Zeitpunkten seines Lebenszyklus erstellen. Wenn Sie zwei Commits zu den Zeitpunkten T und T+1 vornehmen, können Sie im VCS sehen, was sich zwischen den beiden festgeschriebenen Versionen geändert hat. Normalerweise wird das VCS von einem Entwicklerteam genutzt. Die Entwickler führen einen Commit durch, sobald ihr Code gründlich getestet wurde. Andere Entwickler können diesen validierten Code aus dem VCS abrufen und verwenden.

Hier gibt es nur einen Entwickler. Die Erfahrung zeigt, dass eine Anwendung zum Zeitpunkt T vielleicht funktioniert, zum Zeitpunkt T+1 jedoch nicht mehr. In diesem Fall möchten wir zum Zeitpunkt T zurückkehren, um von vorne zu beginnen. Das VCS ermöglicht dies, und deshalb werden wir es hier verwenden.

Wir zeigen Ihnen, wie das mit Git funktioniert.

Wählen Sie in [1] die Registerkarte [Git] (unten links);
in [2] sehen Sie, dass es 495 Projektdateien gibt, die nicht von Git versioniert sind. Das bedeutet, dass sie bei Commits nicht in den Projekt-Snapshot aufgenommen werden;
in [3] die Schaltfläche [commit] oder die Schaltfläche zur Projektvalidierung. Wie bereits erwähnt, erstellt Git dann einen Snapshot des Projekts und speichert ihn in einem [.git]-Ordner im Projektstammverzeichnis (wird von PyCharm nicht angezeigt, ist aber im Windows Explorer sichtbar);

Lassen Sie uns das Projekt in seinem aktuellen Zustand [3] committen.

In [4] die Liste der nicht versionierten Dateien;
In [5] gehören alle diese nicht versionierten Dateien zur virtuellen Umgebung [venv];
In [6] muss jeder Commit mit einer Nachricht versehen sein. Hier beschreibt der Entwickler die Änderungen, die durch die zu committende Version im Vergleich zur zuletzt committeten Version eingeführt wurden;

Bestimmte Ordner oder Dateien können von Git ignoriert werden. Sie werden dann nie in den Snapshot aufgenommen. Klicken Sie oben in [5] mit der rechten Maustaste auf den Ordner [venv].

In [1-3] legen wir fest, dass der Ordner [venv] nicht in die Git-Snapshots aufgenommen werden 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 im Ordner [venv] aus der Liste der nicht versionierten Dateien. Nur die soeben erstellte Datei [.gitignore] bleibt erhalten;
In [5] wählen wir sie aus, damit sie gespeichert wird;
In [6] erstellen wir eine Commit-Nachricht:
In [7] bestätigen wir. Anschließend wird ein Snapshot des Projekts erstellt;

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

Schauen wir uns nun an, wie Git nützlich sein 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];

in [6-10] erstellen wir ein Python-Skript [git_01];

in [11-12] enthält das Skript nur einen Kommentar;
Erstellen Sie in [13-14] eine Kopie von [git_01]. 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 ein;

Nun wollen wir unser Projekt committen. Es wird ein Snapshot der beiden Dateien [git_01, git_02] erstellt;

Führen Sie in [1-3] das Commit des Projekts durch;
Wählen Sie in [4] die nicht versionierten Dateien aus, die Sie committen möchten – in diesem Fall alle;
Geben Sie in [5] die Commit-Nachricht ein;
In [6] bestätigen wir;

Bestätigen Sie in [1-2] den Commit;
Wählen Sie in [3] die Registerkarte [Log] aus;
In [4] sehen Sie eine Übersicht über die Projektzweige. Hier gibt es nur einen Zweig namens [master];
in [5-6] den soeben durchgeführten Commit;

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

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

Führen Sie anschließend einen Commit für die neue Version durch:

Jetzt haben wir zwei Commits in den Logs:

Wenn Sie einen bestimmten Commit auswählen, wird rechts davon die Dateistruktur des Projekts angezeigt:

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:

Wählen Sie in [1-2] den Commit aus, zu dem Sie zurückkehren möchten;
in [3-5] stehen mehrere Reset-Modi zur Auswahl. Wir wählen den Modus [hard], der zum ausgewählten Zustand zurückkehrt und dabei die seitdem vorgenommenen Änderungen verworfen werden;

in [6] haben wir [git_01] wiederhergestellt, das gelöscht worden war;
in [7-8] finden wir [git_02] in seinem ursprünglichen Zustand ohne die vorgenommenen Änderungen;

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

Wiederholen wir nun den Vorgang der Rückgängigmachung auf den ursprünglichen Commit:

In [1-4] kehren wir zum Snapshot von Commit Nr. 1 zurück;
In [5-6] wählen wir die Option [Keep] anstelle von [Hard]. Diese Optionen sind nicht leicht zu verstehen. Deshalb müssen wir sie ausprobieren:

In [1] ist die Datei [git_03] noch vorhanden;
in [2-3] hat die Datei [git_02] ihre Änderungen beibehalten;

Es ist schwer zu sagen, was dieser [Revert Commit] bewirkt hat. Lassen Sie uns nun den aktuellen Stand festschreiben:

In [1-6] sehen wir den Commit;

in [9] sehen wir den neuen Commit;

Versuchen wir nun, wie zuvor zu Commit 1 zurückzukehren:

In [1-6] kehren wir im [Hard]-Modus zu Commit #1 zurück;

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

Von hier an werden wir nicht mehr auf [Git] zurückkommen. Der Leser kann wie folgt fortfahren:

Er kann den bereitgestellten Beispielen folgen, indem er sie entweder selbst abtippt oder von der Kurswebsite herunterlädt;
Wenn ein Beispiel funktioniert, kann er sein Projekt committen;
wenn er beim Entwickeln seines eigenen Codes in eine Sackgasse gerät, weiß er, dass er durch das Zurücksetzen auf einen früheren Commit zu einem stabilen Zustand zurückkehren kann;

2.3. Python-Codierungskonventionen

Man kann Python-Code schreiben, ohne die Programmierkonventionen zu befolgen, und er wird trotzdem funktionieren. Aber er wird von der Python-Community, die diese Konventionen festgelegt hat, möglicherweise nicht geschätzt. Diese sind in einem Beitrag unter |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: alles in Kleinbuchstaben, wobei Wörter bei Bedarf durch Unterstriche getrennt werden. Diese [snake_case]-Konvention 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, wobei der erste Buchstabe jedes Wortes großgeschrieben wird;
Konstantennamen folgen der [SNAKE_CASE]-Konvention: eine Folge von Wörtern mit Großbuchstaben, die durch Unterstriche getrennt sind;

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