Python in de wiskundeles

Bert Wikkerink 

Python is een snelgroeiende programmeertaal en inmiddels ook beschikbaar op de nieuwe grafische rekenmachines en bijbehorende software. Naast een aanvulling bij traditionele onderwerpen kan het ook worden ingezet bij andere onderwerpen. We maken kennis met de volgende toepassingen:

  • Laagdrempelig programmeren met Turtle-graphics
  • Patronen - Langton’s mier
  • Computer gegenereerde kunst

 

Logische voorwaarden en lussen

a=10
print("a = {}".format(a))
if a>5:
  print("a is groter dan 5")
    
    
a=4
print("a = {}".format(a))
if a>5:
  print("a is groter dan 5")
else:
  print("a is niet groter dan 5")

 

Voorbeeld - Huurprijs

Een autoverhuurbedrijf heeft de volgende aanbieding:
De huurprijs is € 66 voor de eerste 70 kilometer plus nog € 0,30 voor elke kilometer die extra gereden wordt.

Algoritme

k = aantal kilometers

als k <= 70
   bedrag = 66
anders
   k1 = k - 70
   bedrag = 66 + 0.30*k1

druk het bedrag af

 

Huurprijs met Python

k=int(input("Aantal kilometers: "))

if k<=70:
  prijs=66
else:
  k1=k-70
  prijs=66+0.30*k1

print("Bedrag voor {} km:".format(k))
print("€ {}".format(prijs))

Python-code
Voorwaarde:   tns  -  8xv  -  py
Huurprijs:   tns -  8xv -  py


Bereken de som van de eerste 100 natuurlijke getallen.

Algoritme

   som = 0

   voor i van 0 tot 100
      vermeeder som met i

   druk som af 

Bereken het getal n waarvoor geldt dat de som van de eerste n natuurlijke getallen groter is dan 1000000.

Algoritme

   n = 0
   som = 0

   zolang som < 1000000
      vermeeder n met 1
      vermeerder som met n

   druk som af

som = 0

for i in range(100):
  som = som + i
print(som)
   
   
  
n=0;som=0

while som<1000000:
  n = n+1
  som = som+n

print("Voor n = {} is".format(n))
print("de som gelijk aan: {}".format(som))

Python-code
For - Som:   tns  -  8xv  -  py
While - Som:   tns -  8xv -  py


 

Enkele wiskundige voorbeelden


Product van de eerste 100 positieve natuurlijke getallen:

$\prod_{i=1}^{100} i$

n=100
product=1
for i in range(1,n+1):
  product=product*i
print(product)    


Definieer faculteit als een Python-functie:

fac($n$) = $\prod_{i=1}^{n} i$

def fac(n):
  product=1
  for i in range(1,n+1):
    product=product*i
  return product

Python-code
Product:   tns  -  8xv  -  py
Faculteit:   tns -  8xv -  py



Hoeveel nullen in 100! 

def nullen(a):
  cijfers=str(a)
  totaal=0
  for c in cijfers:
    if c=="0":
      totaal += 1
  return totaal

Definitie fac(): zie Faculteit


Kleinste $n \in \mathbb{N}$ zodat $n!$ heeft minimaal 100 nullen

n=0;getal=0

while n<100:
  getal += 1
  n=nullen(fac(getal))

print(getal,"! ","heeft",n,"nullen")

Definitie fac(): zie Faculteit
Definitie nullen(): zie Hoeveel nullen in ...


Python-code
Hoeveel nullen:   tns  -  8xv  -  py
Minimaal 100 nullen:   tns -  8xv -  py



Je hebt de beschikking over munten met de volgende waardes (in euro): 2,  1,  0.5,  0.2,  0.1,  0.05,  0.02,  0.01

Schrijf een programma dat voor een bepaald bedrag berekent wat het kleinste aantal munten is om het te betalen.

  • Input: Het bedrag (in euro’s)
  • Output: De aantallen van de benodiged munten
     

                          


