4a: Python Turtle

4a: Python Turtle

Inleiding

In deze cursus ga je leren programmeren. Wij zullen hiervoor Python Turtle gebruiken. Python is een zeer veel gebruikte programmeertaal met een eenvoudige synthax. Daarnaast zijn voor Python zeer veel uitbreidingspakketten beschikbaar. Wij zullen uitbreidingspakket Turtle gaan gebruiken bij deze cursus.

Met Python Turtle kan je tekeningen maken door programma te schrijven (algoritme). Wanneer je het programma uitvoert, zal een de schildpadje jou code stap voor stap volgen en daarmee een tekening maken.

Bij het schrijven van het programma heb je commando's nodig. We gaat een flinke lijst met commando's gebruiken om onze schildpad de juiste kant op te sturen. Het is niet nodig om deze commando's uit je hoofd te leren. Deze mag je altijd opzoeken, zelfs op je toets.

Soms kan je door slim te programmeren in een paar regels code hetzelfde bereiken als pagina's vol code. Korte en efficiënte code heeft altijd de voorkeur. In deze cursus zullen dit leren gebruiken.

A Algoritmen

Wat is een algoritme?

Een algoritme is een recept om wiskundige of informaticaproblemen op te lossen dat bestaat uit een eindige reeks eenduidig gedefinieerde instructies. Een algoritme staat los van een computer programa. Een recept voor een appeltaart of een bouwplan voor een kast zijn ook algoritme.

Kort samengevat een algoritme is een exactie beschrijving wat je moet doen om een doel te bereiken.

Algoritmen bestaat meestal uit stappen (sequenties) die zich kunnen herhalen (iteratie) of beslissingen die vereist zijn om de taak op te lossen.

Eenzelfde taak kan gewoonlijk op verschillende manieren worden opgelost. Het verschil ligt dan meestal in de hoeveelheid tijd, ruimte of inspanning die het algoritme vergt; dit kan een indicatie zijn voor de complexiteit of de efficiëntie van het algoritme. Bij het correct uitvoeren van een computerprogramma is het belangrijk dat het algoritme inderdaad de beoogde functie uitvoert en dat het algoritme goed door het computerprogramma wordt uitgevoerd. Eventuele fouten of problemen moeten hierbij worden gerapporteerd.

Bij het maken van een appeltaart kan je wel een voorstelling maken van wat er gebeurt bij een fout in het recept (algoritme). Wij mensen kunnen kleine probleempjes vaak oplossen door logisch na te denken. Als er bijvoorbeeld in het recept staat verwarm de oven voor op 1600 graden, zullen wij als snel zien dat dit waarschijnlijk één nul te veel is en dat het eigenlijk 160 graden zal moeten zijn. Bij computers gaat dit niet op. Computers voeren de instructies letterlijk uit en gaan niet overdenken wat de programmeur heeft bedoeld. Bij een onduidelijke of foute instructies loopt het programma gewoon vast of produceert onzin als output.

Meer informatie over een algoritme kan je hier vinden

https://npokennis.nl/story/39/wat-is-een-algoritme

B Tekenen met Python Turtle

Introductie

Python Turtle is een Python tekenboard extensie, dit noem je een “library”. De commando’s die je kan uitvoeren vertellen wat de “Turtle” moet tekenen. Dit klinkt misschien kinderachtig, maar je zal al snel merken dat het niet altijd even makkelijk is om de juiste commando’s te geven.

Python Turtle kan je uitvoeren in een Python omgeving, maar er zijn ook veel browser versies beschikbaar die zeer bruikbaar zijn. Daarvoor hoef je niets te installeren en kan je snel aan de slag.

Een aardige website om te beginnen met tekenen is bv:

https://hourofpython.trinket.io/a-visual-introduction-to-python#/welcome/an-hour-of-code

of

https://kooi.github.io/ippt

of

https://repl.it/languages/python_Turtle

of

https://pythonsandbox.com/turtle

Wij zullen in deze module gebruik maken van Repl.it omdat we hier al eerder mee gewerkt hebben.

Een eerste programmatje kan er bv. uitzien zoals hieronder:

import turtle

t = turtle.Turtle()

t.forward(50)
t.right(90)
t.forward(50)
t.left(90)
t.forward(50)
t.left(60)
t.forward(25)

Met als resultaat

Als op de “run” knop wordt gedrukt gaat de “Turtle” aan het werk en maakt hij een tekening (of geeft hij foutmeldingen ☹). Neem boven staande code over en probeer of dat lukt. Probeer ook wat getallen te veranderen.

 

Je start je programma altijd met “import Turtle”, hiermee vertel je Python dat de “turtle library” gebruikt gaat worden. Daarna maken we een variabele aan met een naam. Deze naam start met een letter. Dit mag ook een woord zijn maar geen getal. Je mag wel een variabele aanmaken die start met een letter en daarna een getal bevat. Bv. turtle6 =

 

Python is een object georiënteerde programmeertaal.

Op de regel “t = turtle.Turtle()”
maken we de variabele “t” een instance van object turtle. .Turtle() is de constructor van Turtle.

Daarna volgen wat commando’s bv.

.forward(50) wat betekent schildpad loop 50 pixels naar voren.
.right(90) draai 90 graden naar rechts
.left(90) draai 90 graden naar links

In de beginstand is Turtle altijd naar rechts gedraaid. Als je wilt beginnen met naar boven te tekenen. Zou je eerste commando zijn .left(90)

Helemaal onderaan de cursus staat een cheat-sheet met een lijst mogelijke commando's.

Gebruik van kleuren

Er zijn twee verschillende manieren van het gebruik van kleuren.

  1. De kleur van je pen aanpassen
  2. Inkleuren van figuren

De kleur van je pen wijzigen is het meest eenvoudig, hiervoor kan je het commando .color() gebruiken bv

import turtle
t = turtle.Turtle()

t.color("red")
t.forward(50)

Let hierbij op dat de kleurnamen in het Engels zijn. Probeer zelf wat kleuren uit.

 

Het inkleuren van een figuur werkt als volgt.

  1. Je definieert een kleur die wilt gebruiken dmv .fillcolor(kleur)
  2. Dan geef je het begin vullen commando .begin_fill()
  3. Als je klaar bent met je figuur geef je het stop vul commando .end_fill()

Een voorbeeld

import turtle
t = turtle.Turtle()

t.fillcolor("green")
t.begin_fill()
t.forward(100)
t.left(90)
t.forward(100)
t.left(90)
t.forward(100)
t.left(90)
t.forward(100)
t.left(90)
t.end_fill()
Met als resultaat
 
Maar wat gebeurt er als je het figuur niet helemaal afmaakt en je kleurt het dan in. Hieronder zijn maar twee lijnen van het vierkant getekend.
import turtle
t = turtle.Turtle()

