ergens in december 2024

Python - GOTO
 
Zoals reeds aangehaald in deel 1 bestaat er in Python geen "goto" instructie, maar je kan dat vrij gemakkelijk omzeilen.
Om dat te doen maken we uitbundig gebruik van de "while" instructie. Een en ander wordt duidelijk in onderstaand voorbeeld:

from time import sleep

stap = 1

while True:
   
    while stap == 1:
        print("stap = ",stap)
        sleep(1)
        stap = 3
       
    while stap == 2:
        print("stap = ",stap)
        sleep(1)
        stap = 4
       
    while stap == 3:
        print("stap = ",stap)
        sleep(1)
        stap = 2
       
    while stap == 4:
        print("stap = ",stap)
        sleep(1)
        stap = 1

Hier is enige verduidelijking op zijn plaats.
Je merkt dat de eerste "while" een beetje speciaal is. De voorwaarde om de "while" uit te voeren is dat wat volgt logisch "waar" is. Vandaar dus de "True:" voorwaarde. (let ook op de hoofdletter T in True en de dubbele punt na True:)
Wat wil zeggen dat het programma eerst de eerste lijnen uitvoert "from time import sleep" en "stap = 1" en daarna hier later in het programma nooit meer naar terugkeert. Tenzij natuurlijk je de "True" "False" kan maken, als je weet hoe.
Ik weet hoe: je plaatst in de "while True:" kring de "break" instructie, maar ik zou dat nooit in een programma opnemen.

Nog iets waar je rekening mee moet houden is de "indent" of "insprong" in het Nederlands. Die insprongen geven het niveau aan waaronder een instructie werkt. Zo zie je hierboven dat na de "while True:" er een insprong is voor de "while stap == 1:" kring. Zolang stap gelijk is aan 1 zal alles wat met een insprong onder "while stap == 1:" staat uitgevoerd worden. Zou die insprong er niet staan voor de "print("stap = ",stap)" en "sleep(1)" en "stap = 3", dan zouden deze instructies nooit uitgevoerd worden en zou het programma kringetjes blijven draaien op de instructie "while stap == 1". Het programma blijft daar dan "hangen" en als goede programmeur wil je nooit dat je programma ergens blijft hangen.

Zo ook, als "while stap == 1:" zonder insprong geplaatst zou zijn dan staat die op hetzelfe niveau als de "while True:" instructie en krijg je gelijk een foutmelding van de interpreter zoals deze: "IndentationError: expected an indented block after 'while' statement on line 5"

Dus, zolang de voorwaarde van de "while True:" kring "waar" is blijft het programma rondjes draaien binnen deze "while True:" instructie. In de praktijk begin ik het eigenlijke programma dus op de eerste regel die na de "while True:" volgt. Ik kan daar eender welke code zetten en die code zal het programma blijven uitvoeren zolang de waarde van "stap" op 1 blijft staan.
Beslis ik op een gegeven ogenblik dat ik een andere stap in het programma wens uit te voeren dan wijzig ik de waarde van "stap" en het programma gaat verder naar beneden tot het een "while" tegenkomt die als voorwaarde gelinkt is aan de waarde van "stap".

In bovenstaand voorbeeld ziet het resultaat van deze code er als volgt uit:

stap =  1
stap =  3
stap =  2
stap =  4
stap =  1
stap =  3
stap =  2
enz... enz... enz...

Dit ietwat simplistisch voorbeeld zal dus steeds de stappen doorlopen in de volgorde 1, 3, 2, 4 en dan terug naar 1. Het is duidelijk dat ik de volgorde waarin de stappen worden uitgevoerd naar believen naar mijn hand kan zetten door er bepaalde voorwaarden aan te koppelen. Die voorwaarden programmeer ik dan onder de "while stap == x:" kring die op dat ogenblik actief is.
Maar, let op: het programma gaat nooit rechtstreeks naar de volgende stap maar gaat gewoon het rijtje af tot het de stap tegenkomt die op dat ogenblik de waarde van de variabele "stap" is. Als je bv van stap 3 naar stap 1 wil gaan dan zal het programma eerst verder naar beneden gaan ("while stap == 4:") en kijken of er aan de volgende "while" voorwaarde voldaan is. Dit gaat zo verder tot de laatste "while" in het rijtje wordt bereikt en dan gaat het programma naar de instructie "while True:". Dit betekent dat alles wat je nog zou gecodeerd hebben tussen "while True:" en "while stap == 1:" eerst nog gaat uitgevoerd worden alvorens het programma naar de "while stap == 1:" zal springen.
Staat er bv na "while True:" als volgende instructie "stap = 2" dan ben je eraan voor de moeite want het programma zal dan niet "while stap == 1:" uitvoeren maar wel degelijk "while stap == 2:". Wees dus voorzichtig met wat je programmeert tussen de "while True:" en "while stap == 1:". Mijn advies: schrijf daar geen enkele instructie tussen en handel alles af binnen de stappen zelf.