Munten met Python

beurs=[2,1,0.5,0.2,0.1,0.05,0.02,0.01]
bedrag=eval(input("Bedrag in euro's: "))

for munt in beurs:
  aantal=0
  while bedrag >= munt :
    bedrag = round(bedrag - munt,2)
    aantal = aantal + 1
  if aantal > 0 :
    print (aantal, "x", munt)

Python-code
Munten:   tns  -  8xv  -  py


 

Turtle Graphics*


Driehoek

from cx_turtle import *
t=Turtle()

t.penup()
t.backward(25)
t.pendown()

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


Vierhoek

from cx_turtle import *
t=Turtle()

t.penup()
t.backward(25)
t.pendown()

def vierhoek():
  for i in range(4):
    t.forward(50)
    t.left(90)

vierhoek()


Vijfhoek

from cx_turtle import *
t=Turtle()

t.penup()
t.backward(25)
t.pendown()

def vijfhoek():
  for i in range(5):
    t.forward(50)
    t.left(72)

vijfhoek()


Veelhoek

from cx_turtle import *
t=Turtle()

t.penup()
t.backward(20)
t.pendown()

def veelhoek(n,zijde):
  for i in range(n):
    t.forward(zijde)
    t.left(360/n)

veelhoek(10,30)

Python-code
Veelhoeken:   tns
     - Driehoek:   8xv  -  py
     - Vierhoek:   8xv  -  py
     - Vijfhoek:   8xv  -  py
     - Veelhoek:   8xv  -  py



6-Zeshoeken

from cx_turtle import *
t=Turtle()

def veelhoek(n,zijde):
  for i in range(n):
    t.forward(zijde)
    t.left(360/n)

t.penup()
t.backward(20)
t.left(90)
t.forward(50)
t.right(90)
t.pendown()

for i in range(6):
  veelhoek(6,20)
  t.forward(20)
  t.right(60)


Pentagram

from cx_turtle import *
t=Turtle()

t.penup()
t.backward(60)
t.left(90)
t.forward(40)
t.right(90)
t.pendown()

for i in range(5):
  t.forward(100)
  t.right(144)


1-pennetrekhuisje

from cx_turtle import *
from math import *
t=Turtle()

t.penup()
t.backward(30)
t.pendown()

t.forward(50)
t.left(90)
t.forward(50)
t.left(45)
t.forward(25*sqrt(2))
t.left(90)
t.forward(25*sqrt(2))
t.left(135)
t.forward(50)
t.right(135)
t.forward(50*sqrt(2))
t.right(135)
t.forward(50)
t.right(135)
t.forward(50*sqrt(2))

Python-code
Figuren:   tns
     - 6-zeshoeken:   8xv  -  py
     - Pentagram:   8xv  -  py
     - 1-pennetrekhuisje:   8xv  -  py  


 

Twee Algoritmes

De mier van Langton is een 2D Turing machine met een reeks eenvoudige regels maar een complex gedrag. het werd uitgevonden door Chris Langton in 1986 en draait op een vierkant rooster van zwarte en witte cellen. Langton's mier kan ook gedefinieerd worden als een Cellurar Automaton.

Regels

  • Als het vakje waarop de mier terecht komt wit is, draait de mier 90$^{\circ}$ naar rechts, wisselt de kleur van het vierkantje en gaat de mier 1 vakje vooruit.
     
  • Als het vakje waarop de mier terecht komt wit is, draait de mier 90$^{\circ}$ naar links, wisselt de kleur van het vierkantje en gaat de mier 1 vakje vooruit.
     

Hoe verloopt de reis van de mier?

De volgende eenvoudige regels leiden tot een zeer complex gedrag:

  • Eenvoud
    Gedurende de eerste honderdtal stappen beweegt de mier volgens eenvoudige patronen, vaak zelf symmetrisch. 
     
  • Chaos
    Dan beweegt de mier zich op een zeer onregelmatige manier tot rond de 10000 stappen.
     
  • Emergentie
    Uiteindelijk start de mier met het opbouwe van een Highway-patroon that blijft herhaald worden.
     


