2. Installatie van een werkomgeving

2.1. Python 3.8.1

De voorbeelden in dit document zijn getest met de Python 3.8.1-interpreter die beschikbaar is op URL |https://www.python.org/downloads/| (februari 2020) op een Windows 10-computer:

De installatie van Python resulteert in de bestandsstructuur [1] en het menu [2] in de lijst met programma’s:

• [3-4]: twee interactieve Python-interpretters;
• [5]: de Python-documentatie;
• [6]: de documentatie van de Python-modules;

We zullen de interactieve Python-interpreter niet gebruiken. Het is echter goed om te weten dat de scripts in dit document met deze interpreter kunnen worden uitgevoerd. Dit is handig om de werking van een Python-functie te testen, maar minder geschikt voor scripts die hergebruikt moeten worden. Hier volgt een voorbeeld met de hierboven genoemde optie [4]:

Via de prompt >>> kun je een Python-instructie invoeren die onmiddellijk wordt uitgevoerd. De hierboven getypte code heeft de volgende betekenis:

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

Regels:

• 1: initialisatie van een variabele. In Python hoef je het type van variabelen niet te specificeren. Deze krijgen automatisch het type van de waarde die eraan wordt toegewezen. Dit type kan in de loop van de tijd veranderen;
• 2: weergave van de naam. 'nom=%s' is een weergaveformaat waarbij %s een formele parameter is die verwijst naar een tekenreeks. nom is de daadwerkelijke parameter die in plaats van %s wordt weergegeven;
• 3: het resultaat van de weergave;
• 4: weergave van het type van de variabele 'naam';
• 5: de variabele 'nom' is hier van het type class. In Python 2.7 zou deze de waarde <type 'str'> hebben;

Laten we nu een Windows-console openen:

Het feit dat we zowel [python] als [1] konden invoeren en dat het uitvoerbare bestand [python.exe] werd gevonden, toont aan dat dit bestand zich in de PATH van de Windows-machine bevindt. Dit is belangrijk omdat het betekent dat de Python-ontwikkeltools de Python-interpreter zullen kunnen vinden. Dit kan als volgt worden gecontroleerd:

• in [2], we verlaten de Python-interpreter;
• bij [3] wordt de opdracht uitgevoerd die de lijst met uitvoerbare bestanden van de Windows-machine weergeeft;
• bij [4] zien we dat de map van de Python 3.8-interpreter deel uitmaakt van PATH;

2.2. De IDE PyCharm Community

2.2.1. Inleiding

Om de scripts in dit document te bouwen en uit te voeren, hebben we de [PyCharm] Community-editie gebruikt, die (februari 2020) beschikbaar is op URL |https://www.jetbrains.com/fr-fr/pycharm/download/#sectie=windows| :

Download de IDE PyCharm Community [1-3] en installeer deze.

Laten we IDE PyCharm starten en vervolgens een eerste Python-project aanmaken:

• Maak in [2-4] een nieuw project aan;

IDE PyCharm toont het aangemaakte project in de volgende vorm:

• in [2-3], laten we de eigenschappen van IDE bekijken;

• in [4], de Python-interpreter die voor het project zal worden gebruikt;
• in [5], een vervolgkeuzelijst met beschikbare interpreters;
• in [6] kiest men de interpreter die in de paragraaf |Python 3.8.1| is gedownload;

• in [7], de gekozen interpreter;
• in [8], de lijst met pakketten die beschikbaar zijn voor deze interpreter. De pakketten bevatten modules die Python-scripts kunnen gebruiken. Er zijn honderden modules beschikbaar;

Laten we beginnen met het aanmaken van een map waarin we ons eerste Python-script zullen plaatsen:

• klik met de rechtermuisknop op het project en vervolgens op [1-2] om een map aan te maken;
• Typ in [3] de naam van de map: deze wordt aangemaakt in de projectmap;

Laten we vervolgens een Python-script aanmaken:

• klik met de rechtermuisknop op de map [bases] en vervolgens op [1-3];
• geef in [4-5] de naam van het script op;

Laten we ons eerste script schrijven:

• in [3] schrijven we het volgende script:

  • regels 1, 3: opmerkingen beginnen met het teken #;
  • regel 2: initialisatie van een variabele. Python specificeert het type van zijn variabelen niet;
  • regel 4: weergave op het scherm. De syntaxis die hier wordt gebruikt is [format % données] met:
    • formaat: naam=%s, waarbij %s de plaats aangeeft van een tekenreeks. Deze wordt gevonden in het gedeelte [données] van de uitdrukking;
    • gegevens: de waarde van de variabele [nom] vervangt de opmaak %s in de opmaakreeks;
  • met [4-5] wordt de code opnieuw opgemaakt volgens de aanbevelingen van de organisatie die Python beheert;

Het script wordt uitgevoerd door met de rechtermuisknop op de code [6] te klikken:

• in [7], de uitgevoerde opdracht;
• in [8], het resultaat van de uitvoering;

Om het script van het document uit te voeren, downloadt u de code van URL |https://tahe.developpez.com/tutoriels-cours/python-flask-2020/documents/python-flask-2020.rar| en ga vervolgens in PyCharm als volgt te werk:

• in [1-2], een bestaand project openen: selecteer de map met de gedownloade code;
• in [3], het geopende project;
• in [4-5], voer een van de scripts van het project uit;

• in [7-8], de resultaten van de uitvoering;

2.2.2. Virtuele uitvoeringsomgeving

Onze werkomgeving is nu operationeel. We gaan deze echter aanpassen om de scripts voor deze cursus te schrijven. Laten we eerst de configuratie van PyCharm aanpassen:

In het venster aan de rechterkant:

• is het vakje [1] standaard aangevinkt. We vinken dit uit, zodat PyCharm niet standaard het laatst geopende project opent, maar ons zelf laat kiezen welk project we willen openen;
• bij [2] wordt het afsluiten van PyCharm niet bevestigd wanneer je het venster van de applicatie sluit;
• in [3] worden nieuwe projecten in een ander venster geopend;
• in [4]: als je PyCharm sluit terwijl er een programma wordt uitgevoerd, wordt dit programma gestopt;

Laten we PyCharm nu sluiten en vervolgens opnieuw openen:

• in [1] maken we een nieuw project aan;
• in [2], geef de map van het project op;
• In [3] moet je een virtuele omgeving gebruiken. Een virtuele omgeving is specifiek voor het project dat je aanmaakt. Deze raakt niet vermengd met de virtuele omgevingen van andere projecten. Een Python-/Flask-project maakt gebruik van talrijke externe bibliotheken die moeten worden geïnstalleerd. Een project met de naam P1 kan bibliotheek B in versie v1 gebruiken, terwijl een project met de naam P2 dezelfde bibliotheek B maar dan in versie v2 gebruikt. Deze twee versies kunnen min of meer compatibel zijn. Wanneer men echter een bibliotheek in versie v2 installeert terwijl versie v1 al is geïnstalleerd, wordt deze overschreven door versie v2. Dit kan problematisch zijn voor het project dat versie v1 gebruikte, als de nieuwe versie v2 niet volledig compatibel is met versie v1. Om deze problemen te voorkomen, wordt elk project geïsoleerd in een virtuele omgeving;
• geef in [4] de map aan waarin de Python-bibliotheken zullen worden opgeslagen die tijdens het project worden gedownload. We hebben hier gekozen voor een map [venv] (virtuele omgeving) binnen de projectmap. Dit is niet verplicht;
• in [5], de Python-interpreter van het project. Dit is degene die we in de vorige stap hebben geïnstalleerd;
• in [6], het project aanmaken;

• in [7-8], het aangemaakte project;
• in [9], de uitvoeringsomgeving van het project, ook wel virtuele omgeving genoemd;
• in [10] is de map [site-packages] de map waarin de later gedownloade bibliotheken zullen worden opgeslagen;

2.2.3. Git

Vervolgens wordt een programma voor broncodebeheer geactiveerd. In dit geval is dat Git [1-4]:

Met software voor broncodebeheer (VCS: Version Control System) kunnen we de ontwikkelingen van een project volgen. Door middel van een handeling die ‘commit’ wordt genoemd, kunnen op verschillende momenten in de levenscyclus van het project momentopnames worden gemaakt. Als er twee commits worden uitgevoerd op tijdstippen T en T+1, laat het VCS zien wat er tussen de twee gecommitteerde versies is veranderd. Normaal gesproken wordt het VCS gebruikt door een team van ontwikkelaars. Zij voeren commits uit van hun code zodra deze grondig is getest. Via het VCS kunnen andere ontwikkelaars deze gevalideerde code ophalen en gebruiken.

In dit geval is er slechts één ontwikkelaar. De ervaring leert dat een applicatie op tijdstip T kan werken, maar op tijdstip T+1 niet meer. Dan zouden we graag teruggaan naar tijdstip T om helemaal opnieuw te beginnen. De VCS maakt dit mogelijk en daarom gaan we deze hier gebruiken.

We laten zien hoe je dit met Git kunt doen.

• Selecteer in [1] het tabblad [Git] (linksonder);
• in [2] zie je dat er 495 projectbestanden zijn die niet door Git zijn versiebeheerd. Dit betekent dat ze bij het committen niet deel zullen uitmaken van de projectfoto’s;
• in [3]: de knop van [commit] of de knop voor het valideren van het project. Zoals gezegd maakt Git vervolgens een momentopname van het project en slaat deze op in een map [.git] in de hoofdmap van het project (niet weergegeven door PyCharm, maar wel zichtbaar in de Windows-verkenner);

Laten we het project in zijn huidige staat valideren via [3].

• in [4], de lijst met niet-gecontroleerde bestanden;
• in [5] zijn al deze niet-gecommitteerde bestanden afkomstig uit de virtuele omgeving [venv];
• in [6] moet elke commit vergezeld gaan van een bericht. De ontwikkelaar beschrijft hier de wijzigingen die de versie die gecommit gaat worden, ten opzichte van de laatst gecommitteerde versie met zich meebrengt;

Sommige mappen of bestanden kunnen door Git worden genegeerd. Ze maken dan nooit deel uit van de Git-repository. In [5] hierboven klikken we met de rechtermuisknop op de map [venv].

• In [1-3] geven we aan dat de map [venv] geen deel mag uitmaken van de Git-repository. De lijst met mappen en bestanden die door Git worden genegeerd, wordt opgeslagen in een bestand met de naam [.gitignore] [4];

• na de vorige bewerking verdwijnen alle bestanden uit de map [venv] uit de lijst met niet-gecontroleerde bestanden. Er blijft alleen het zojuist aangemaakte bestand [.gitignore] over;
• in [5] selecteren we dit bestand om het op te slaan;
• in [6] maken we een commitbericht aan:
• in [7] bevestigen we. Er wordt dan een projectfoto gemaakt;

• in [8-9], de inhoud van het bestand [.gitignore]: één regel met de naam van de map [/venv], wat aangeeft dat de inhoud ervan bij de foto's moet worden genegeerd;

Laten we nu eens bekijken wat Git voor ons kan betekenen. Allereerst maken we een map aan met de naam [git] (u kunt elke andere naam gebruiken – deze map kan aan het einde van de demonstratie worden verwijderd):

• in [1-5] maken we een map aan met de naam [git];

• bij [6-10] maken we een Python-script [git_01] aan;

• in [11-12] bevat het script alleen een opmerking;
• in [13-14] wordt een kopie gemaakt van [git_01]. Selecteer hiervoor [git_01] en druk op Ctrl-C (Kopiëren), vervolgens op Ctrl-V (Plakken) en geef [git_02] op als bestandsnaam;

Laten we nu ons project vastleggen. Er wordt een foto gemaakt met de twee bestanden [git_01, git_02];

• in [1-3], committen we het project;
• in [4] selecteren we de niet-gecommitteerde bestanden die we willen committen, in dit geval alle;
• in [5] voer je het bericht in dat de commit identificeert;
• in [6], bevestig je;

• in [1-2]: bevestig de commit;
• in [3] selecteer je het tabblad [Log];
• in [4], een overzicht van de branches van het project. Hier is er slechts één branch met de naam [master];
• in [5-6], de zojuist uitgevoerde commit;