t.fillcolor("green")
t.begin_fill()
t.forward(100)
t.left(90)
t.forward(100)
t.left(90)
t.end_fill()
 

RGB kleuren

Met de namen van kleuren kan je niet alle kleuren maken die je misschien zou willen. Je kan ook RGB kleuren gebruiken zoals we ook in de HTML cursus hebben gedaan.

Als je een kleur als RGB waarde wilt weergeven, dan geeft je in je .fillcolor() of .color() gevolgd door drie getallen (tussen de 0 en 255). Waarbij 0 betekent helemaal niet en 255 volledig.

Bv .color(255,0,0) betekent een pen die volledig ROOD is (waarde 255) en niet GROEN (waarde 0) en niet BLAUW (waarde ook 0).

 

Ook de achtergrond kleur is aan te passen. Maar dit is iets lastiger en wordt pas verderop in de cursus besproken.

Fouten in je programma

 

Het is eigenlijk wel vreemd dat we het woord 'code' gebruiken om een uitgeschreven programma mee aan te duiden. Er is niets geheim aan, als je de programmeertaal kent kun je het programma gewoon lezen.
De oorsprong van die term ligt in de begintijd van de computer. De eerste computers moest je programmeren door een reeks processorinstructies in te voeren. Die instructies waren genummerd, vaak als binaire getallen, omdat de processor nu eenmaal binair werkt. Zo zou het binaire getal '0010' kunnen staan voor de instructie 'sla een getal op in het geheugen'. Deze machinecodes leken natuurlijk wel op geheimschrift. Het werd aangeduid als 'code' en dat woord is nooit meer weggegaan.

Een andere vreemde term in de wereld van programmeurs is bug, wat letterlijk kever of torretje betekent. Je weet het waarschijnlijk wel, een bug is een fout in een programma. Er wordt beweerd dat de term is uitgevonden toen een computer ooit uitviel omdat er een echt torretje in de elektrische schakelingen zat. Dat is niet waar. De term werd al veel langer gebruikt voor fouten in het ontwerp van apparaten. Edison, de uitvinder van onder andere de gloeilamp, gebruikte de term al.
Het is wel waar dat ooit een echte tor de oorzaak van het uitvallen van een computer was. De fout was dus geen figuurlijke bug, maar een echte.

Er bestaat geen programmeur die altijd meteen bij de eerste compilatie een perfect werkend programma heeft. Dus het opsporen en corrigeren van fouten is een altijd aanwezig onderdeel van het programmeren.
Er zijn verschillende soorten fouten.

 

Fouten in de syntax
Allereerst zijn er de zogenaamde syntactische fouten. Fouten die je zou kunnen vergelijken met taalfouten bij het schrijven. Een voorbeeld van een syntax-fout is wanneer je een programma-opdracht niet afsluit met een puntkomma, of wanneer je de naam van een methode met een hoofdletter schrijft, terwijl je dat eerder met een kleine letter hebt gedaan. Het kan  ook zijn dat je een accolade vergeten bent. Dit soort fouten wordt meestal bij het compileren ontdekt. Bovendien geeft de compiler aan wat er fout is en in welke regel.

 

Fouten in de semantiek
Semantische fouten zondigen tegen de betekenis van codewoorden. Ook het gebruik van bouwstenen of procedures waarvan we betekenis, bedoeling of gebruik niet precies kennen, leidt tot semantische fouten. Semantische fouten worden soms wel en soms niet door de compiler herkend.

Het fout gebruiken van een variabele is een voorbeeld van een semantische fout:

bv: opp_rechthoek = lengte + breedte i.p.v. opp_rechthoek = lengte * breedte

Logische fouten
Een ander soort fout is een logische fout. In dat geval heb je soms een werkend programma, alleen doet het niet wat je wilt. Als je een programma wilt schrijven dat twee vierkanten moet tekenen, maar het tekent er maar één, dan heb je een logische fout.

 

Debuggen
Semantische en logische fouten worden ook wel bugs genoemd. Het opsporen en verbeteren van dit soort fouten noemen we 'debuggen'. Voor ons Turtle kunnen we debuggen dmv het console. Als er fouten zijn zullen deze in het console weergegeven worden.

 

Console
In je console kan je zien welke stappen uitgevoerd worden door je programma. Je kan zien dat elk commando stap voor stap wordt uitgevoerd. Je kan de snelheid van uitvoeren van de stappen instellen. Hiervoor kan je het commando .speed() gebruiken. .speed(1) tekent het langzaamst, hoe hoger het getal hoe snelle er wordt getekend. .speed(0) is zo snel mogelijk.

 

Oefening

Even niet tekenen

Stel je wilt 2 vierkanten tekenen die los van elkaar staan. Zoals hieronder


 import turtle
t = turtle.Turtle()

# vierkant 1
t.forward(100)
t.left(90)
t.forward(100)
t.left(90)
t.forward(100)
t.left(90)
t.forward(100)

# ruimte tussen de vierkanten
t.forward(10)

#vierkant 2
t.forward(100)
t.left(90)
t.forward(100)
t.left(90)
t.forward(100)
t.left(90)
t.forward(100)

Je ziet dat er een streepje tussen de vierkanten staat door de code t.forward(10)

Eigenlijk wil je dat onze schildpad dan even niet tekent. Dit kan je oplossen met de commando's

.penup() en .pendown().

Dus in bovenstaand voorbeel door

# ruimte tussen de vierkanten
t.penup()
t.forward(10)
t.pendown()

Meerdere soorten van tekenen

We hebben nu een aantal keer het commando .forward() gezien. Maar je kan ook achteruit lopen door .backward().

Daarnaast kan je ook een coördinaat opgeven waar je naar toe wilt met .goto().

.goto(x,y)

Je kan een x en y coördinaat meegeven waar je turtle naar toe gaat lopen. Let hierbij op dat dit hetzelfde werkt als bij wiskunde. Het is een coördnaat in een assenstelsel waarbij de startpositie van je turtle (0,0) is.

 

Meerdere turtles

Je kan ook meerdere turtle's laten tekenen. Dat kan door ze andere namen te geven

import turtle
t1 = turtle.Turtle()
t2 = turtle.Turtle()
 
t1.forward(50)
t2.backward(50)
t1.left(90)
t2.right(90)
t1.forward(50)
t2.forward(50)
t1.left(90)
t2.left(90)
t1.forward(50)
t2.forward(50)
t1.left(90)
t2.left(90)
t1.forward(50)
t2.forward(50)
In bovenstaande code hebben we twee turtles t1 en t2 die om de beurt een stukje lijn tekenen. Voer de code uit om te zien wat er gebeurt.
 

Oefening

Leesbaarheid

