Activiteiten van maximaal 10 minuten
Kies hier uit verschillende activiteiten waarmee je stap voor stap leert programmeren in Python.
Unit 1 Introductie van de Python-applicatie
Oefenblad 1 : Rekenen in Python
Teacher's NotesIn deze eerste les maak je kennis met de TI-Python programmeer editor en het gebruik van een aantal veel voorkomende bewerkingen in Python.
Doelen :
-
Het gebruik van de TI-Python editor
-
Het verschil tussen editor en shell
Stap 1
Start met een nieuw document en kies voor Add Python en dan New... .
Stap 2
Er verschijnt een scherm waarin je de naam van het te maken programma kunt intypen en voor een type kan kiezen.
Typ een naam in en druk dan op enter (dus het type is dan Blank Program)
Stap 3
Je komt nu in de zogenaamde editor waarin je programma code kunt intypen en wijzigen.
We beginnen met een eenvoudig programma dat alleen een tekst afdrukt.
Daarvoor is de Python opdracht: print().
Dit kun je intypen, maar je kunt deze opdracht ook in het menu vinden.
(Menu > 4:Built-ins > 6:I/O > 1:print())
Stap 4
Maak het programma af door tussen de haakjes de gewenste tekst in te typen.
Belangrijk: Letterlijke tekst moet in Python tussen aanhalingstekens staan. In de editor zie je dat dit groen wordt afgedrukt. Dit voor de duidelijkheid en als hulp om de aanhalingstekens op de juiste plek te sluiten.
Het programma is nu af.
Stap 5
Om te controleren of het voldoet aan de syntax (grammatica) van Python kun je dat checken met Menu > 2:Run > 2:Check syntax & Save.
(Dat kan ook met Ctrl+B)
Als je dit gedaan hebt staat er in de bovenste regel van het scherm achter de programmanaam: saved successfully.
Dat betekent dat er geen syntaxfouten zijn.
Je kunt het programma nu uitvoeren (runnen) door weer naar het menu te gaan en nu te kiezen voor Run (of met Ctrl+R).
Stap 6
Er wordt nu een nieuw scherm aangemaakt waarin het programma wordt uitgevoerd. Dit heet de shell.
Je kunt met Ctrl-links en Ctrl-rechts wisselen tussen de editor en de shell.
Ga eerst weer naar de editor en wijzig het programma door een tweede regel toe te voegen met andere teksten en voer het opnieuw uit.
Je ziet dan direct het resultaat.
Oefenblad 2 : Datatypes in Python
Teacher's NotesIn deze tweede les maak je kennis met verschillende datatypes die in Python gebruikt worden.
Doelen :
- Het gebruik van de Python shell
- Omgaan met verschillende gegevenstypes
Stap 1
Start met een nieuw document en kies nu voor Add Python en dan 3:Shell.
Je komt dan in de Python shell.
Het verschil met de editor is dat de opdrachten die je hierin in typt direct worden uitgevoerd.
Stap 2
In het vorige programma drukten we een tekst af. In computer programmeren is tekst van het type: string.
Je kunt dat ook in Python opvragen met de functie type()
De functie type() kun je vinden bij Menu > 3:Built-ins . 5:Type > 6:type() maar je kunt het ook gewoon intypen.
Stap 3
Als je in de shell intypt: type(“Hallo”) dan geeft Python het type weer.
<class ‘str’> betekent dat de tekst van het type string is.
Zo zijn er verschillende datatypes in Python.
Stap 4
Enkele andere belangrijke datatypes zijn int (gehele getallen), float (komma getallen), list (lijsten).
Merk op dat hiernaast het getal 8 van het type integer (int) is terwijl 8/2 van het type float is (hoewel 8/2 = 4).
Dat komt omdat 8/2 een deling is en door Python benaderd wordt en dus een afgerond getal is.
Stap 5
Soms is het nodig om het datatype in Python te wijzigen.
Zo kun je de deling 8/2 veranderen in een integer met de functie int().
Controleer wat het type is van int(20/5).
Je ziet hiernaast ook dat je de tekst “23” kunt converteren naar een getal van het type integer.
Converteer op dezelfde manier de tekst “35.9” naar een kommagetal met float(“35.9”).
En ook het getal 7 naar het type string met str(7)
In een volgende les zullen we hiervan gebruik maken.Oefenblad 3 : De Python editor
Teacher's NotesIn deze les leren we meer over de syntax van Python en het gebruik van variabelen
Doelen :
- Een variabele gebruiken in Python
- De input()-opdracht in Python
- Het gebruik van een functie in Python
Stap 1
Het is vaak nodig dat je de loop van een computerprogramma kan beïnvloeden tijdens de uitvoering. Een van de opdrachten waar dat mee kan is input().
Maak een programma dat eerst vraagt om de naam van de gebruiker en die dan op het scherm afdrukt.
Begin weer met een nieuw Python programma (Nieuw document, Add Python, New.
Begin het programma met de vraag naar de naam van de gebruiker.
De ingevoerde naam moeten we wel ergens opslaan (toekennen aan een variabele).
Noem die variabele bijvoorbeeld naam.
Het programma kan dan beginnen zoals hiernaast.
In dit voorbeeld is nog een andere eigenschap van Python te zien: Je kunt twee teksten (strings) samenvoegen tot één met een plus teken.Stap 2
Stap 3
De Python opdracht input() geeft altijd een string als uitkomst.
Als we een getal willen invoeren moeten we die string omzetten naar een integer (geheel getal) of float (komma getal).
We maken een programma dat vraagt om een getal en dat dan het kwadraat van dat getal afdrukt.
Begin met een input opdracht en eindig met een print opdracht.
Een voorbeeld vind je hiernaast.
Het kwadraat geef je in Python aan met twee keertekens.
Stap 4
Je kunt in Python ook zelf gedefinieerde functies gebruiken.
We veranderen het programma zo dat het berekenen van het kwadraat in een functie gebeurt.
De syntax (grammatica) is hierbij belangrijk.
Als je het menu gebruikt krijg je daarbij hulp.
Stap 5
Ga naar Menu --> Built-ins --> Functions --> def function().
Stap 6
Vul eerst de naam in (bijvoorbeeld kwadraat).
Dan het argument (bijvoorbeeld x) en in het “block” de opdrachten.
Om aan te geven wat de uitkomst is kun je eindigen met “return”.
In het voorbeeld is dat de waarde van a.
De sjabloon laat zien hoe de syntax er uit moet zien:
Alle opdrachten die bij de functie horen springen hetzelfde aantal spaties in.
In het programma hiernaast wordt het kwadraat van 20 afgedrukt.
- Oefenblad 1
- Oefenblad 2
- Oefenblad 3
Unit 2 Programmeren in Python
Oefenblad 1 : Voorwaardelijke opdrachten
Teacher's NotesIn deze les maken we kennis met de voorwaardelijke opdrachten.
Doelen :
- Het gebruik van de opdracht if ... else ... .
- Wat is de syntax voor deze opdracht in Python
Stap 1
In elke programmeertaal is er wel een voorwaardelijke opdracht.
Zo’n opdracht heeft de vorm: als ... dan ... .
Als een bepaalde voorwaarde geldt dan moet er iets gebeuren.
Vaak kan er nog een extra regel bij gevoegd worden wat er anders moet gebeuren.
Stap 2
Voorbeeld :
Een autoverhuurbedrijf heeft de volgende aanbieding:
De huurprijs is € 66,-- voor de eerste 70 kilometer plus nog € 0,25 voor elke kilometer die extra gereden wordt.
We maken een programma dat om het aantal verreden kilometers vraagt en dan de bijbehorende prijs afdrukt.
Stap 3
Start een nieuw document met daarin een Python programma.
Begin met de vraag naar het aantal kilometers en noem dat k.
De Python opdracht input() geeft altijd een string als uitkomst, maar we willen een getal voor k. Dat kan door het type te wijzigen naar een geheel getal met de functie int(). (We gaan er hierbij vanuit dat het aantal kilometers een geheel getal is)
De eerste twee regels van het programma kunnen er nu uitzien zoals hiernaast.
Stap 4
Om het juiste bedrag te berekenen moet eerst bepaald worden of het aantal kilometers meer of minder dan 70 is. Daarvoor kun je de if structuur gebruiken.
Die kun je vinden met: Menu > 4 Built-ins > 2 Control > if..else..
In het sjabloon hiernaast komt direct achter if de voorwaarde te staan.
Stap 5
In het eerste blok komen de opdrachten die moeten worden uitgevoerd als de voorwaarde geldt. In het tweede blok komen de opdrachten die in het andere geval moeten worden uitgevoerd.
Alle opdrachten die in hetzelfde blok zitten moeten met hetzelfde aantal spaties beginnen. Dat is een syntax-eigenschap van Python.
Je ziet ook aan het eind van de regel met if en die met else een dubbele punt. Dit is ook een eigenschap van Python.
Stap 6
Vul het sjabloon in.
Het resultaat van de berekening moet natuurlijk ook nog worden afgedrukt.
Met Ctrl+R kun je het programma uitvoeren.
Er wordt dan zo nodig een nieuwe shell geopend.
Wil je daarna het programma nog een keer uitvoeren, dan kan dat vanuit de shell met opnieuw Ctrl+R.
Stap 7
In plaats van de inputopdracht kun je het programma ook uitvoeren als een functie.
Hiernaast is dat gedaan. De functie heeft de naam “bedrag” gekregen.
Stap 8
Als je dit programma uitvoert gebeurt er op het eerste gezicht niets. Maar als je nu op de var toets drukt (of Menu > Variables > 1 Vars: Last Run Program), dan zie je de functie staan en kun je hem selecteren.
Als je nu een waarde invult krijg je de berekende prijs.
Oefenblad 2 : De for lus
Teacher's NotesIn les 2 van deze unit leren we hoe je opdrachten kunt herhalen.
Doelen :
- Hoe gebruik je de opdracht for .
- Wat is de syntax voor deze opdracht in Python
Stap 1
De kracht van een computerprogramma is de mogelijkheid om een serie opdrachten eventueel met een kleine wijziging te herhalen.
Een van de opdrachten hiervoor is de for ... lus
We maken een programma dat van de eerste 8 gehele getallen het kwadraat en de derde macht afdrukt.
Open een nieuw Python programma en geef het een naam.
In het menu staan bij Built-ins onder Control de opties voor een for..lus.
Stap 2
De letter i is de zogenaamde teller. Die start als er geen beginwaarde is opgegeven altijd bij 0.
De lus wordt 8 keer doorlopen waarbij telkens de waarde van i een groter wordt.
De laatste waarde van i zal dus 7 zijn.
De opdrachten die in het blok staan worden nu 8 keer herhaald.
Je ziet ook hier weer de dubbele punt aan het eind van de regel waar het blok begint.Stap 3
We willen de kwadraten en derde machten afdrukken dus die gaan we binnen de lus berekenen.
In Python noteer je machtsverheffen met twee keertekens. Dus 25 wordt in Python geschreven als: 2**5
In de for-lus moeten we telkens i**2 en i**3 berekenen en afdrukken.
Voeg deze regels toe en bekijk het resultaat met Ctrl+R.Stap 4
We kunnen de resultaten ook opslaan in een lijst.
Begin het programma dan met een lege lijst (Een lege lijst is een lijst zonder elementen)
Elke keer als de lus wordt doorlopen voegen we een nieuwe uitkomst toe aan de lijst met .append. (In Python is dit een manier om een lijst uit te breiden.)
Pas het programma aan zodat de lijst met kwadraten wordt gemaakt en druk deze uiteindelijk af.
De printopdracht staat nu buiten de lus. Kijk ook eens wat er gebeurt als je deze printopdracht binnen de lus zet! (dus de laatste regel laat beginnen met twee spaties.)
Stap 5
In de wiskunde is 5! (5 faculteit) de uitkomst van 5*4*3*2*1 = 120.
Maak een programma waarin de faculteit-functie wordt gedefinieerd.
Aanwijzing:
Start met het getal 1 en maak een for-lus waarbij elke keer de nieuwe uitkomst wordt vermenigvuldigd met de lus-variabele (i).
Ga na dat je hiermee de faculteit van grote getallen kunt berekenen.
(Als je het programma uitvoert kom je in de shell waar dan de functie is gedefinieerd. Met de var toets of met Ctrl+L kun je hem oproepen)
Oefenblad 3 : De while lus
Teacher's NotesIn les 3 van deze unit leren we hoe je opdrachten kunt herhalen
Doelen :
- Hoe gebruik je de opdracht while ... .
- Wat is de syntax voor while opdracht in Python
Stap 1
Als je een serie opdrachten een aantal keren wilt herhalen, maar je weet van tevoren niet hoe vaak, dan kun je de while... lus gebruiken.
Dit kun je lezen als:
Zolang een bepaalde voorwaarde geldt blijf dan herhalen.
We maken een programma dat het volgende probleem simuleert:
Werp met een dobbelsteen en herhaal dit net zolang totdat je 6 gooit en tel het aantal keren dat je hiervoor nodig hebt.
Je weet dus van tevoren niet hoe vaak je moet gooien.Stap 2
Open een nieuw Python programma en geef het een naam.
Omdat we randomgetallen gaan gebruiken hebben we de random module nodig.
Deze module is een soort bibliotheek met functies voor randomgetallen.
In Python is het gebruikelijk om dit aan het begin van het programma te doen.
Je kunt deze module vinden in het menu bij Random en dan keuze 1 om alle functies te importeren.
Stap 3
We gaan in het programma twee variabelen gebruiken.
De variabele ‘aantal’ die bijhoudt hoe vaak er is gegooid en de variabele ‘uitkomst’ die bijhoudt wat er is gegooid.
Beide variabelen geven we als startwaarde 0.
(Je kunt natuurlijk ook andere namen kiezen)
Voeg het sjabloon toe voor while ... met Menu > Built-ins > Control.
Achter while komt de voorwaarde te staan.
Dat is in dit geval: uitkomst is ongelijk aan 6
In Python noteer je dat als: uitkomst != 6. (dit kun je intypen, maar je kunt ook in het menu kijken bij Built-ins en dan Ops)
Stap 4
In het herhalingsblok komen twee opdrachten te staan. De eerste is het kiezen van een randomgetal tussen 1 en 6 en de tweede is het aantal met 1 verhogen.
Als de uitslag gelijk is aan 6 wordt de lus verlaten en volgt nog de opdracht om het aantal worpen af te drukken.
Als je het programma een aantal keren uitvoert (Ctrl+R) dan zie je waarschijnlijk verschillende waarden voor aantal.
Stap 5
We gaan het programma wijzigen zodat we het experiment niet één keer maar honderd keer uitvoeren en dan het gemiddeld aantal worpen berekenen.
Verander eerst het vorige programma zo dat het werpen met de dobbelsteen totdat zes is gegooid in een functie wordt gezet (noem die functie bijvoorbeeld dobbelen()).
Let op het gebruik van de spaties.
Je kunt het hele functieblok in een keer ‘opschuiven’ door het met de shift toets en de pijltoetsen te selecteren en dan de tab toets in te drukken.
Stap 6
Als je deze functie 100 keer uitvoert, de aantallen optelt en het totaal deelt door 100 krijg je het gemiddeld aantal worpen.
Begin met een variabele som en zet deze op nul.
Stap 7
Maak nu een for-lus waarin de dobbel-functie 100 keer wordt uitgevoerd en tel telkens het aantal worpen op bij de som.
Als laatste komt de opdracht om som/100 af te drukken.
Om het gemiddelde nauwkeuriger te bepalen kun je bijvoorbeeld het getal 100
in het programma wijzigen in 1000 (op twee plekken).
Je berekent dan het gemiddelde van 1000 experimenten.Toepassing: De abc formule
Teacher's NotesIn deze toepassing gaan we een programma schrijven dat de oplossing(en) van een tweedegraads vergelijking berekent (als die er zijn).
Doelen :
- Het gebruik van de opdracht if ... else ... .
- Een functie definiëren
De vergelijking ax2 + bx + c = 0 heeft 2, 1 of 0 oplossingen.
We gaan een functie schrijven met als argumenten de getallen a, b en c.
De uitkomst zijn de oplossingen of de mededeling dat er geen oplossing is.
Stap 1
Begin een nieuw programma en kies bij het scherm waar de naam moet worden ingetypt voor het type Math Calculations
We hebben deze module nodig omdat we de wortel van een getal willen berekenen. Als het goed is krijg je hetzelfde scherm als hiernaast.
De eerste regel begint met een #. In Python betekent dit dat het een commentaar regel is en deze wordt niet uitgevoerd.
(uiteraard kun je ook later nog deze math module laden)
Stap 2
Begin met het sjabloon van een functie en noem deze functie los_op(a,b,c).
In de naam van een variabel (of functie) kun je een onderstrepingsteken gebruiken voor de leesbaarheid.
De functie heeft drie argumenten (a, b en c). Dit zijn de waarden van a, b en c uit de vergelijking.
Bereken eerst de discriminant D
Er zijn nu drie mogelijkheden:
D<0 (geen oplossingen), D=0 (één oplossing) of D>0 (twee oplossingen).
Gebruik det if ... elif ... else ... structuur om de drie mogelijkheden te onderscheiden.
Stap 3
We beginnen met het geval D<0. Dan zijn er dus geen oplossingen.
Het volgende geval is als D=0.
Dan is er één oplossing.
(Let op: in Python gebruik je een dubbel = teken om de gelijkheid te controleren).
Stap 4
Vul de blokken in.
Stap 5
Er zijn verschillende manieren om de functie te gebruiken.
Je kunt het programma uitvoeren met Run (Ctrl+R) en dan in de shell met de var toets de functie opvragen en de juiste argumenten invullen
Je kunt ook het programma uitbreiden en de functie daarin gebruiken.
Dat is hiernaast gedaan.
De regel a=float(input(“a: “)) doet het volgende:
De tekst “a: “ wordt afgedrukt op het scherm, het ingetypte getal is van het type string en dat wordt met de functie float() omgezet naar een komma getal.
Dit kan natuurlijk ook in meerdere regels.
- Oefenblad 1
- Oefenblad 2
- Oefenblad 3
- Toepassing
Unit 3 Programmeren in Python
Oefenblad 1 : Voorwaardelijke opdrachten
Teacher's NotesIn deze Unit gaan we wat dieper in op programmeren in Python.
Doelen :
- Meer over voorwaardelijke opdrachten
- True en False.
- Deelbaarheid.
Stap 1
Een positief geheel getal heet priemgetal als het slechts twee delers heeft (1 en zichzelf).
Zo is 7 een priemgetal want er zijn maar twee delers (1 en 7), maar 10 is geen priemgetal omdat 10 deelbaar is door 1, 2, 5 en 10.
Het kleinste priemgetal is 2.
We gaan een functie maken waarmee je kunt bepalen of een getal een priemgetal is.
De uitkomst van deze functie is True (waar) als het getal een priemgetal is en False (onwaar) als het getal geen priemgetal is.
Met behulp van deze functie berekenen we daarna het honderdste priemgetalStap 2
We maken gebruik van een speciale deling: %
In Python geeft dit de rest bij een deling.
Zo is bijvoorbeeld 20%3 gelijk aan 2 want 20/3=6 met een rest van 2.
(3 past 6 keer in 20 en je houdt 2 over)
Dit betekent als a%b = 0 dat b dan een deler is van a. (b past een heel aantal keren in a, de rest is nul).Stap 3
Begin met de definitie van de functie is_priem(n).
Als n<2 kan het geen priem zijn. Dan is de uitkomst dus False.
Als n>=2 dan controleren we of er een deler is.
Zo ja dan is de uitkomst False, anders is de uitkomst True.
(Je kunt True en False vinden in het menu bij Built-ins en dan bij 3:Ops)
Stap 4
Om het honderdste priemgetal te vinden maken we een while-lus.
Eerst kiezen we een teller (i) en geven die de waarde 0.
De variabele p doorloopt de getallen 2 en verder.
Telkens als p een priemgetal is wordt i een opgehoogd tot dat i=100.
Ga na dat je op deze manier het honderdste priemgetal krijgt.
Stap 5
De functie is_priem(n) in het programma is erg traag.
Als je bijvoorbeeld het 1000-ste priemgetal wilt berekenen kost dat veel tijd (zeker op de handheld).
Je kunt de functie aanmerkelijk sneller maken.
Als 3 een deler is van 27, dan is 9 dat ook want 3*9=27.
Telkens als je een deler hebt gevonden heb je er automatisch nog een.
Eigenlijk hoef je alleen maar getallen te controleren die kleiner of gelijk zijn dan de wortel van n.
Stap 6
Dit voegen we toe in de functie.
Om de wortel te kunnen gebruiken hebben we de math-module nodig.
Voeg aan het begin van het programma deze module in met from math import *.
Oefenblad 2 :Recursieve functie
Teacher's NotesIn deze Unit gaan we wat dieper in op programmeren in Python.
Doelen :
- Een recursieve functie definiëren.
- Recursief versus rechtstreeks.
Een recursieve functie is een functie die zichzelf aanroept.
Een mooi voorbeeld hiervan is de faculteit functie.
Onder 5! (spreek uit 5 faculteit) verstaan we: 5 ∙ 4 ∙ 3 ∙ 2 ∙ 1 = 120 .
Algemeen: n!=n∙(n-1)∙(n-2)∙⋯∙1
Dit kun je ook schrijven als: n!=n∙(n-1)!
Dus als je de functie fac(n) maakt voor n!, dan geldt: fac(n)=n*fac(n-1).
Stap 1
De functie krijgt de vorm:
Als n=1 dan is de uitkomst 1
Anders is de uitkomst n*fac(n-1)
Maak een Python programma waarin je deze functie definieert en bereken daarmee een aantal uitkomsten.
Een nadeel van deze functie is dat voor grote waarden van n het geheugen van de rekenmachine niet toereikend is. Zoek uit wat de grootste waarde van n is zodat de functie nog een uitkomst geeft.
Stap 2
Een andere benadering is een functie die gebruik maakt van een for-lus:
Start met het getal 1 en maak een for-lus waarbij elke keer de nieuwe uitkomst wordt vermenigvuldigd met de lus-variabele (i in dit geval).
Definieer deze functie als fac1(n) en ga na dat je hiermee bijvoorbeeld 500! kunt berekenen terwijl dat met de “gewone” faculteit-functie in TI-Nspire niet kan.
Stap 3
Als je wilt weten uit hoeveel cijfers het getal 500! bestaat kan dat in Python door eerst het getal naar een string om te zetten met str() en daarna de lengte van die string te berekenen (met len()).
Ga na dat 500! bestaat uit 1135 cijfers.
Oefenblad 3 : Lijsten
Teacher's NotesIn deze Unit gaan we wat dieper in op programmeren in Python. Lijsten in Python
Doelen :
- Lijsten maken
- Verschillende lijst-opdrachten gebruiken.
Een lijst wordt in Python genoteerd als een opsomming van elementen tussen rechte haken waarbij de elementen door een komma gescheiden worden.
Zo is bijvoorbeeld [7,3,5] een lijst met 3 elementen (in dit geval getallen).
Elementen kunnen ook van een ander type zijn bijvoorbeeld tekst of zelf weer een lijst.Stap 1
Open een nieuw Python programma en maak een lijst a met de getallen 1 t/m 10.
Elk element in de lijst heeft een rangnummer waarbij het eerste element nummer 0 heeft. Met a[3] krijg je het element met rangnummer 3.
Voeg een regel aan het programma toe waarbij je het derde element afdrukt en ga na dat dit element de waarde 4 heeft.Stap 2
Je kunt elementen toevoegen aan een rij met lijst.append().
Dit kun je vinden in Menu --> Built-ins --> Lists.
Als bijvoorbeeld a = [1,2,3], dan is a.append(5) de lijst a = [1,2,3,5]
We gaan dit gebruiken om een lijst van Fibonaccigetallen te maken.
De rij van Fibonacci is: 1, 1, 2, 3, 5, 8, 13, ... waarbij steeds het volgende getal de som is van de twee vorige getallen.Stap 3
Begin met de lijst fib = [1,1].
Dan moeten we de eerste keer toevoegen fib[0] + fib[1].
Er geldt dan: fib = [1,1,2]
De tweede keer voegen we fib[1] + fib[2] toe. Dit herhalen we steeds weer opnieuw.
Maak een programma dat de rij van de eerste 10 Fibonaccigetallen maakt en gebruik hiervoor een for-loop.
Een mogelijk programma staat hiernaast.
De loop wordt 8 keer doorlopen want we hoeven maar 8 getallen toe te voegen aan de lijst [1,1].
Stap 4
Op deze manier kun je makkelijk een lijst van 100 Fibonaccigetallen maken.
Ga na dat het programma hiernaast het 100-ste Fibonaccigetal afdrukt.
Stap 5
Een lijst kan ook bestaan uit elementen die zelf een lijst zijn.
Dit is een tweedimensionale lijst of matrix.
We maken nu zo’n lijst waarbij elk element een lijst met Fibonaccigetallen is te beginnen met [1,1].
Verander het vorige programma eerst zo dat de functie f(a) een lijst geeft met Fibonaccigetallen.
Ga na dat f(8) uit het programma hiernaast een lijst met 10 Fibonaccigetallen geeft.Stap 6
Definieer nu een lege lijst. (bijvoorbeeld L = [ ])
Maak dan een for-loop waarbij steeds de lijst f(i) wordt toegevoegd aan L.
Zie hiernaast.
L bestaat uit vier lijsten met Fibonaccigetallen.
Stap 7
De lijst L uit dit programma bestaat uit lijsten.
Als we die lijsten onder elkaar willen afdrukken dan kan dat met een for-lus.
We gebruiken hiervoor de optie for i in L. (dit kun je vinden in Menu --> Built-ins --> Control.
In deze lus doorloopt i alle elementen van de lijst L. (Dus i is steeds zelf een lijst)
Breid het programma uit met zo’n loop en druk alle lijsten uit L af.- Oefenblad 1
- Oefenblad 2
- Oefenblad 3
Unit 4 Het gebruik van de ti_draw module
Oefenblad 1 : Het grafiekenscherm
Teacher's NotesIn deze unit maken we kennis met de ti_draw module waarmee je grafische figuren kunt tekenen
Doelen :
- De ti_draw module verkennen.
- Het scherm configureren en vormen tekenen.
Stap 1
Voor het tekenen van grafische vormen in Python kun je de ti_draw module gebruiken.
In deze module vind je opdrachten voor het tekenen van punten, lijnen, cirkels, rechthoeken, enzovoorts.
Start een nieuw Python programma en kies voor het type: Geometry Graphics.
(Je kunt ook achteraf deze module nog laden met Menu > More Modules > TI Draw)
Stap 2
Als je het programma begint met het importeren van deze module heb je toegang tot alle functies die in het draw-menu te vinden zijn.
Telkens als je zo’n functie wilt gebruiken kun je met Menu > More Modules > TI Draw die functie vinden.
Standaard zijn de afmetingen van het tekenscherm 318 bij 212 pixels waarbij de coördinaten van de linkerbovenhoek (0,0) zijn.
Maak een programma dat een cirkel tekent met het middelpunt in het centrum van het scherm en waarvan de straal 100 is.
Hiernaast zie je hoe je de opdracht voor het tekenen van een cirkel kunt vinden in het menu.
De functie hiervoor is: draw_circle(159,106,100).Stap 3
Verander het programma zo dat er 10 cirkels getekend worden met hetzelfde middelpunt, maar waarvan de straal varieert van 10 tot 100.
In het voorbeeld hiernaast is er nog een extra opdracht toegevoegd. Deze opdracht stelt de tekenkleur in en je kunt hem vinden in het TI Draw menu bij Control.
Stap 4
Een van de opdrachten in het control-menu in de ti-draw module is: set_window().
Hiermee kun je de afmetingen en de oorsprong opnieuw instellen.
Hiernaast is een window gekozen zodat de oorsprong in het centrum van het scherm ligt. Belangrijk is wel dat de breedte anderhalf keer zo groot is als de hoogte om de verhoudingen te behouden.
Teken nu 20 cirkels met het middelpunt in het midden van het scherm en waarvan de straal varieert van 0 tot 20.
Stap 5
Als je dit programma uitvoert kost het tekenen enige tijd.
Dat komt omdat telkens weer de tekenmodule moet worden aangeroepen.
Er zit ook een opdracht bij waarmee we dit kunnen versnellen.
In het control-menu zit de opdracht use_buffer(). Deze opdracht zorgt ervoor dat de tekenopdrachten niet direct worden afgedrukt maar worden “gebufferd”.
Pas aan het einde van het programma, of wanneer je de opdracht paint_buffer() gebruikt, wordt de buffer in een keer getekend.
Hiernaast zijn deze opdrachten toegevoegd.
Stap 6
Maak een programma dat het plaatje van hiernaast op het scherm tekent.
Stap 7
Een mogelijk programma staat hiernaast.
Oefenblad 2 :Grafieken tekenen
Teacher's NotesIn deze unit maken we kennis met de ti_plotlib module waarmee je grafische voorstellingen kan maken
Doelen :
- De ti_plotlib module gebruiken.
- De grafiek van een functie tekenen.
Stap 1
Met de module ti_plotlib kun je met Python grafieken tekenen.
Start een nieuw Python programma. Kies nu bij New voor het type Plotting (x,y) & Text.
Je ziet dan dat de module ti_plotlib is ingevoegd, maar op een iets andere manier dan andere modules.
Import ti_plotlib as plt betekent dat je in het programma elke opdracht of functie uit deze module moet beginnen met plt.
Als je het menu gebruikt gebeurt dit automatisch.Stap 2
We beginnen met een rooster en een assenstelsel.
In het TI_PlotLib menu vind je onder setup de opdrachten plt.grid() en plt.axes().
Deze kun je gebruiken voor het tekenen van een rooster en een assenstelsel.
Zie hiernaast.
De volgorde is hierbij wel van belang. Kijk bijvoorbeeld wat er gebeurt als je de twee opdrachten plt.grid() en plt.axes() omwisselt.Stap 3
Verder is er in het voorbeeld ook nog een punt getekend. Je kunt de verschillende tekenopdrachten vinden in het TI_PlotLib menu onder Draw.
Stap 4
We gaan de functie f(x)=x2 – 4x plotten.
Begin met een nieuw Python programma en importeer de ti_plotlib module.
Definieer de functie f.
Stap 5
Het tekenen van een grafiek in Python gaat door een serie punten te plotten en die met lijnstukjes te verbinden.
De ti_plotlib module heeft hiervoor een opdracht, nl plt.plot(x-list,y-list,"mark"), waarbij x-list de lijst met x-coördinaten is, y-list de lijst met y-coördinaten en mark het punt-type.
We maken eerst een lijst met x-coördinaten (lx) en een lijst met de bijbehorende y-coördinaten (ly).
Voeg dan de opdrachten toe voor het maken van het rooster en het assenstelsel.
Stap 6
Doordat x in hele stappen gaat ziet de grafiek er hoekig uit. We veranderen het programma een klein beetje om dit te verbeteren. We nemen stappen van 0.5 in plaats van 1.
Als we nog kleinere stappen nemen kan het plotten lang duren. Neem bijvoorbeeld stapjes van 0.1. Dan kunnen we de lijst aanpassen zoals hiernaast. Hierin is ook nog de kleur van de grafiek aangepast.
Oefenblad 3 :Puntenwolken tekenen
Teacher's NotesIn deze les tekenen we een puntenwolk waarna we met lineaire regressie de best passende lijn erbij zoeken.
Doelen :
- Het tekenen van een puntenwolk.
- Lineaire regressie uitvoeren.
We bekijken het volgende probleem.
Na een overstroming in een gebied wordt elk uur de waterhoogte gemeten.
De resultaten staan in de volgende tabel:
t(uren) |
0 |
1 |
2 |
3 |
4 |
5 |
6 |
7 |
8 |
9 |
10 |
11 |
12 |
H(cm) |
130 |
127 |
123 |
118 |
116 |
111 |
105 |
103 |
101 |
95 |
86 |
80 |
71 |
Stap 1
We maken een programma dat een grafiek tekent van deze metingen en onderzoeken het verband tussen t en H.
Open een nieuw Python programma en voeg ti_plotlib module in.
Als eerste maken we twee lijsten met de gegevens uit de tabel.Stap 2
Voor de grafiek hebben we een geschikt assenstelsel nodig.
Met de opdracht plt.window() kun je de vensterinstellingen aanpassen.
De functie plt.scatter (t,H,”x”) tekent de puntenwolk.
Hierbij is t de lijst met de horizontale gegevens, H de lijst met de verticale en “x” het symbool voor de punten.
(De functie scatter() is te vinden in het ti_plotlib menu onder tabblad Draw).
Stap 3
De punten lijken redelijk op een lijn te liggen.
De beste rechte door de punten heet de regressie lijn.
We kunnen deze lijn tekenen met de opdracht plt.lin_reg(t,H,”center”).
Het woord “center” geeft aan dat de bijbehorende vergelijking gecentreerd op het scherm wordt weergegeven.
In het voorbeeld hiernaast zijn nog wat extra opdrachten toegevoegd om het plaatje nog wat aan te passen
Stap 4
Het tijdstip waarop de waterhoogte 0 is kun je nu berekenen met de vergelijking
De getallen -4.6 en 132.9 zijn afgerond op een decimaal.
De onafgeronde waarden van deze getallen zijn opgeslagen in de variabelen plt.m en plt.b die je kunt vinden in het ti_plotlib menu bij Properties.
- Oefenblad 1
- Oefenblad 2
- Oefenblad 3
Unit 5 Het gebruik van de ti_system module
Oefenblad 1 : Gegevens uitwisselen
Teacher's NotesIn deze les maken we kennis met de ti_system module waarmee data uitgewisseld kunnen worden tussen Python andere TI-Nspire toepassingen
Doelen :
- Variabelen van Python naar Nspire exporteren.
- Functiewaarden van Nspire naar Python importeren.
Stap 1
De ti_system module maakt het mogelijk gegevens uit te wisselen tussen Python en de andere toepassingen.
Je kunt variabelen, lijsten en functiewaarden uitwisselen.
Open een nieuw document en kies daarin voor een Calculator pagina (keuze 1).
Definieer een functie, bijvoorbeeld f(x) := x2.
(Let erop dat je bij de definitie van een functie in TI-Nspire het := teken moet gebruiken.)
Stap 2
Voeg een nieuwe pagina toe aan het document en kies nu voor een Python pagina van het type Data Sharing.
In deze Python editor moet de ti_system module geïmporteerd worden.
(Deze module staat ook in het menu bij Menu --> More Modules --> TI System en dan keuze 1.)
In het ti_system menu (bij More Modules) staat o.a. de functie eval_function().
Bij deze functie moet je twee waarden invullen. De eerste is de naam van de functie die je in de calculator pagina gekozen hebt (in ons geval “f”) en de tweede is de waarde die je wilt invullen in de functie.
Ga na dat het programma de uitkomst 25 geeft.
Stap 3
Dit kunnen we ook gebruiken voor functies die Python niet kent, maar TI-Nspire wel.
We bekijken twee van dergelijke functies.
De eerste is de ggd van twee getallen berekenen. (ggd is grootste gemene deler)
De tweede is de controle of een getal een priemgetal is.
Stap 4
Ga terug naar de calculator pagina (dat kan bijvoorbeeld met ctrl-pijl naar links).
Definieer de functie g(x):=gcd(x,y).
Stap 5
Ga weer naar de Python pagina en definieer nu de functie ggd(a,b).
In het voorbeeld hiernaast begint de functie met store_value(“y”,b).
Dit is omdat de eval_function() in Python alleen geldt voor functies van één variabele. De andere waarde (y in ons geval) moet ook bekend zijn en dat kan met store_value().
Deze functie staat in het ti_system menu.
Ga na dat je op deze manier de ggd van twee getallen in Python kunt berekenen.
Stap 6
In het volgende voorbeeld gebruiken we de isprime() functie van TI-Nspire.
Deze functie geeft de uitkomst true voor een priemgetal en false als het geen priemgetal is.
De eval_function() in Python werkt alleen als de functie uitkomst een getal is.
Stap 7
In Python ziet de functie er dan uit zoals hiernaast.
Oefenblad 2 :Gegevens uitwisselen
Teacher's NotesIn deze les gaan we verder met de ti_system module. We kijken naar het gebruik van het toetsenbord.
Doelen :
- Detecteren welke toets is ingedrukt.
Stap 1
In de ti_system module staan functies die het toetsenbord en de muis kunnen aflezen.
We maken een programma waarmee je m.b.v. de pijl-toetsen een stip over het scherm kunt bewegen.
Start een nieuw Python programma en importeer de ti_system module en de ti_draw module. (Beide staan in het menu bij More Modules.)
Stap 2
We starten met een rode stip in het midden van het scherm.
Het scherm is 318 pixels breed en 212 pixels hoog met de oorsprong in de linkerbovenhoek.
De coördinaten van het midden zijn dan (159,106).Stap 3
De functie get_key() uit het ti_system menu gaat na of er een toets is in gedrukt en zo ja dan is de uitkomst de naam van de toets die is ingedrukt (dus een string).
We starten met een lege string toets = ””.
Vervolgens maken we een while-lus die elke keer nagaat of er een toets is ingedrukt.
Als de escape-toets is ingedrukt stopt de lus.Stap 4
In de lus controleren we elke keer of één van de pijl-toetsen is ingedrukt.
Zo ja dan geven we aan wat er moet gebeuren.Stap 5
Het programma heeft nog een paar nadelen.
De stippen blijven staan en ze kunnen buiten het scherm vallen.
Om ervoor te zorgen dat de stippen niet buiten het scherm vallen mogen de coördinaten niet te groot of te klein worden.
Je kunt dit voor elkaar krijgen met de functies min() en max().
min(x,y) geeft als uitkomst de kleinste waarde van de twee.
Stap 6
Als we alleen de nieuwe stip willen zien moet het scherm telkens gewist worden voordat de nieuwe stip getekend wordt.
Stap 7
De stip flikkert de hele tijd omdat het scherm ook gewist wordt als er geen toets is ingedrukt.
Je kunt dit voorkomen door in de get_key() functie een getal in te vullen (meestal kiezen we daarvoor 1)
Dit zorgt ervoor dat het programma wacht totdat er een toets is ingedrukt.
Oefenblad 3 :Werken met afbeeldingen
Teacher's NotesIn deze les maken we kennis met de ti_image module waarmee afbeeldingen kunnen worden bewerkt.
Doelen :
- Importeren van afbeeldingen.
- Bewerken van afbeeldingen.
Stap 1
De ti_image module maakt het mogelijk afbeeldingen te bewerken.
(Je hebt de software nodig om een afbeelding in je document te importeren)
Hiernaast staat een afbeelding van Mickey Mouse.
We maken een programma waarmee we deze afbeelding veranderen in een afbeelding met alleen grijstinten.
Stap 2
Open een nieuw Python programma en importeer de ti_image module.
(Dat kan bijvoorbeeld door het type “Image Processing” te kiezen)Stap 3
Om in Python een afbeelding te bewerken moet deze afbeelding in een Notes- pagina staan.
Voeg in het huidige document een Notes-pagina toe.Stap 4
Stap 5
Als de afbeelding in de Notes pagina staat, moet je deze een naam geven.
Ga met de cursor op de afbeelding staan en gebruik Ctrl_menu (of Ctrl-muisklik) om een pop-up menu te krijgen. Kies dan 5:Name Image en geef de afbeelding een naam (bijvoorbeeld mickey)Stap 6
Ga terug naar de Python pagina om het programma te schrijven.
Hiernaast zie hoe je de afbeelding in Python kunt krijgen.
(De opdracht load_image() kun je vinden in Menu --> More Modules --> TI Image --> load_image()).
We noemen de variabele waarin we de afbeelding opslaan in dit voorbeeld “plaatje”.Stap 7
Als je nu de variabele-naam van de afbeelding intypt gevolgd door een punt krijg je een menu in beeld waarin een aantal keuzes staan.
Een ervan is show_image()
Stap 8
(30,0) betekent: 30 pixels vanaf links en 0 pixels omlaag en is de positie van de linkerbovenhoek van de afbeelding.
Als je nu het programma uitvoert wordt de afbeelding afgedrukt.
Om de afbeelding te bewerken hebben we de afmetingen (in pixels) nodig.
Stap 9
We maken nu twee lussen die samen alle pixels doorlopen en rekenen voor elke pixel de grijswaardes uit waarna we die nieuwe waardes weer in de afbeelding “terugzetten”.
Met de opdracht get_pixel(i,j) krijg je van pixel i,j de kleuren (r,g,b).
Dit is een tuple (een soort lijst) die bestaat uit drie elementen.
Voor elke pixel rekenen we het gemiddelde van deze drie getallen uit en geven elke kleur deze waarde. (Drie gelijke kleurwaarden geven een grijstint)
- Oefenblad 1
- Oefenblad 2
- Oefenblad 3
Unit 6 Het gebruik van de ti_hub module
Oefenblad 1 : Built-in devices en de hub
Teacher's NotesIn deze les gebruiken we de TI-Innovator Hub in een Python programma.
Doelen :
- Het verkennen van de ti_hub module.
- Het toepassen van enkele basisvaardigheden.
In de ti_hub module vind je de opdrachten om vanuit Python met de TI-Innovator Hub te communiceren.
We gaan een programma maken dat de gekleurde led in de hub laat branden en dat de ingebouwde luidspreker gebruikt.
Sluit de hub aan op de rekenmachine of op de computer.
Stap 1
Open een nieuw Python programma en kies voor “Blank Program”.
Om de Innovator Hub te kunnen gebruiken heb je de Hub module nodig.
Kies uit het menu TI Hub en dan optie 1: from ti_hub import *.
Je hebt dan de beschikking over alle hub-functies.Stap 2
In het TI Hub menu staat bij Hub Built-in Devices de Color Output.
Kies hierin voor rgb() om een kleur te kiezen, en daarna in hetzelfde menu voor blink om het lampje te laten knipperen.Stap 3
Stap 4
We gaan ook geluid toevoegen.
Ga weer naar het ti_hub menu en daarin weer de Built-in devices en kies nu voor Sound Output.
Kies hieruit tone(freq, time).
Stap 5
Pas het programma aan door de toonhoogte te variëren.
Maak een loop die de frequentie laat lopen van 400 tot 2000 Hz met stappen van 100 Hz waarbij elke toon 0.2 seconde duurt.
Stap 6
Als je dit programma uitvoert merk je dat niet elke toon 0.2 seconde duurt.
Belangrijk is dat de tijd tussen twee opeenvolgende tonen ook minstens 0.2 seconde is.
Je kunt hiervoor de opdracht sleep() gebruiken.
Oefenblad 2 :Werken met een externe sensor
Teacher's NotesIn deze les lezen we een externe sensor af met de TI-Innovator Hub in een Python programma.
Doelen :
- Het aansluiten van een externe sensor.
- Het gebruik van de Ranger.
Naast de ingebouwde apparaten kun je ook externe input- en output apparaten aansluiten aan de hub.
We gaan een programma maken dat m.b.v. een afstandssensor (Ranger) de afstand tot een voorwerp meet.
Ook moet het programma een geluid geven waarvan de toonhoogte afhangt van de gemeten afstand.
Sluit de Ranger aan in poort IN1. (deze poort zit aan een van de zijkanten van de hub) en sluit de hub aan op de rekenmachine of de computer.
Stap 1
Open een nieuw Python programma en importeer de Hub-module.
Om de Ranger te kunnen gebruiken moeten we aangeven in welke poort hij zit aangesloten en we moeten hem nog een naam geven.
Kies uit het TI Hub-menu: Add Input Device, en kies dan voor Ranger.
Op het scherm verschijnt var=ranger(“port”).
De cursor staat nu op de plek waar je de naam kan intypen.
Typ een naam in (bijvoorbeeld rg) en geef aan in welke poort de Ranger is aangesloten (IN1 in dit geval).
Stap 2
Het aflezen van de Ranger gaat met de opdracht rg.measurement().
Je kunt dit makkelijk invoeren door de variabele-naam (rg) in te typen direct gevolgd door een punt.
Als je de gemeten waarde wilt gebruiken dan kun je die opslaan in een variabele (bijvoorbeeld a).
Stap 3
Als je het programma van hiernaast uitvoert dan wordt de gemeten afstand afgedrukt.
De gemeten afstand is in meters.
Stap 4
Pas nu het programma aan zodat het voortdurend de afstand blijft meten en afhankelijk van de uitkomst een toon laat horen (zoals een parkeersensor werkt)
Gebruik hiervoor de while lus.
Neem de volgende voorwaarden:
Als de afstand groter is dan 0.4 m dan moet de frequentie 1000Hz zijn.
Tussen 0.2 m en 0.4 m is de frequentie 800Hz.
Tussen 0.05 m en 0.2 m is de frequentie 400Hz.
Als de afstand kleiner is dan 0.05 m (5 cm) dan moet het programma stoppen.
Stap 5
Een mogelijk programma staat hiernaast.
Oefenblad 3 : Werken met de Rover
Teacher's NotesIn deze les maken we een programma waarbij we de Rover laten rijden
Doelen :
- De Rover programmeren.
- De afstandssensor van de Rover gebruiken.
Om de Rover te kunnen programmeren heb je de ti_rover module nodig.
Hierin staan alle opdrachten die betrekking hebben op de Rover.
Stap 1
Open een nieuw Python programma en importeer de module ti_rover.
In de afbeelding hiernaast zie je staan: import ti_rover as rv.
Dit betekent dat elke Rover-opdracht moet beginnen met rv.
Dit gaat automatisch als je de opdrachten uit het menu haalt.Stap 2
Eerst maken we een programma dat de Rover een vierkant laat tekenen met een zijde van 50 cm.
De eenheid van afstand is decimeters.Stap 3
We gaan nu een programma maken dat de Rover laat rijden totdat de afstand tot een object (bijvoorbeeld een muur) kleiner is dan 10 centimeter.
Tijdens het rijden moet het lampje op de Rover groen branden.
Als de Rover stopt moet het lampje twee seconden lang rood branden.Stap 4
Importeer de time-module.
De time-module vind je in het menu bij More Modules.
Begin met het aanzetten van het lampje.
De opdracht rv.color_rgb() kun je vinden in het TI Rover menu bij outputs.
Geef dan de opdracht om de afstand aan de voorkant van de Rover te meten en sla de waarde op in variabele a.
De opdracht om de Ranger van de Rover te meten staat in het menu bij TI Rover 3:Inputs.Stap 5
Nu moet de Rover gaan rijden totdat de afstand tot een voorwerp minder dan 10 cm is.
Een manier om dit te doen is als volgt:
Geef de Rover de opdracht om een grote afstand te gaan rijden (bijvoorbeeld 10 meter).
Meet, terwijl de Rover rijdt, telkens de afstand.
Op het moment dat deze afstand kleiner is dan 0.1 meter geef je de opdracht om te stoppen.
Dit kan met een while lus: zolang de afstand groter is dan 0.1, meet dan opnieuw.
- Oefenblad 1
- Oefenblad 2
- Oefenblad 3
Unit 7: micro:bit met Python
Oefenblad 1: Het Display
Teacher's NotesIn deze les maak je je eerste Python-programma’s voor het op verschillende manieren aansturen van het ‘micro:bit’-display.
- Deel 1: alien encounter
- Deel 2: plaatjes weergeven
Doelen:
- Het display van de micro:bit gebruiken met de opdrachten .show(), .scroll() en .show(image);
- De display snelheid instellen met sleep(ms).
Stap 1
Controleer voordat je begint het volgende:
- De TI-Nspire CX II heeft OS 5.3 of hoger.
- Je beheerst de beginselen van het programmeren in Python.
- De micro:bit is verbonden met de TI-Nspire CX II.
- Je hebt de instructies gevolgd voor het instellen van de micro:bit, zie: https://education.ti.com/en/teachers/microbit
Deze procedure hoeft maar één keer gevolgd te worden, maar zorg dat je op de hoogte blijft van eventuele updates.
Stap 2
Als alles goed is gegaan ziet je micro:bit er zo uit, nadat je hem hebt aangesloten op je TI-Nspire:
Op het display van de micro:bit zie je het TI-logo: de staat Texas met een heldere stip op de plek van Dallas.
Stap 3
Tot slot:
De micro:bit staat in de Python-bibliotheek en kun je als volgt vinden:
Druk in de Python-editor op [menu] >More Modules. Je ziet dat de ‘BBC Micro:bit’-module hieraan is toegevoegd.
Merk op dat in OS 5.3 en hoger Python-modules die in de Pylib- map zijn opgeslagen, in het menu worden toegevoegd aan de TI-modules.
Stap 4
Deel 1: Alien encounter
Zoals gebruikelijk bij een eerste programma begin je met een bericht op het ‘micro:bit’-display.
Begin met een nieuw ‘TI-Nspire’-document en kies voor Add Python>New om een nieuw programma te starten en noem het bijvoorbeeld: ‘greetings’.
Typ nu in de Python-editor [menu]>More Modules>BBC Micro:bit om de module te importeren:
from microbit import *
Tip: Als de mededeling ‘micro:bit not connected’ verschijnt, koppel dan de micro:bit los en sluit hem opnieuw aan.
Stap 5
Om een tekst op het display van de micro:bit te tonen, gebruik je de opdracht
display.show(image or text)
Je kunt deze opdracht vinden met:
[menu] > More Modules > BBC micro:bit > Display > Methods
De opdracht wordt ingevoegd als display.show(Value) waarbij ‘value’ vervangen kan worden door bijvoorbeeld tekst. Typ hier tussen aanhalingstekens: “greetings, earthlings”
Als je dit programma uitvoert (bijvoorbeeld met [ctrl] [R] zie je de letters één voor één verschijnen op het display.
Stap 6
Een betere manier om tekst weer te geven is:
display.scroll(“greetings, earthlings”)
Ook deze opdracht kun je vinden bij:
[menu] > More Modules > BBC micro:bit > Display > Methods
Voorzie de eerste opdracht van een commentaarsymbool om deze te negeren.
Je kunt natuurlijk ook gewoon ‘show’ vervangen door ‘scroll’ met het toetsenbord.
Stap 7
Display.scroll(“greetings, earthlings”, delay = 200)
Deze opdracht vertraagt het scrollen met 200 milliseconden (ofwel 0.2 seconden). Probeer ook andere waarden.
Stap 8
Deel 2: Hartslag
Open een nieuw document en kies Add Python>New om een nieuw programma te starten. Noem het bijvoorbeeld ‘hartslag’. Begin weer met het importeren van de ‘micro:bit’-module:
from microbit import *
Stap 9
Om een hartsymbool op het ‘micro:bit’-display weer te geven gebruik je de opdracht display.show()
Je kunt deze vinden bij:
[menu]>More Modules>BBC Micro:bit>Display>Methods
Tussen de haakjes vul je dan in Image.HEART.
Je kunt dit intypen, maar je kunt het ook in het menu vinden:
[menu]>More Modules>BBC Micro:bit>Display>Images>Set 1>HEART
Stap 10
Voer het programma uit ([ctrl] [R]), dan zie je een hartvorm op het ‘micro:bit’-display verschijnen. Het hartsymbool blijft op het display staan, totdat er weer een andere opdracht gegeven wordt. Ook als het programma gestopt is.
Stap 11
Ga terug naar de Python-editor en voeg de opdracht toe om het kleine hartsymbool weer te geven:
display.show(Image.HEART_SMALL)
Je kunt dit symbool vinden bij:
menu]>More Modules>BBC Micro:bit>Display>Images>Set 1
Maar je kunt ook de vorige regel kopiëren en plakken en dan _SMALL toevoegen (let er dan wel op dat je hoofdletters gebruikt).
Stap 12
Voer het programma uit. Dan zie je eerst het grote hart en dan direct daarna het kleine. .
Stap 13
We maken nu een lus (loop) om het hart te laten “kloppen”.
Voeg vóór de twee opdrachten de volgende opdracht toe:
while get_key() != “esc”:
deze kun je vinden met:
[menu]>More Modules>BBC micro:bit>Commands
Zorg ervoor dat de twee display-opdrachten beide inspringen (dit betekent dat beide opdrachten in een lus worden uitgevoerd).
Stap 14
Voer het programma weer uit, het hart klopt nu.
Je kunt het programma onderbreken met de escape-toets.
Tip: Mocht het zo zijn dat je programma in een oneindige lus zit dan kun je met de [home/on] -toets het programma toch stoppen.
Stap 15
In het ‘micro:bit’- Commands -menu kun je enkele nuttige Python- opdrachten vinden.
Enkele van deze opdrachten staan ook in de menu’s van andere modules.
Stap 16
Om de snelheid van de hartslag te veranderen kun je twee keer de opdracht sleep() toevoegen. Achter elke display-opdracht één sleep(1000) betekent een wachttijd van 1000 milliseconden ofwel 1 seconde.
De opdracht kun je vinden in:
[menu]>More Modules>BBC micro:bit>Commands
Tip: Let ook hier weer op het inspringen.
Stap 17
Extra: Probeer ook eens verschillende gezichten uit. Gebruik dezelfde structuur als het hartslagprogramma maar gebruik nu verschillende gezichtsuitdrukkingen uit Set 1.
Oefenblad 2: Knoppen en beweging
Download Teacher/Student DocsIn deze les leer je de knoppen en de bewegingsmogelijkheden van de micro:bit te gebruiken. Je maakt een programma dat het werpen met een dobbelsteen simuleert en de uitkomsten in een lijst opslaat die je naar dataplot van TI-Nspire exporteert.
Deze les bestaat uit twee delen:
- Deel 1: De werking van de knoppen en het effect van bewegen onderzoeken;
- Deel 2: Beweging en knoppen gebruiken voor het genereren van data.
Doelen :
- Bepalen of knop A of B is ingedrukt;
- Het verschil tussen .was en .is;
- Data uitwisselen tussen Python en TI-Nspire;
- Data vanuit de micro:bit beheren;
- Bewegingen van de micro:bit gebruiken.
Step 1
De micro:bit beschikt over twee knoppen, gelabeld A en B, aan weerszijden van het display. De Python-‘micro:bit’-module kent twee gelijksoortige methodes om de knoppen af te lezen en om daarna taken uit te voeren, afhankelijk van de uitkomst. Eerst test je deze methodes en dan schrijf je een Python-programma waarmee je data verzamelt en analyseert met de TI-Nspire.
Er zit ook een accelerometer/compas-chip op de achterkant van de micro:bit en er zijn methodes (opdrachten) waarmee beweging en oriëntatie van de micro:bit kan worden gemeten.
Step 2
Deel 1: Knoppen en bewegingen onderzoeken
Begin een nieuw Python-programma in een nieuw document. (Druk op de [Home] toets, kies New en dan Add Python>New). Geef het een naam bijvoorbeeld “knoppen”. Start weer met from microbit import *, deze kun je vinden in [menu]>More Modules>BBC micro:bit.
Step 3
Voeg de while-lus (loop) toe
([menu] > More Modules > BBC micro:bit > Commands).
Vrijwel alle voorbeelden met de micro:bit hebben deze structuur.
Step 4
Om knop A te testen gebruiken we de if-structuur:
◆◆if button_a.was_pressed():
◆◆◆◆print("Button A")
De if-opdracht is onderdeel van de while-opdracht en moet dus inspringen. De print opdracht springt extra in, omdat deze bij de if-opdracht hoort.
If kun je vinden bij [menu]>Built-ins>Control.
button_a_was_pressed() vind je bij:
[menu]>More Modules>BBC micro:bit>Buttons and Logo Touch.
Step 5
Je kunt nu het programma testen.
Druk op [ctrl] [R] om het programma uit te voeren.
Het lijkt alsof er niets gebeurt. Maar elke keer als je knop A indrukt verschijnt “Knop A” op het scherm.
Druk op [esc] om het programma te stoppen.
Step 6
Voeg nu een tweede if-opdracht toe voor knop B, maar gebruik nu de opdracht: if button_b.is_pressed()
Merk op dat er nu “.IS” staat in plaats van “.WAS”.
Let ook nu weer op de juiste inspringingen.
Step 7
Voer het programma weer uit en druk op de verschillende knoppen A en B.
Het verschil is dat “Knop A” pas wordt getoond als de knop weer wordt losgelaten, terwijl “Knop B” steeds opnieuw wordt getoond, zolang deze ingedrukt blijft.
Merk op dat als je knop B indrukt en snel weer loslaat het mogelijk is dat er geen actie volgt, omdat op het moment dat de if-opdracht wordt uitgevoerd de knop niet is ingedrukt.
Step 8
Bewegingsdetectie (gestures)
De micro:bit heeft een ingebouwde accelerometer (versnellingssensor) die in drie verschillende richtingen versnellingen kan meten (3D-accelerometer).
Naast numerieke waarden voor de versnelling in elke richting (zie afbeelding hiernaast) kent de micro:bit ook duidelijke ‘gestures’ zoals “face up” en “face down” gebaseerd op deze numerieke waarden.
We gaan dit onderzoeken met ons programma.
Step 9
De opdracht g = accelerometer.current_gesture() slaat de ‘waarde’ op in de variabele g.
(Je kunt deze opdracht vinden met:
[menu]>More Modules>BBC micro:bit>Sensors>Gestures)
Print(g) toont deze op het scherm.
Let op dat je het juiste aantal spaties gebruikt. De laatste twee regels horen bij de while-opdracht en niet bij de if-opdracht.
Step 10
Voer het programma uit en kijk naar de verschillende meldingen op het rekenmachinescherm als je de micro:bit schudt, omdraait, rechtop zet, enz.
Sommige beschikbare ‘gestures’ zijn: face up, face down, up, down, left, right, shake.
Step 11
Voorzie de laatste twee regels in je programma van het commentaarsymbool (#) (dit wil zeggen dat het programma deze regels tijdens het uitvoeren negeert) en voeg de volgende twee regels toe:
if accelerometer.was_gesture(“face down”):
◆◆print(“face down”)
Je vindt alle ‘gesture’-opties en functies in:
menu]>More Modules>BBC micro:bit>Sensors>Gestures.
Tip: Om een programmaregel als commentaarregel te markeren kun je [ctrl] [T] gebruiken.
Als je dit laatste programma uitvoert merk je een verschil met de vorige versie;
.current_gesture() toont continu de melding.
.was_gesture() toont deze alleen als er iets wijzigt.
Step 12
Knoppen en ‘gestures’ bieden beide de mogelijkheid om input van de micro:bit te krijgen.
In het volgende deel verzamelen we data met behulp van de micro:bit en verwerken we deze met de TI-Nspire.
Step 13
Deel 2: Werpen met een dobbelsteen
Als knop A is ingedrukt geef dan een variabele, een willekeurig heel getal van 1 t/m 6. Dit simuleert de dobbelsteen (in plaats van knop A kun je ook knop B gebruiken of één van de ‘gestures’).
Laat het getal op het display van de micro:bit zien.
Voordat je verdergaat, kun je eerst zelf proberen om het programma te schrijven.
Step 14
Begin me een nieuw Python-programma en voeg weer de ‘micro:bit’-module toe.
Om een willekeurig (random) getal te kunnen kiezen hebben we een functie nodig uit de random-module. Deze voegen we ook toe (zie de tweede regel in het programma).
Het programma lijkt op het vorige met ook weer de while-structuur.
De regel uitkomst = randint(1,6) geeft elke keer als knop A is ingedrukt de variabele ‘uitkomst’ een willekeurige waarde (1 tot 6).
Step 15
Voeg nu ook de opdracht toe om deze waarde op het display van de micro:bit weer te geven.
Dat kan met display.show(uitkomst)
Voer het programma uit en elke keer als je knop A indrukt zie je de gekozen waarde op het display van de micro:bit verschijnen.
Step 16
Data verzamelen
Het werpen met een dobbelsteen door op een knop te drukken is leuk, maar we willen de uitkomsten opslaan om er conclusies uit te kunnen trekken.
Step 17
Begin met een lege lijst waarin de uitkomsten worden opgeslagen, in dit programma heet die lijst: uitkomsten.
Elke keer als knop A wordt ingedrukt moet de uitslag worden toegevoegd aan de lijst. Dat kan met uitkomsten.append().
Dit kun je vinden met: [menu]>Built-ins>List.
Aan het eind van het programma worden de elementen van de lijst opgeslagen in een ‘TI-Nspire’-lijst met de opdracht:
store_list(“ogen”,uitkomsten)
Deze functie kun je vinden met:
[menu]>BBC micro:bit>Commands.
Step 18
Voer het programma uit en druk een groot aantal keren op knop A. Druk dan op [esc] om het programma weer te stoppen. Het Python-programma bevat nu een lijst “uitkomsten” met alle uitkomsten en TI-Nspire heeft nu ook een lijst met dezelfde uitkomsten, deze heet “ogen”. Druk op [ctrl]-[doc] (of [ctrl]-[i]) om een nieuwe pagina aan het document toe te voegen en kies dan voor Data & Statistics. Je ziet een scherm met een groot aantal punten. Door onderaan het scherm te klikken en de variabele “ogen” te kiezen, verschijnt een figuur zoals hiernaast.
In het menu van deze toepassing kun je het plottype veranderen en bijvoorbeeld voor een histogram kiezen.
Step 19
Uitbreiding:
Verander het programma zo dat elke keer als knop A wordt ingedrukt de uitkomstenlijst wordt opgeslagen en de uitkomst zelf wordt getoond.
Combineer de toepassingsschermen door in de Python-shell op [ctrl]-[4] te drukken.
Als je nu het programma weer uitvoert zie je dat de uitkomsten in het linkerdeel, en het histogram in het rechterdeel van het scherm steeds worden aangepast.
Oefenblad 3: Lichtsensor
Download Teacher/Student DocsIn deze les meet je de lichtsterkte met de lichtsensor en sla je de data op in een ‘TI-Nspire’-lijst voor verdere analyse.
Doelen :
- De lichtsensor aflezen;
- De lichtsterkte op het display weergeven;
- De data uitwisselen tussen Python en TI-Nspire;
- De data analyseren.
Step 1
De micro:bit kan de intensiteit van het omgevingslicht meten met behulp van de display-LEDs.
Deze LEDs kunnen dus ook als input-device gebruikt worden
Step 2
Begin een nieuw Python-programma in een nieuw document.
(Druk op de [Home] toets, kies New en dan Add Python>New).
Geef het een naam bijvoorbeeld “lichtsterkte”.
from microbit import *
while get_key() != "esc":
licht = display.read_light_level()
print("Lichtsterkte =",licht)
De opdracht display.read_light_level() kun je vinden met:
[menu]>More Modules>BBC micro:bit>Sensors
Step 3
Voer het programma uit en richt het ‘micro:bit’-display naar een lichtbron. Je ziet dan de lichtsterkte op je rekenmachinescherm.
Als je bijvoorbeeld je hand op het display legt, zie de waarde afnemen.
Druk op [esc] om het programma te stoppen.
Step 4
Maak twee lege lijsten vóór de while-opdracht:
tijd = [ ]
helderheid = [ ]
en neem t als variabele voor de tijd:
t = 0
In de eerste lijst toon je de tijden waarop gemeten is.
In de tweede lijst toon je de gemeten waarden.
Step 5
Voeg in de while-lus (loop) een opdracht die t met 1 verhoogt.
Voeg ook twee opdrachten toe om de waarden van t en van de lichtsterkte in de lijsten te stoppen:
t = t+1
tijd.append(t)
helderheid.append(licht)
.append kun je vinden bij [menu]>Built-ins>Lists.
Step 6
We gaan elke seconde een meting uitvoeren. Dat kan door een wachtopdracht toe te voegen aan het eind van de while-lus:
sleep(1000)
voor een wachttijd van 1000 milliseconden.
Je kunt deze opdracht vinden met:
[menu]>BBC micro:bit>Commands.
Step 7
Als we de metingen stoppen slaan we de Python-lijsten op in twee ‘TI-Nspire’-lijsten met dezelfde naam.
Je kunt hiervoor de opdracht store_list() gebruiken.
Let er wel op dat deze twee opdrachten niet inspringen want ze hoeven niet elke keer te worden uitgevoerd. Pas als de while-lus verlaten wordt moeten de lijsten worden opgeslagen.
store_list() kun je vinden met:
[menu]>BBC micro:bit>Commands.
Step 8
Voer het programma uit en begin met de micro:bit dichtbij een lichtbron. Beweeg dan de micro:bit langzaam steeds verder weg van de lichtbron.
Tip: De lamp van een smartphone werkt prima als lichtbron.
Step 9
Als je genoeg metingen hebt, druk je op [esc] om het programma te stoppen.
Voeg dan een extra pagina toe aan je document met [ctrl]-[doc] en kies voor Data & Statistics.
Je ziet dan een scherm dat lijkt op dat van hiernaast.
Step 10
Klik onderaan het scherm om een variabele te kiezen en selecteer “tijd” als onafhankelijke variabele.
Klik ook aan de linkerkant van het scherm en kies hier voor “helderheid” als afhankelijke variabele.
De punten vormen dan een grafiek die lijkt op die van hiernaast.
Tip: Als je het experiment nog een keer uitvoert, kun je in het ‘Data & Statistics’-scherm met [menu]>Window/Zoom>Zoom Data de grafiek weer passend in beeld krijgen.
Toepassing: Dobbelen
Download Teacher/Student DocsIn deze toepassing schrijf je een programma waarmee je data verzamelt met behulp van de micro:bit. Daarna voer je het programma uit in een gedeeld scherm, zodat je de grafiek ziet “groeien” tijdens het verzamelen van de data.
Doelen :
- Het schrijven van een programma;
- Het maken van een dynamische grafiek met de ‘Data & Statistics’-pagina.
Step 1
In deze toepassing gebruik je de technieken uit de drie lessen van deze unit:
Data verzamelen met de micro:bit waarbij je ‘gestures’ of knoppen gebruikt, en het gebruik van lijsten om de data op te slaan en uit te wisselen met TI-Nspire.
Daarna maak je een ‘TI-Nspire’-pagina waarin:
- aan de ene kant het Python-programma word uitgevoerd;
- aan de andere kant de grafiek (puntenplot of histogram) wordt getoond terwijl het programma loopt.
Step 2
Begin je programma met het importeren van de ‘micro:bit’-module en ook de random-module.
Definieer daarna een lege lijst (“ogen”) en sla deze direct op als ‘TI-Nspire’-lijst zodat ook deze lijst leeg is als het programma wordt gestart.
Laat het programma dan de instructie voor de gebruiker tonen. In dit geval gebruiken we de optie om de micro:bit te schudden voor het werpen met de dobbelstenen.
Step 3
Het programma moet elke keer als er “geworpen” wordt het volgende doen:
- Kies twee willekeurige getallen (van 1 tot 6).
- Tel deze op.
- Voeg de uitkomst toe aan de lijst “ogen”.
- Toon het aantal worpen, de twee getallen en hun som op het scherm.
- Laat de twee getallen ook op het display zien.
- Pas de ‘TI-Nspire‘-lijst aan.
Tip: Het aantal worpen is gelijk aan de lengte van de lijst “ogen”: len(ogen)
Step 5
Tel de uitkomsten op en voeg deze som toe aan de lijst “ogen”.
Step 6
Laat de twee uitkomsten zien op het ‘micro:bit’-display.
display.clear() wordt gebruikt om de vorige uitkomst van het display te wissen, zodat het duidelijk is dat er weer een nieuwe waarde wordt getoond.
Step 7
Voeg regels toe om de informatie op het ‘TI-Nspire’-scherm te tonen en om de ‘TI-Nspire’-lijst te updaten.
Step 8
Als het Python-programma goed werkt, ga je verder met de link naar de ‘TI-Nspire’-plotmogelijkheden. Voer eerst het programma uit en werp ongeveer 50 keer met de dobbelstenen. Druk op [esc] om het programma te stoppen.
Zorg dat je in de Python-shell zit (de pagina met de >>> - cursor) en druk dan op [ctrl]-[doc] of [ctrl]-[i] om een pagina toe te voegen en kies voor Data & Statistics. Dan zie je een scherm zoals hiernaast.
Step 9
Klik op “Click to add variable” onderin het scherm en selecteer “ogen”. Je ziet dan een puntenplot van de data verschijnen.
Step 10
Ga een pagina terug naar de Python-shell met [ctrl]-[pijl naar links] en druk op [ctrl]-[4] om de twee pagina’s samen te voegen tot één gedeelde pagina. Links de Python-shell en rechts de ‘Data & Statistics’- toepassing.
Step 11
Ga weer naar de Python-editor en start het programma met [ctrl]-[R].
Je komt dan terug in het gedeelde scherm en als je de micro:bit heen en weer schudt dan zie je de grafiek ontstaan.
Je kunt ook het programma starten vanuit de Python-shell (het linkerdeel van het scherm) om opnieuw te starten.
- Oefenblad 1
- Oefenblad 2
- Oefenblad 3
- Toepassing