Laten we nu op dezelfde manier een script [git_03] aanmaken:

Laten we het script [git_02] aanpassen en het script [git_01] verwijderen:

Vervolgens committen we de nieuwe versie:

Nu staan er twee commits in de logs:

Wanneer we een bepaalde commit selecteren, verschijnt rechts daarvan de bestandsboom van het project:

Laten we nu aannemen dat de laatste commit ons in een impasse heeft gebracht en dat we terug willen naar een situatie die overeenkomt met een van de eerdere commits:

• naar [1-2], selecteren we de commit naar de status waarvan we willen terugkeren;
• in [3-5] zijn er verschillende resetmodi. We kiezen de modus [hard], die terugkeert naar de geselecteerde toestand, waarbij de wijzigingen die sindsdien zijn aangebracht, verloren gaan;

• in [6] hebben we [git_01] teruggehaald, dat was verwijderd;
• bij [7-8] vinden we [git_02] terug in de oorspronkelijke toestand, zonder de wijziging die was aangebracht;

Laten we nu [git_02] aanpassen en [git_03] en [1-4] toevoegen:

Laten we nu de bewerking herhalen om terug te keren naar de oorspronkelijke commit:

• naar [1-4], dan keren we terug naar de foto van commit nr. 1;
• met [5-6] kiezen we de optie [Keep] in plaats van [Hard]. Deze opties zijn niet eenvoudig te begrijpen. Daarom moet je ze gewoon uitproberen:

• bij [1] is het bestand [git_03] nog steeds aanwezig;
• bij [2-3] zijn de wijzigingen in het bestand [git_02] behouden;

Het is moeilijk te zeggen wat dit [Revert Commit] heeft gedaan. Laten we nu de huidige situatie vastleggen:

• in [1-6], de commit;

• in [9] zien we de nieuwe commit;

Laten we nu proberen terug te gaan naar commit 1, zoals eerder is gedaan:

• in [1-6] keren we terug naar commit nr. 1 in de modus [Hard];

• in [7-8] zijn deze keer alle wijzigingen die sinds de eerste commit zijn aangebracht, inderdaad verloren gegaan;

Verderop zullen we niet meer terugkomen op [Git]. De lezer kan als volgt te werk gaan:

• hij kan de gegeven voorbeelden volgen door ze zelf in te typen of door ze van de cursuswebsite te downloaden;
• telkens wanneer een voorbeeld werkt, kan hij zijn project committen;
• wanneer hij zijn eigen code ontwikkelt en vastloopt, weet hij dat hij naar een stabiele situatie kan terugkeren door terug te gaan naar een eerdere commit;

2.3. Conventies voor het schrijven van Python-code

Je kunt Python-code schrijven zonder je aan schrijfconventies te houden en dat zal de werking ervan niet belemmeren. Maar het wordt mogelijk niet gewaardeerd door de Python-gemeenschap, die schrijfconventies heeft opgesteld. Deze zijn samengevat in een blogpost op |https://stackoverflow.com/questions/159720/what-is-the-naming-convention-in-python-for-variable-and-function-names|:

• De naam van een module (module_name) volgt een conventie die soms [snake_case] wordt genoemd: volledig in kleine letters, waarbij woorden eventueel door een onderstrepingsteken worden gescheiden. Deze conventie [snake_case] geldt voor de namen van methoden, pakketten, variabelen en functies;
• de naam van een klasse (ClassName) volgt een conventie die soms [PascalCase] wordt genoemd: een reeks aan elkaar geschreven woorden waarbij de eerste letter van elk woord een hoofdletter is;
• de namen van constanten volgen de conventie [SNAKE_CASE]: een reeks woorden in hoofdletters, gescheiden door een onderstrepingsteken;

Deze conventies zijn in dit document over het algemeen gevolgd. Voor modules die een klasse definiëren, heb ik de module echter dezelfde naam gegeven als de klasse die deze bevat. Deze volgt dus de conventie [PascalCase] in plaats van [snake_case]. Ik wilde de klassemodules snel kunnen herkennen.