Je zal merken dat je toch wel redelijk wat regels code nodig hebt om een algoritme voor deze figuren te maken.
Om je code leesbaar te houden kan je gebruik maken van comments. Opmerkingen die niet uitgevoerd worden, maar de leesbaarheid vergroten. Elke comments beginnen met een #

Je kan ook meerdere regels als comment gebruiken. Start dan met drie dubbele quotes

# dit wordt niet uitgevoerd

"""
Dit wordt ook niet uitgevoerd
"""

 

 

C Variabele

Variabele waarom???

Stel je wilt een vierkant tekenen, maar je weet van tevoren nog niet zo goed hoe groot het vierkant moet worden. Hieronder wordt een vierkant van 50 x 50 getekend.

import turtle
t = turtle.Turtle()

t.forward(50)
t.left(90)
t.forward(50)
t.left(90)
t.forward(50)
t.left(90)
t.forward(50)
t.left(90)

Stel dat je het vierkant liever 25 x 25 had willen hebben. Dan moet je op 4 plaatsen in je code 50 veranderen in 25. En werkje dat niet echt leuk is. En oplossing voor dit probleem is om een variabele te maken voor de afmeting van het vierkant. Geef deze variabele een naam die zinvol is. Let op elke variabele begint met een letter en bevat GEEN spaties.

Voor ons vierkant kan je bijvoorbeeld een variabele zijde aanmaken. Mochten we ons vierkant toch kleiner willen maken, dan moeten we maar op één plaats in ons algoritme een aanpassing te doen.

import turtle
t = turtle.Turtle()

zijde = 50
t.forward(zijde)
t.left(90)
t.forward(zijde)
t.left(90)
t.forward(zijde)
t.left(90)
t.forward(zijde)
t.left(90)

Oefening

D Herhaling

De algoritmen die je tot nu toe geschreven hebt, zijn nog niet erg efficiënt. Voor het tekenen van een vierkant (vier lijnen en hoeken) had je acht tekenopdrachten nodig. In dit onderdeel zul je zien hoe dat handiger kan.

De eerste stap in het efficiënt opschrijven van algoritmen is het gebruik van de herhalingsstructuur. Wanneer je kijkt naar het algoritme voor het tekenen van een vierkant, dan zie je dat er vier keer hetzelfde staat. Je gaat vier keer vooruit en naar rechts. Of, om precies te zijn: je gaat vier keer (vooruit en naar rechts). In Python kan je op onderstaande manier een herhaling maken

import turtle
t = turtle.Turtle()

zijde=50
for i in range(4):
  t.forward(zijde)
  t.left(90)

Hoe werkt dit:
Achter for zie je een i, dit is een variabele deze mag je noemen hoe je zelf wilt. Meestal wordt daar een letter i gebruikt als afkorting van integer (geheel getal). Je mag dit noemen zoals jij zelf wilt.

range(4) is een lijst met getallen van 0 tot 4. Als deze lijst is doorlopen stopt de herhaling.

Onderstaande code zou precies hetzelfde doen.

import turtle
t = turtle.Turtle()

zijde=50
for getal in [0,1,2,3]:
  t.forward(zijde)
  t.left(90)

De variabele heet hier getal en de range(4) is vervangen door de getallen [0,1,2,3]

Hetgeen je meerdere keren wilt uitvoeren staat onder de for en is een stukje ingesprongen.

Wanneer je het inspringen beeindigd, hoort het niet meer bij de herhaling.

Dus bij bovenstaande code zullen alleen regel 6 en 7 herhaald worden. De code werkt maar is onoverzichtelijk. Beter kan je vertellen wat er gebeurt zoals hieronder.

Variabele printen

Je kan goed zien wat er met de variabele gebeurt door deze op het scherm af te drukken.

import turtle
t = turtle.Turtle()

zijde=50
for i in range(4):
  t.forward(zijde)
  t.left(90)
  t.write(i)  # schrijft in je tekening
  print(i)    # schrijft in je console

Een veel gemaakte fout is dat de : achter de for regel wordt vergeten. Dus let daarop!

Oefening

E Deeltaak

Stel dat je twee vierkanten naast elkaar wilt tekenen. Dan kan het misschien verleidelijk zijn om de copy-paste te gebruiken. Dit is niet de meest handige manier. Hiervoor kan je beter een deeltaak (functie) maken. Een deeltaak (functie) is een stukje code dat je meerdere keren kan gebruiken. Een deeltaak (functie) begint in Python met “def”.

 

import turtle
t = turtle.Turtle()

def vierkant(): # definitie van de deeltaak
  for i in range(4):
    t.forward(50)
    t.left(90)

vierkant() # aanroep van de deeltaak

Let op de volgorde van de code. Eerst de deeltaak aanmaken en daarna pas aanroepen. Geef je deeltaak een logische naam. De naam van een deeltaak moet altijd met een letter beginnen (net als bij een variabele)

Meerdere vierkanten naast elkaar tekenen kan dan als volgt

Toch kan bovenstaande nog iets efficiënter worden geprogrammeerd

Deeltaak met variabele

In onze vorige vierkant() deeltaak hadden we de zijde hard gecodeerd. Dit wil je liever niet. Stel dat je een vierkant van een andere afmeting wilt tekenen dan is onze deeltaak niet meer bruikbaar.

Een oplossing hiervoor is om aan de deeltaak een variabele mee te geven.

import turtle
t = turtle.Turtle()

def vierkant(zijde):
  for i in range(4):
    t.forward(zijde)
    t.left(90)

vierkant(100) # aanroep van de deeltaak

Tussen de haakjes van de deeltaak kan je een variabele aanmaken. Tijdens de aanroep van de deeltaak krijgt deze variabele een waarde. In bovenstaand voorbeeld gebruiken we de variabele zijde. En bij de aanroep wordt zijde = 100.

We hebben nu een deeltaak met één variabele, maar dit kunnen er ook meerdere zijn bijvoorbeeld bij deeltaak rechthoek(lengte, breedte). Deze deeltaak verwacht dan ook dat je twee getallen meegeeft bv. rechthoek(100, 50).

 

 

Globaal vs lokaal

Er zijn verschillende type variabele. Een variabele kan lokaal of globaal zijn. Een variabele die je buiten een deeltaak (functie) definieert is globaal. Dat betekent dat deze overal in je programma te gebruiken is (LET OP! dit is niet bij elke programmeertaal het geval).

Hieronder twee voorbeelden:

 

De volgende vragen gaan over onderstaand figuur

Om te zien wat de posities zijn van de vierkanten zijn de coördinaten afgedrukt op het scherm. (Het is niet nodig dit zelf ook te doen, maar mag wel)

De afmetingen van de vierkanten zijn 100, 40 en 80

Oefening

In de volgende opgave gaan we stap voor stap onderstaande figuur tekenen

Variabele een andere waarde geven