Langton's mier kan vrij eenvoudig uitgebreid worden tot meerdere kleuren. Voor elk van opeenvolgende kleuren gebruiken we een letter L of R. Bijvoorbeeld  RLLR voor zwart  wit  blauw  rood.


Sommige van deze patronen gecreëerd door de mier van Langton vertonen zelf continu symmetrie.  De regels (en code) kunnen nog als volgt uitgebreid worden: 

  • N = geen verandering, U = 180°,
  • R1 = 60° rechts, R2 = 120° rechts,
  • L1 = 60° Links, L2 = 120° Links.

Python-code
Langton's mier:   tns



Een Lindenmayer-systeem of L-systeem is een mechanisme voor het vertalen van gegenereerde strings te vertalen naar geoemtrische structuren. Een L-systeem  is gebaseerd op een alfabet van symbolen voor het maken strings, een verzameling productieregels (generator) om elk symbool uitbreiden tot een grotere reeks symbolen, en een initiële "axioma" (initiator of stam) om de constructie te starten.

De Hongaarse theoretische bioloog en botanist Aristid Lindenmayer introduceerde de L-systemen in 1968 toen hij verbleef aan de Universiteit van Utrecht. HIj gebruikte L-systemen voor het beschrijven van plantencellen en het modelleren van groeiprocessen van planten.

L-systemen kunnen ook gebruikt worden voor het genereren van fractalen. Turtle* graphics zijn een handige tools of L-systemen te coderen in Python. 

De Koch-kromme is gebaseerd op:

Axioma: "F"
Regels: "F"  $\rightarrow$  "F + F - - F + F"

waarbij

  • F = Teken Voorwaarts
  • + = Draai links over 60$^{\circ}$
  • - = Draai rechts over 60$^{\circ}$


Koch-kromme

Axioma: "F"
Regels: 
"F"  $\rightarrow$  "F + F - - F + F"
$\alpha$ = 60$^{\circ}$

tns  -  8xv  -  py


Koch-sneeuwvlok

Axioma: "F++F++F"
Regels: 
"F"  $\rightarrow$  "F - F ++ F - F"
$\alpha$ = 60$^{\circ}$

tns  -  8xv  -  py


Kochische kromme

Axioma: "F"
Regels: 
"F"  $\rightarrow$  "F + F - F - F + F"
$\alpha$ = 90$^{\circ}$

tns  -  8xv  -  py


Kochisch vierkant

Axioma: "F-F-F-F"
Regels: 
"F"  $\rightarrow$  "F + F - F - F + F"
$\alpha$ = 90$^{\circ}$

tns  -  8xv  -  py

Takje

tns  -  8xv  -  py

Struik

tns  -  8xv  -  py

Boom

tns  -  8xv  -  py

Bomen

tns  -  8xv  -  py


Python-code


tns = TI-Nspire CX II-T document met Python-code
8xv = Python-programma voor TI-84 Plus CE-T python edition
py = Python-code

(*)  Voor het runnen van de Turtle-code is Turtle-module nodig:
            - Download de Turtle-module voor de TI-84 Plus CE-T Python Edition,
            - Download de Turtle-module voor de TI-Nspire CX II-T,
            - Installatie van de Turtle-module: TI-84 Plus CE-T Python Edition  -  TI-Nspire CX II-T.

(**) En voor het runnen van de 8xv-code voor de L-systemen is de module graphics nodig:
            - Download de graphics module,
            - Syntax van de grafische commando's van de graphics module,
            - TIP: voor 8xv-code geldt clear=esc & Getting Started.

Leerkrachten/docenten kunnen de TI-Nspire CX Premium software gratis aanvragen om de Python-code uit te proberen.
Klik hier - als ook voor de TI-SmartView CE-T.

Meer over programmeren in Python
TI Python BootCamp >