En dan komt het belangrijkste: maak steeds en altijd eerst een flowchart van wat je wil programmeren. Je begrijpt dat je het programma zoals hierboven gemakkelijk in de war kan laten lopen als je niet zorgvuldig te werk gaat. En om zorgvuldig te werk kunnen te gaan is het onontbeerlijk dat je ALTIJD eerst een flowchart maakt van wat je wil bereiken met je programma.
Kidlin law: If you write a problem down clearly and specifically, you have solved half of it.
Zonder een flowchart kan je heel gemakkelijk verdwalen in je eigen creatie en kan het programma de meest gekke capriolen maken. En dat is nu net de reden waarom er in Python geen "goto" instructie bestaat.

Een flowchart brengt een aantal enorme voordelen met zich mee. Ik som er enkele op:
  1. Je krijgt een overzichtelijk schema dat
  2. visueel makkelijk te volgen is en
  3. je zal merken dat je verplicht bent om een gezonde, logische redenering te volgen om tot iets bruikbaars te komen
  4. Je zal ook gemakkelijker wegen vinden om je programma functioneler te maken dan wanneer je geen flowchart maakt
  5. Een flowchart verplicht je om heel goed na te denken over wat je wil bereiken en hoe je dat gaat bereiken.
  6. Gouden regel: laat de verbindingslijnen tussen twee blokken die de code moet uitvoeren elkaar NOOIT kruisen. Kom je toch in een situatie terecht dat zulke verbindingslijnen mekaar zouden kruisen, verzin dan snel wat anders. Kruisende lijnen op een flowchart zijn een gegarandeerd succes voor fouten.
  7. En tenslotte, wat de "echte" programmeurs absoluut willen vermijden is dat je je weg zou verliezen in een programma. Zolang dat programma goed en voldoende van commentaren is voorzien werkt dit voor een buitenstaander, of voor jezelf na de code enkele jaren niet meer gezien te hebben, vaak wel verhelderend. Je kan dan volgen wat er geprogrammeerd staat en waarom, dus wat de code verondersteld wordt te doen.
    Het grootste probleem van die kruisendde lijnen op een flowchart is dat wanneer er iets fout loopt in het programma (en in ietwat programma gaat er vrijwel zeker altijd ergens iets foutlopen) dat je dan niet of heel moeilijk weet hoe je op die plaats in het programma geraakt bent. Met andere woorden, wat was de aanleiding in de code om net daar verzeild te geraken. En, geloof me, dat is niet altijd gemakkelijk te achterhalen. En al zeker niet als je in tijdsnood zit en de storing dringend diet opgelost te worden.
Kortom, je bent een oen als je vooraf geen flowchart van je programma maakt want een overzicht krijgen van je programma aan de hand van enkel de code is niet mogelijk wanneer je code ietwat gecompliceerd begint te worden.
Wanneer ik spreek over "een programma" dan moet je je dat voorstellen in het aantal lijnen code die erin zitten. Tot een paar honderd lijnen kan je dat nog min of meer de baas zonder een flowchart. Maar stel dat je programma 30000 lijnen code bevat? Het langste programma dat ik ooit geschreven heb (niet in Python) bevatte inderdaad 30000 lijnen code. Als je dan niet overzichtelijk en systematisch werkt dan kom je geheid in de problemen. En dan begint een flowchart al meer tot de verbeelding te spreken.