Bij voorgaande oefeningen hebben we de variabele vooraf gedefiniëerd en hielden deze waarde constant. Maar het kwachtige van een variabele is dat deze tijdens het uitvoeren van het programma van waarde kan veranderen.

Een voorbeeld:

zijde = 10          # we hebben onze variabele aangemaakt met waarde 10

zijde = zijde + 10  # we verhogen onze variabele zijde met 10 (zijde is nu 20)

zijde = zijde * 5   # we vermenigvuldigen onze variabele met 5 (zijde is nu 100)

Om een variabele aan te maken of te wijzigen begin je dus altijd met de naam van de variabele en daarachter vertel je welke waarde de variabele moet gaan krijgen.

Met deze kennis kunnen we heel eenvoudig figuren als hieronder tekenen.

Het figuur bestaat uit allemaal vierkanten. We hebben hiervoor dus een deeltaak vierkant nodig.

Deze taak gaan we 10 keer aanroepen, steeds met een iets grotere zijde. Een voorbeeld code zou dit kunnen zijn:

import turtle
t = turtle.Turtle()
t.speed(0)

# deeltaak vierkant
def vierkant(zijde):
  for i in range(4):
  t.forward(zijde)
  t.left(90)

zijde = 10
for i in range(10):
  vierkant(zijde)
  zijde = zijde + 10

Dus bij start van de code is zijde = 10 en in de laatste regel van de herhaling wordt deze zijde steeds met 10 verhoogd. Hetgeen uitgevoerd wordt is dan vierkant(10), vierkant(20), vierkant(30), etc...

 

RGB vulkleur

In de volgende opgave willen we figuren gaan inkleuren met een kleurverloop. Eerder in de cursus hebben we commando's geleerd als .fillcolor(), .begin_fill(), .end_fill(). Bij een kleurverloop wil je aan de .fillcolor() een rgb waarde meegeven

 

Note in sommige gevallen is het noodzakelijk dat de color mode van Turtle wordt aangepast. Dit ligt aan de Python omgeving waarin je werkt. De color mode kan je aanpassen met regel 2 van onderstaande voorbeeld

Als je regel 2 in je programma hebt toegevoegd is het mogelijk om rbg waardes aan de fillcolor mee te geven.

Voorbeeld

import turtle
turtle.colormode(255)  # soms nodig (bij foutmelding verwijderen)
t = turtle.Turtle()

t.fillcolor(255,255,0)
t.begin_fill()
for i in range(4):
  t.forward(100)
  t.left(90)
t.end_fill()

Met als resultaat

 

 

F Expressies en berekeningen

In de vorige paragraaf hebben we variabele laten veranderen met een berekening. Berekeningen zijn dus belangrijk.
In de informatica wordt de term expressie gebruikt voor berekeningen. Expressies zijn min of meer hetzelfde als berekeningen in de wiskunde, al worden soms andere symbolen gebruikt. Optellen (+) en aftrekken (-) hebben de bekende symbolen, vermenigvuldigen gaat met *, delen met /. Je kunt haakjes gebruiken en er zijn speciale functies voor zaken als worteltrekken. Zie hiervoor de cheat-sheet voor details. Het symbool dat wordt gebruikt heet een operator
Belangrijk is dat je op alle plaatsen waar je tot nu toe een getal gebruikte, ook een expressie kunt neerzetten.

Meest gebruikte operatoren
+ optellen
- aftrekken
* vermenigvuldigen
/ delen

In de volgende opgave gaan we expressies gebruiken om vierkanten in vierkanten te plaatsen zodat ze mooi in het midden komen te staan. Hieronder een paar voorbeelden

 

 

Huisjes tekenen

In de volgende opgave gaan we huisjes tekenen.

Hierboven is één huisje getekend.

 

Veelhoek

In eerdere opgave hebben we vierkanten en driehoeken tekend. Het wordt nu tijd voor een deeltaal veelhoek(). Deze deeltaak krijgt twee variabele mee zijde en hoeken

veelhoek(100, 8) moet onderstaande tekening opleveren

Het is ook mogelijk om sterren te tekenen.

Om een ster te tekenen maak je een lijn, daarna draai je turtle 180 - 360/hoeken. En dit herhaal je hoeken keer.

Spiralen

Je kan ook een spiraal tekenen. Dit krijg je voor elkaar door een figuur meerdere keren te tekenen met een kleine draaiing.

 

import turtle
t = turtle.Turtle()
t.speed(0)

def vierkant(zijde):
  for i in range(4):
    t.forward(zijde)
    t.left(90)

for i in range(25):
  vierkant(100)
  t.left(5)

Toch wordt het effect pas echt mooi als je de afmeting van de vierkant ook gaat aanpassen

for i in range(40):
  vierkant(i*5+5)
  t.left(5)

En met inkleuring wordt het helmaal wat

 

 

G Keuzes maken

Afmeting tekenscherm

Als je bij repl.it of een andere IDE, een tekening maakt is de afmeting van je tekenscherm afhankelijk van beeldscherm afmeting. Bij een gemiddelde beeldscherm afmeting kan je ongeveer in een vlak van 600x400 tekenen. Let op dat linker onderpunt dan (-300,-200) is en rechtsboven (300, 200)

Stel dat we een stapel vierkanten willen tekenen die altijd op het scherm passen.

De code voor deze twee vierkanten op elkaar kan zo uitzien

 

import turtle
t = turtle.Turtle()
t.speed(0)

def vierkant(zijde):
  for i in range(4):
    t.forward(zijde)
    t.left(90)

def stapel(aantal):
  zijde = 100
  for i in range(aantal):
    vierkant(zijde)
    # naar de linker bovenhoek voor het volgende vierkant
    t.left(90)
    t.forward(zijde)
    t.right(90)

stapel(2)

Wanneer de stapel(3) wordt gedaan zal het 3e vierkant niet meer helemaal zichtbaar zijn.

Dus als de stapel hoger dan 200 wordt moet de zijde van de vierkanten worden aangepast om deze passend op het scherm te krijgen.

Als aantal x zijde > 200 dan moet zijde kleiner worden zodat aantal x zijde <= 200

In Python kan je daarvoor een IF gebruiken

zijde = 100
if aantal > 2:
  zijde = 200/aantal

Dus standaard is zijde=100 maar als ik meer dan 2 vierkanten wil tekenen dan wordt de zijde aangepast.

In de stapel() deeltaak wordt het dan

def stapel(aantal):
  zijde = 100
  if aantal > 2:
    zijde = 200 / aantal
  for i in range(aantal):
    vierkant(zijde)
    # naar de linker bovenhoek voor het volgende vierkant
    t.left(90)
    t.forward(zijde)
    t.right(90)

stapel(5)

 

Bij een if kan je verschillende vergelijkingsoperatoren gebruiken:

> Groter dan x > y
< Kleiner dan x < y
== Gelijk aan x == y
!= Niet gelijk aan x != y
>= Groter of gelijk aan x >= y
<= Kleiner of gelijk aan x <= y

 

 

 

Interactief

Laten we het vorige stapel probleem interactief maken. Dus dat je als gebruiker kan invoeren hoe hoog de stapel blokjes moet worden zonder dat je hiervoor de code hoeft aan te passen.

Je kan Python een vraag laten stellen in het console door middel van

input("Geef het aantal vierkantjes")

Dit resultaat kan je in een variabele zetten

aantal = input("Geef het aantal vierkantjes")

Aantal is nu hetgeen de gebruiker antwoord op de vraag gevolgd door <enter>. Dit antwoord wordt gezien als tekst, maar zou een getal moeten zijn. We moeten deze tekst dus omzetten naar een getal. Daar hebben we een functie int() voor

aantal = input("Geef het aantal vierkantjes")
aantal = int(aantal)

Of in één keer

aantal = int(input("Geef het aantal vierkantjes"))

In de code van de opdracht kan je nu een kleine aanpassing doen waardoor je bovenstaande gebruikt

aantal = int(input("Geef het aantal vierkantjes"))
stapel(aantal)

 

 

De gebruiker kan nu ingeven voor het aantal hoeken 2. Dit is natuurlijk geen geldige waarde voor de veelhoek. Indien de gebruiker een getal onder de 3 invoert zouden een foutmelding kunnen laten zien. Dit kan door het gebruik van het print() commando.

print("Het aantal hoeken moet groter dan 2 zijn!")

 

 

Herhalen tot het oneindige

Eigenlijk wil je bij de vorige opgave als de gebruiker een onjuist aantal hoeken invult net zo lang blijven vragen hoeveel hoeken totdat er wel een geldige waarde wordt ingevoerd.

Om iets te herhalen totdat een doel bereikt is (of tot in het oneidige) kan een while gebruikt worden.

while aantal < 3:
  print("Het aantal hoeken moet groter dan 2 zijn!")
  #...opnieuw vragen om het aantal hoeken in te voeren

 

 

 

While...

De while kunnen ook zeer makkelijk gebruiken voor herhaling.

Bijvoorbeeld voor het tekenen van een spiraal

Je begint met een lijn en draait dan je turtle bij. Het stukje lijn wordt steeds korter. In code

import turtle
t = turtle.Turtle()

lengte = 20
while lengte > 1:
  t.forward(lengte)
  t.right(15)
  lengte = lengte * 0.95

Er wordt gestart met een lengte 20 en elke keer dat de herhaling wordt uitgevoerd wordt de lengte 5% minder (*0.95). Dit wordt herhaalt zolang de lengte langer dan 1 is.

Aantal herhalingen

Bij de spiraal die we zojuist hebben gebruikt is het niet zo makkelijk om te zien hoeveel keer de code is herhaalt voordat deze stopt.

Soms moet je weten hoeveel keer het was, dit kunnen we oplossen door een teller toe te voegen aan de code.

lengte = 20
teller = 0
while lengte > 1:
  teller = teller + 1
  t.forward(lengte)
  t.right(15)
  lengte = lengte * 0.95
print(teller)

We maken een teller aan met waarde 0 en elke keer dat de herhaling wordt uitgevoerd wordt er één bij opgeteld. Als de herhaling klaar is wordt de teller naar het console geschreven.

Trappen

We gaan nu een deeltaak trap maken. Een trap kan omhoog of naar beneden gaan.

Onze trap deeltaak komt er als volgt uit te zien trap(richting, ...)

richting is daarbij 0 (omlaag) of 1 (omhoog)

We gaan nu de deeltaak trap(...) maken. Je kunt hiervoor gebruik maken van deeltaak vierkant()

import turtle
t = turtle.Turtle()
t.speed(0)

def vierkant():
  t.fillcolor("yellow")
  t.begin_fill()
  for i in range(4):
    t.forward(20)
    t.left(90)
  t.end_fill()

 

 

H Vlakvullingen

In deze paragraaf gaan we patronen waar een vlak mee kan worden ingekleurd. Dit zijn echte puzzels. Maar als je de theorie van de vorige paragrafen slim gebruikt is het vaak makkelijker dan je denkt.

Rekenen

Stel je wilt het volgende gelijkbenige, rechthoekige driehoek tekenen waarbij de rechthoekzijdes beide 100 zijn.

Het begin is makkelijk

import turtle

t = turtle.Turtle()
t.speed(0)
t.forward(100)
t.left(90)
t.forward(100)
t.left(135)

Maar daarna moet ik de lange zijde van de driehoek tekenen. Ik kan natuurlijk wat getallen gaan proberen. Maar dat is tijdrovend en nooit helemaal precies. Daarnaast als ik de zijde een variabele lengte wil geven, dan moet ik wel berekenen.

Maar gelukkig hebben we ooit bij wiskunde de stelling van Pythagoras gehad en daarmee kunnen we berekenen hoe lang de lange zijde van de driehoek met gaan worden.

c2 = a2 + b2
Dus als we voor onze driehoek voor a en b de lengte 100 hebben gekozen kunnen we dit invullen

c2 = 1002 + 1002
En om c dan te weten moeten we daarvan de wortel nemen

c = wortel van (1002 + 1002)

Om wiskunde te gebruiken in Python moet je math importeren. Dat werkt het zelfde als bij turtle.
Onze code gaat nu starten met

import turtle
import math
Nu kunnen we alle methodes (deeltaken die in math zijn gemaakt) gebruiken.

Voor een wortel kunnen we het volgende gebruiken

math.sqrt(2)

Geeft het resultaat van wortel 2

Voor een macht kan je onderstaande gebruiken

math.pow(100,2)

Geeft het resultaat van 1002
Python heeft ook een operator voor machten

100**2

Dit doet het zelfde als math.pow(100,2)

Onze driehoek afmaken

Met bovenstaande kennis kunnen we onze driehoek afmaken

De lengte van de lange zijde moet worden wortel van (1002 + 1002)

Dus

math.sqrt(100**2 + 100**2)
# of met de pow methode
math.sqrt(math.pow(100,2) + math.pow(100,2))

Ons volledige code voor de driehoek wordt dan

import turtle
import math

t = turtle.Turtle()
t.speed(0)
t.forward(100)
t.left(90)
t.forward(100)
t.left(135)
t.forward(math.sqrt(100**2 + 100**2))

 

Driehoeksvulling

We gaan nu een start maken met de volgende vlaksvulling

We kunnen hiervoor de code van de vorige opdrachten goed gebruiken. Daar moesten wij een deeltaak driehoek maken. Deze hoeft alleen nog worden uitgebreid met een fill_color()

import turtle
import math

