| 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:
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 |