Hier dan de flowchart van de code aan het begin van deze pagina:

Zoals je kan zien weet je nu precies hoe de structuur van je code in mekaar moet zitten.
En let ook op de pijltjes die op de flowchart staan. De meeste pijltjes zijn op zich niet nodig want de normale weg op een flowchart is van boven naar beneden en van links naar rechts. In principe moet je dus enkel aangeven met pijltjes wat daar van afwijkt. Ik plaats die pijltjes altijd, op elke lijn en liefst nog een pijltje te veel dan eentje te weinig. Dat maakt het interpreteren van zo een flowchart veel gemakkelijker en duidelijker.

Nu kan je je ook afvragen waarom ik met stappen werk en niet zoals voor de hand ligt de "while" instructie laat volgen door de gewenste voorwaarde om die instructie uit te voeren, zoals bv "while tel < max_tel and not HNK_sig.is_pressed:". Nee, ik zet die voorwaarden onder een "while stap == x" in de vorm van een "if" instructie: "if tel < max_tel and not HNK_sig.is_pressed:"
Als ik aan iedere "while" een stap nummer geef dan kan ik onder die "while" complexe voorwaarden beginnen schrijven die anders moeilijk of niet op één regel zouden kunnen geschreven worden. Elke "while stap == x" wordt zo een op zichzelf staand hoofdstukje in de code. Zo geven de stappen me veel meer flexibiliteit.
En ook, niet te verwaarlozen, verhoogt dit de leesbaarheid van het programma.

Hieronder dan een praktisch voorbeeld van een uitgewerkte "while stap == 5:"

# STAP 5 - Voorraad in VP opvullen
    while stap == 5:       
        VP.off()                 # start zuigmotor VacuPellet
        if HNVP_sig.is_pressed: # hoog niveau in de VacuPellet bereikt?
            VP.on()            # ja, stop zuigmotor
            stap = 6            # en start het laten leeglopen van de VacuPellet
        end = time.time()    # inlezen verlopen tijd in timer
        if (end - start) > T2:    # T2 = 60 sec, dus het vullen van de VacuPellet moet binnen de 60 sec gebeurd zijn, anders is er ergens iets misgelopen
            VP.on()            # stop de zuigmotor
            fout = 3            # Het duurt te lang om de VP te vullen
            stap = 10         # Afhandelen foutcode

Ik bedien in stap 5 een zuigmotor en laat die draaien tot een hoog niveau (HNVP) bereikt is. Wanneer dat hoog niveau bereikt is dan spring ik naar stap 6. Mocht er iets foutlopen dan ga ik niet verder met stap 6 maar met stap 10.
Ondertussen loopt er een timer, die in stap 4 geïnitialiseerd werd. Het hoog niveau moet binnen de 60 seconden bereikt worden. Indien dat niet zo is dan stop ik onmiddelijk de zuigmotor en genereer een foutcode die afgehandeld wordt in stap 10.

Opmerking:
De werking van "on" en "off" bij het aansturen van een uitgang is in mijn geval omgekeerd. Dat hangt samen met de hardware die ik gebruik om de uitgangen te sturen. Deze hardware laat niet toe dat ik het stuursignaal op de printplaat kan omdraaien, zodat in mijn geval .off() in feite de uitgang zal aansturen en op "aan" zetten. Dit echter is een puur hardwarematig probleem, maar bij het schrijven van de software moet ik er wel rekening mee houden.

En als je het nog niet wist dan merk je nu ook dat men commentaren kan toevoegen in het programma. Deze beginnen steeds met het hekje # en alles wat daarmee begint wordt aanzien als een commentaar (toelichting). Deze commentaren zijn een aanvulling op de flowchart om de code beter te kunnen volgen.
Soms zal je een "shebang" in de code vinden. Die start altijd met #!  Zo een shebang geeft aan waar bepaalde bestanden zich bevinden (of zich zouden moeten bevinden). Een shebang is dus geen commentaarregel.

En daarmee weet je nu ook dat een "goto" instructie wel degelijk kan gesimuleerd worden in Python.

Op de volgende pagina krijg je een voorbeeld van een programma dat ik recent geschreven heb.

   OVERZICHT    VORIGE    VOLGENDE