t = turtle.Turtle()
t.speed(0)

def driehoek(zijde,kleur):
  t.fillcolor(kleur)
  t.begin_fill()
  t.forward(zijde)
  t.left(90)
  t.forward(zijde)
  t.left(135)
  t.forward(math.sqrt(2)*zijde)
  t.left(135)
  t.end_fill()

In het de vlakvulling zien we dat het driehoekje steeds wordt herhaald. Maar de kleur wisselt steeds
Om onze code flexibel te maken starten we met het aanmaken van variabele.

# variabele
zijde = 50
rijen = 4
kolommen = 5

Als we dan later meer rijen of kolommen willen tekenen kan dat eenvoudig door het getal achter de variabele aan te passen.

In de vlakvulling zien we dat op elke rij 5 driehoekjes staan. Dit kunnen we oplossen met een loop

for kolom in range(kolommen):
  driehoek(zijde,"red")

Dit tekent echter 5 driekhoekjes over elkaar heen. Dus na het tekenen van een driehoek moeten we onze turtle zijde opschuiven om de volgende te tekenen.

for kolom in range(kolommen):
  driehoek(zijde,"red")
  t.forward(zijde)
We krijgen nu
Als we nu meerdere rijen willen gaan tekenen is het belangrijk dat na het tekenen van een rij onze turtle weer helemaal teruggaat naar het begin. En liever nog naar de positie waar de nieuwe rij getekend moet gaan worden.
Hieronder drie manieren die je kan gebruiken:
 
Optie 1: Gebruik van forward(), left() etc...
t.penup()
t.backward(kolommen*zijde) # je gaan in ons geval 5x50 terug
t.right(90)
t.forward(zijde)
t.left(90)
t.pendown()

De andere manier is door een goto(x,y), daarbij heb je weer twee mogelijkheden

Optie 2: Code die uitgevoerd wordt voordat er een rij wordt getekend

t.penup()
t.goto(0,-rij*zijde) # let op variabele rij moeten we nog aanmaken
t.pendown()

Optie 3: Code die volgt na het tekenen van een rij

t.penup()
t.goto(0,-(rij+1)*zijde) # let op variabele rij moeten we nog aanmaken
t.pendown()

Omdat we in de tekening steeds de volgende rij eronder tekenen is bij de goto() de y-coördinaat negatief. rij loopt daarbij van 0 tot 4, die gaat we zo aanmaken als we ook de loop voor de rijen gaan gebruiken.

De optie met de minste code is uiteraard de meest aantrekkelijke om te gebruiken. Dus we gaan voor optie 2, maar de andere opties zijn natuurlijk ook juist.

Code tot nu toe

import turtle
import math

t = turtle.Turtle()
t.speed(0)

def driehoek(zijde,kleur):
  t.fillcolor(kleur)
  t.begin_fill()
  t.forward(zijde)
  t.left(90)
  t.forward(zijde)
  t.left(135)
  t.forward(math.sqrt(2)*zijde)
  t.left(135)
  t.end_fill()

# variabele
zijde=50
rijen=4
kolommen=5

#vlakvulling
t.penup()
t.goto(0, -rij * zijde) # let op geeft foutmelding want rij bestaat nog niet!!!!
t.pendown()
for kolom in range(kolommen):
  driehoek(zijde, "red")
  t.forward(zijde)
Nu moeten we de code van de vlakvulling rijen keer herhalen
for rij in range(rijen):
  t.penup()
  t.goto(0, -rij * zijde)
  t.pendown()
  for kolom in range(kolommen):
    driehoek(zijde, "red")
    t.forward(zijde)

Dus voor het tekenen van een rij wordt de turtle in de juiste positie gezet dmv goto(). Daarna wordt de rij getekend.

Nu het laatste probleem de driehoekjes veranderen steeds van kleur. De kleur is afhankelijk van de de positie in de rij en welke kolom.

Voor de eerste rij starten we met rood, onze herhaling loopt van 0 tot 5. Hierbij moet driehoek 0, 2, 4 rood worden en 1, 3 blauw. Je ziet waarschijnlijk al dat we iets met even/oneven moeten gaan doen.

Als kolom even is dan teken we rood en anders blauw

if kolom % 2 == 0:  # bij kolom=even geeft de deling geen rest (modulo = 0)
  driehoek(zijde, "red")
else:
  driehoek(zijde, "blue")

Maar bij de volgende rij die we tekenen is het weer net andersom

if kolom % 2 == 1:  # bij kolom=oneven geeft de deling rest 1 (modulo = 1)
  driehoek(zijde, "red")
else:
  driehoek(zijde, "blue")

Dus bij een even rij moeten we de eerste gebruiken en bij een oneven rij de tweede

if rij % 2 == 0:             # even rij
  if kolom % 2 == 0:         # even kolom
    driehoek(zijde, "red")
  else:                      # oneven kolom
    driehoek(zijde, "blue")
else:                        # oneven rij
  if kolom % 2 == 1:         # oneven kolom
    driehoek(zijde, "red")
  else:                      # even kolom
    driehoek(zijde, "blue")

 

 

 

Schaakbord

Hexagon

Een hexagon is een regematig 6 vlak. In onderstaande opdrachten gaan deze vlakvulling maken

Octagon

Een octagon is een regelmatige achthoek. Hiermee kunnen we ook een mooie vlakvulling maken als

Ruit

In onderstaande theorie/opgave gaan we een vlakvulling maken zoals hieronder.

Omdat we dit zo effectief mogelijk willen doen gaan we twee deeltaken definieren.

  • ruit(zijde, kleur)
  • kubus(zijde)

Elke kubus bestaat uit 3 ruiten. De deeltaak voor de kubus staat hieronder

def kubus(zijde):
  for kleur in ["yellow","red","black"]:
    ruit(zijde, kleur)
    t.left(120)

In deze deeltaak zit een rij met kleuren (geel, rood, zwart) deze rij wordt in de herhaling doorlopen. Dus eerst is kleur=yellow, daarna kleur=red en als laatste kleur=zwart.

De aanroep van de kubus zou er bijvoorbeeld zo kunnen uitzien

kubus(100)

Het resultaat is

Bijzondere hexagon vulling

Let op! Deze is zeer lastig om te tekenen. Zorg dat je al redelijk wat teken ervaring hebt voordat je hieraan begint.

Tip start met één van de bijzondere hexagons en maak daar een deeltaak van bv. special_hexagon(zijde)

Het tweede figuur moet hier naast worden getekend. Hiervoor moeten we weten hoeveel er naar rechts verplaatst moet worden om de volgende te tekenen.

In dit figuur zitten heel veel driehoeken met een hoek van 60 en 30 graden. Hiervoor kunnen we sinus en cosinus gebruiken voor berekeningen, maar bij deze hoeken horen ook exacte zijden.

Hiermee kunnen we de lengte van a en van b uitdrukken in zijde

a = 0.5 * zijde
b = 0.5 * wortel(3) * zijde

Met deze kennis zou je de afstand tussen de volgende figuren kunnen berekenen.

Geen paniek als dit je niet lukt. Deze vlakvulling is zeer lastig en moeilijker dan we van jullie verwachten.

 

 

I Recursie

Inleiding

Recursie (Latijn: recurrere, 'teruglopen') is het optreden van een opeenvolging van constructies waarvan elk afzonderlijk gebaseerd is op een of meer soortgelijke voorgaande constructies. Doorgaans verschilt de volgende constructie in waarde van de voorgaande en is er een beginpunt. Recursieve constructies komen enerzijds in de taalkunde voor en anderzijds in de wiskunde, informatica, natuurwetenschappen en logica.

Een voorbeeld van recursie is het cacaoblikje van Droste. Daarom wordt recursie ook wel het Droste-effect genoemd.

Zelf kan je dit effect ook maken met gebruik van twee spiegels. Of met een camera die je aansluit op een beeldscherm en daarmee het beeldscherm filmt.

Recursie in programma's

We starten eenvoudig met een recursief algoritme op papier.

Hieronder staat de hoofdlijn van een algoritme voor het sorteren van een lijst getallen

Haal het kleinste getal uit de lijst en zet die vooraan

Sorteer de rest van de lijst

 

Goed, de eerste regel is een deeltaak (functie) die nog verder uitgewerkt moet worden, maar die is zeker veel eenvoudiger dan het complete sorteeralgoritme. Je ziet ook de recursie: het sorteeralgoritme roept zichzelf aan, op een deel van de lijst.

Het ziet er redelijk simpel uit, maar het werkt. Het plaatje hieronder laat dat zien.

De recursie moet wel een keer stoppen

Nu klopt het plaatje niet helemaal met het algoritme. In het plaatje stoppen we gewoon als de lijst 'op' is, maar dat staat niet in het algoritme. Dat zal gewoon proberen door te gaan en de kleinste te vinden in een lijst zonder iets. Om het goed te doen moeten we het algoritme aanpassen:

Als er in de rest van de lijst nog iets over is

{    

     Haal het kleinste getal uit de lijst en zet die vooraan

     Sorteer de rest van de lijst

}

 

Hier zie je het tweede belangrijke element van de recursie. Recursie gaat in principe gewoon door met het aanroepen van zichzelf. Dat wordt dan een oneindige lus. Je hebt dus een voorwaarde nodig om de recursie door te laten lopen, als die niet meer waar is, stopt het. Dat is hier als de lijst 'op' is.

Recursie in tekeningen

Met Python turtle kunnen ook tekeningen maken die een recursief algoritme bevatten. Hiermee kunnen we een zeer beperkt aantal regels code zeer uitgebreide figuren tekenen. Die er vaak zeer complex uit zien.

Hieronder bijvoorbeeld een Siepinsky driehoek

Deze gaan we stap voor stap tekenen.

We beginnen met onstaand figuur

In middels weten we het algoritme om een driehoek te tekenen

for i in range(3):
  t.forward(zijde)
  t.left(120)

Uiteraand kunnen we hier ook een deeltaak van maken

def driehoek(zijde):
  for i in range(3):
    t.forward(zijde)
    t.left(120)

Deze deeltaak willen we steeds herhalen nadat we een driehoek hebben getekend. Alleen bij de volgende driehoek moet de zijde gehalveerd worden.

def driehoek(zijde):
  for i in range(3):
    t.forward(zijde)
    t.left(120)
  driehoek(zijde/2)

Je ziet hier dat in de deeltaak driehoek de deeltaak zichzelf gaat aanroepen. Dit blijft oneindig lang doorgaan want nergens staat dat dit moet stoppen met tekenen.

Een manier om aan te geven dat er gestopt moet worden met tekenen is bevoorbeeld een voorwaarde toevoegen. Bijvoorbeeld teken alleen als de zijde > 5

def driehoek(zijde):
  if zijde > 5:
    for i in range(3):
      t.forward(zijde)
      t.left(120)
    driehoek(zijde/2)

Zodra de zijde 5 of kleiner wordt zal het algoritme stoppen.

Onze volledige code wordt dan

import turtle

t = turtle.Turtle()
t.speed(0)

def driehoek(zijde):
  if zijde > 5:
    for i in range(3):
      t.forward(zijde)
      t.left(120)
    driehoek(zijde/2)

driehoek(200)

Bij de Sierpinsky driehoek wordt vanuit elke hoek een driehoek getekend. Op dit moment doen we dat nog alleen vanuit de linker onderhoek. Dus bij elke aanroep van de deeltaak moet de deeltaak zelf drie keer aangeroepen gaan worden. Hiervoor is een zeer kleine aanpassing in onze code nodig.

 

Pythagorasroos

We gaan nu de Pythagoras roos tekenen.

Waarschijnlijk zie je dat dit uit vierkanten bestaat. In elk vierkant is weer een nieuw vierkant getekend, die 45 graden is gedraaid en waarbij de afmeting kleiner is geworden.

Om te beginnen met tekenen kunnen we starten met een deeltaak roos met een zijde als variabele.

import turtle

t = turtle.Turtle()
t.speed(0)

def roos(zijde):
  t.forward(zijde)
  t.left(90)
  t.forward(zijde)
  t.left(90)
  t.forward(zijde)
  t.left(90)
  t.forward(zijde)
  t.left(90)

roos(200)

Nu gaan we zoeken waar in het vierkant het nieuwe vierkant getekend moet gaan worden. Dit is in het midden van één van de zijdes van de vierkant. Laten we de onderzijde nemen.

import turtle

t = turtle.Turtle()
t.speed(0)

def roos(zijde):
  t.forward(zijde/2)
  # hier is het midden van onderste zijde
  t.forward(zijde / 2)
  t.left(90)
  t.forward(zijde)
  t.left(90)
  t.forward(zijde)
  t.left(90)
  t.forward(zijde)
  t.left(90)

roos(200)

We delen de onderste zijde in tweeën. Dus we gaan twee keer .forward(zijde/2) dat is samen nog steeds één hele zijde. Onze uiteindelijke tekening is dan nog steeds een vierkant.

Wanneer we op het midden van de onderste zijde zijn moet onze Turtle 45 graden naar links draaien.
Daarna kan een vierkant worden getekend. En daarna moet onze Turtle weer 45 graden naar rechts draaien om de oorspronkelijke vierkant af te maken.

import turtle

t = turtle.Turtle()
t.speed(0)

def roos(zijde):
  t.forward(zijde/2)
  t.left(45)
  # hier komt het volgende vierkant
  t.right(45)
  t.forward(zijde / 2)
  t.left(90)
  t.forward(zijde)
  t.left(90)
  t.forward(zijde)
  t.left(90)
  t.forward(zijde)
  t.left(90)

roos(200)

Nu moeten we even rekenen hoe groot de zijde van het nieuwe vierkant moet gaan worden.

 

Belangrijk

Wanneer je een teken algoritme maakt met recusie moet je altijd met de volgende zaken rekening houden.

  • Zorg ervoor dat je op een gegeven moment stopt met tekenen
    Bijvoorbeeld alleen tekenen als zijde > 10
  • Zorg ervoor dat je elke figuur aftekend en ook precies eindigd (in richting) zoals je bent begonnen.

Tip: start altijd met het tekenen van één figuur en zoek uit waar in dat figuur het volgende figuur getekend kan worden.

Pythagorasboom

We gaan nu een level hoger een gaan de Pythagoras boom tekenen. De boom bestaat uit allemaal vierkanten die steeds op elkaar getekend zijn.

Om dit te tekenen kunnen we een deeltaak boom maken. Voor het tekenen zijn natuurlijk verschillende mogelijkheden. Kijk goed naar de figuur en stel je zelf de vraag. "Wat wordt er steeds herhaald?"

Hierop zijn meerdere antwoorden mogelijk. Bijvoorbeeld een 'vierkant'.

Toch is het eenvoudiger om een vierkant met daarop een doorzichtige driehoek te gebruiken als herhaling.

Hierboven is de doorzichtige driehoek vervangen door een rode driehoek ter verduidelijking. Omdat hier gestart is met de linkerzijde van de vierkant. Moet op positie a en b het figuur worden herhaald.

Nu we het basis figuur hebben gaan we onze Turtle op positie a zo draaien dat er een nieuwe figuur getekend kan worden. Zorg ervoor dat na de aanroep van het nieuwe figuur Turtle weer wordt teruggedraaid.

Dus op positie a

  1. draai 45 graden naar links
  2. roep deeltaak boom aan met de nieuw zijde (zelfde lengte als bij het doorzichtige driehoek)
  3. draai 45 graden naar rechts

Voor de rechter tak gaat het ongeveer hetzelfde voor positie b. Als je de juiste plek in de code uitkiest hoef je zelfs niet bij te draaien. Je kan daar direct de boom aanroepen

 

Ons algoritme voor de boom is af. Door de zijde > 20 aan te passen kan je de boom ook verder laten tekenen.

Nu willen we nog wel graag een kleurtje.

Vierkanten

Fibonacci spiraal

Sierpinsky tapijt

Sneeuwvlok

Tools

Cheat-sheet

Method

Parameter

Description

Turtle()

None

Creates and returns a new turtle object

forward()

amount

Moves the Turtle forward by the specified amount

backward()

amount

Moves the Turtle backward by the specified amount

right()

angle

Turns the Turtle clockwise

left()

angle

Turns the Turtle counter clockwise

penup()

None

Picks up the Turtle’s Pen

pendown()

None

Puts down the Turtle’s Pen

up()

None

Picks up the Turtle’s Pen

down()

None

Puts down the Turtle’s Pen

color()

Color name

Changes the color of the Turtle’s pen

fillcolor()

Color name

Changes the color of the Turtle will use to fill a polygon

fillcolor(r,g,b)

R,g,b values

Changes the color of the Turtle will use to fill a polygon with r,g,b colors

heading()

None

Returns the current heading

setheading()

angle

Turn the Turtle in this direction (right = 0, up = 90, etc)

position()

None

Returns the current position

goto()

x, y

Move the Turtle to position x,y

begin_fill()

None

Remember the starting point for a filled polygon

end_fill()

None

Close the polygon and fill with the current fill color

dot()

None

Leave the dot at the current position

stamp()

None

Leaves an impression of a Turtle shape at the current location

shape()

shapename

Should be ‘arrow’, ‘classic’, ‘Turtle’ or ‘circle’ (veranderd de vorm)
circle() radius,[ angle] Draw a circle
write() text Write a text on screen (at turtles position)
hideturtle() None Hide Turtle

 

rbg vulkleuren gebruiken turtle.colormode(255)

Math cheat cheat

Gebruiken van wiskunde
import math

wortel math.sqrt(...)
kwadraat math.pow(...,2)
graden naar radialen math.radians(...)
sinus math.sin(...) Let op hoek in radialen
cosinus math.cos(...) Let op hoek in radialen
tangens math.tan(...) Let op hoek in radialen

 

  • Het arrangement 4a: Python Turtle is gemaakt met Wikiwijs van Kennisnet. Wikiwijs is hét onderwijsplatform waar je leermiddelen zoekt, maakt en deelt.

    Auteur
    JEL informatica
    Laatst gewijzigd
    10-06-2024 12:53:26
    Licentie

    Dit lesmateriaal is gepubliceerd onder de Creative Commons Naamsvermelding 4.0 Internationale licentie. Dit houdt in dat je onder de voorwaarde van naamsvermelding vrij bent om:

    • het werk te delen - te kopiëren, te verspreiden en door te geven via elk medium of bestandsformaat
    • het werk te bewerken - te remixen, te veranderen en afgeleide werken te maken
    • voor alle doeleinden, inclusief commerciële doeleinden.

    Meer informatie over de CC Naamsvermelding 4.0 Internationale licentie.

    Aanvullende informatie over dit lesmateriaal

    Van dit lesmateriaal is de volgende aanvullende informatie beschikbaar:

    Toelichting
    Python leren programmeren met Python Turtle
    Eindgebruiker
    leerling/student
    Moeilijkheidsgraad
    gemiddeld
    Studiebelasting
    36 uur 0 minuten

  • Downloaden

    Het volledige arrangement is in de onderstaande formaten te downloaden.

    Metadata

    LTI

    Leeromgevingen die gebruik maken van LTI kunnen Wikiwijs arrangementen en toetsen afspelen en resultaten terugkoppelen. Hiervoor moet de leeromgeving wel bij Wikiwijs aangemeld zijn. Wil je gebruik maken van de LTI koppeling? Meld je aan via info@wikiwijs.nl met het verzoek om een LTI koppeling aan te gaan.

    Maak je al gebruik van LTI? Gebruik dan de onderstaande Launch URL’s.

    Arrangement

    IMSCC package

    Wil je de Launch URL’s niet los kopiëren, maar in één keer downloaden? Download dan de IMSCC package.

    Voor developers

    Wikiwijs lesmateriaal kan worden gebruikt in een externe leeromgeving. Er kunnen koppelingen worden gemaakt en het lesmateriaal kan op verschillende manieren worden geëxporteerd. Meer informatie hierover kun je vinden op onze Developers Wiki.

  • Wikiwijs is een dienst van