Project Delphi - Python in de Klas

Delphi wordt geladen

We zetten de Python-leeromgeving klaar.

Catalogus openen...

Inhoud

Over Project Delphi

Project Delphi is mijn Python-versie van het idee achter JS in de Klas: leerlingen laten oefenen in de browser, met duidelijke feedback en zo weinig mogelijk technische ballast.

De inhoud kan uit Dodona-achtige oefenmappen komen, maar Delphi zelf is bewust kleiner: handig voor klassikaal oefenen, snel testen en een helder PDF-bewijs achteraf.

Contact: robbewulgaert.be/contact

Deze webomgeving is bedoeld voor gebruik in de klas en voor collega-leerkrachten die de cursus willen inkijken, aanpassen of fork-en.

Licenties: Project Delphi License (educatief gebruik met expliciete naamsvermelding) en third-party notices voor gebruikte componenten zoals Papyros (MIT).

Code-editor

Invoer voor input()

Geen open input-vraag.

Uitvoer

Pogingen: 0 | Tijd: 0s

Oefening Runtime initialiseren...

Sandbox

Beschrijving

Python Formularium

Uitvoer, invoer en variabelen

print("Hallo") schrijft tekst naar de uitvoer.
naam = "Ada" bewaart een waarde in een variabele.
input("Vraag: ") vraagt invoer. Het antwoord is altijd tekst.
int(antwoord) maakt een geheel getal van tekst.
float(antwoord) maakt een kommagetal van tekst.
str(getal) maakt tekst van een getal.

leeftijd = int(input("Leeftijd? "))
print("Je bent", leeftijd, "jaar.")

Tekst netjes combineren

print("Score:", score) is meestal het veiligst in deze cursus.
"Score: " + str(score) kan ook, maar getallen moeten eerst naar tekst.
f"Score: {score}" is handig wanneer je al wat vlotter bent.
Let op punten, hoofdletters en spaties: de testcases vergelijken de uitvoer.

naam = input("Naam? ")
punten = 17
print("Proficiat", naam + ", je behaalde", punten, "punten.")

Rekenen en afronden

+, -, *, / zijn de gewone rekenoperatoren.
** berekent machten: zijde ** 2.
// deelt zonder rest: 17 // 5 geeft 3.
% geeft de rest: 17 % 5 geeft 2.
round(x, 2) rondt af op twee cijfers na de komma.

prijs = 12.5
aantal = 3
totaal = round(prijs * aantal, 2)
print("Totaal:", totaal)

Math en random

import math zet wiskundige functies klaar.
math.sqrt(x) berekent een vierkantswortel.
math.pi gebruikt de juiste waarde van pi.
math.ceil(x) rondt naar boven af, math.floor(x) naar beneden.
import random zet toeval klaar.
random.randint(1, 6) geeft een geheel getal van 1 tot en met 6.

import random

dobbelsteen = random.randint(1, 6)
print("Je gooide", dobbelsteen)

Selectie: if, elif, else

if voorwaarde: voert code uit als de voorwaarde waar is.
elif voorwaarde: test een volgende mogelijkheid.
else: vangt de rest op.
Na if, elif en else komt een dubbelepunt.
De regels onder de keuze moeten inspringen.

score = int(input("Score? "))

if score >= 10:
    print("Geslaagd")
else:
    print("Niet geslaagd")

Voorwaarden combineren

== vergelijkt of twee waarden gelijk zijn.
!= betekent niet gelijk aan.
<, <=, >, >= vergelijken getallen.
and betekent dat beide voorwaarden waar moeten zijn.
or betekent dat minstens een voorwaarde waar moet zijn.
not keert een voorwaarde om.

leeftijd = int(input("Leeftijd? "))
lengte = int(input("Lengte? "))

if leeftijd >= 12 and lengte >= 140:
    print("Je mag binnen.")

Begrensde herhaling: for en range

for i in range(5): herhaalt 5 keer: 0 tot en met 4.
range(1, 6) gaat van 1 tot en met 5.
range(2, 11, 2) gaat van 2 tot en met 10 in stappen van 2.
Gebruik een teller of somvariabele als je iets wil bijhouden.

som = 0

for getal in range(1, 6):
    som = som + getal

print("Som:", som)

Lijsten en strings

lijst = [] maakt een lege lijst.
lijst.append(waarde) voegt iets toe achteraan.
len(lijst) telt het aantal elementen.
lijst[0] neemt het eerste element.
for item in lijst: overloopt elk element.
for letter in woord: overloopt elke letter van een string.

woord = "python"
aantal = 0

for letter in woord:
    if letter == "p":
        aantal = aantal + 1

print("Aantal p:", aantal)

Voorwaardelijke herhaling: while

while voorwaarde: blijft herhalen zolang de voorwaarde waar is.
Zorg dat er in de lus iets verandert, anders stopt de lus nooit.
Gebruik while saldo < doel: voor groeiproblemen zoals sparen.
Gebruik while antwoord != "stop": wanneer de gebruiker mag blijven invoeren.

saldo = 100
jaar = 0

while saldo < 150:
    saldo = saldo * 1.05
    jaar = jaar + 1

print("Aantal jaren:", jaar)

Tips bij veelgemaakte fouten

Staat er een dubbelepunt na if, elif, else, for of while?
Springt de code binnen een keuze of lus overal even ver in?
Heb je == gebruikt om te vergelijken en = om toe te kennen?
Heb je invoer omgezet met int() of float() voor je ermee rekent?
Komt je print()-zin exact overeen met de gevraagde tekst, inclusief punt en spaties?

Volledig formularium in tabel

Functie of statement	Beschrijving NL (kort)	Syntax	Uitzonderingen / opletten voor
`print()`	Schrijft tekst of waarden naar de uitvoer.	`print("Hallo")`	De uitvoer moet vaak exact overeenkomen met de testcases. Let op hoofdletters, spaties en leestekens.
Variabele	Bewaart een waarde onder een naam.	`naam = "Ada"`	Gebruik `=` om een waarde toe te kennen. Gebruik `==` alleen om te vergelijken.
`input()`	Vraagt invoer aan de gebruiker.	`input("Vraag: ")`	Het antwoord is altijd tekst, dus een `str`.
`int()`	Zet tekst of een getal om naar een geheel getal.	`int("7")`	Bij `int(7.9)` wordt afgekapt, niet afgerond.
`float()`	Zet tekst om naar een kommagetal.	`float("3.29")`	Nodig wanneer je met kommagetallen uit `input()` wil rekenen.
`str()`	Zet een getal om naar tekst.	`str(getal)`	Nodig wanneer je getallen met tekst wil samenplakken.
Tekst combineren met komma's	Combineert tekst en waarden in `print()`.	`print("Score:", score)`	Meestal het veiligst. Python voegt automatisch spaties toe.
String-concatenatie	Plakt tekststukken samen.	`"Score: " + str(score)`	Kan alleen met strings. Getallen eerst omzetten met `str()`.
f-string	Zet waarden netjes in een tekstzin.	`f"Score: {score}"`	Handig, maar iets moeilijker voor beginners.
Rekenoperatoren	Voert gewone berekeningen uit.	`+`, `-`, `*`, `/`	`/` geeft een kommagetal als resultaat.
Machten	Berekent een macht.	`zijde ** 2`	Controleer de volgorde van de waarden.
Delen zonder rest	Geeft het gehele quotient van een deling.	`17 // 5`	Handig samen met `%` bij deelbaarheid.
Restdeling	Geeft de rest van een deling.	`17 % 5`	Handig voor even/oneven en deelbaarheid.
`round()`	Rondt een waarde af.	`round(x, 2)`	`round(x)` geeft een `int`. `round(x, 0)` geeft een `float`.
`import`	Laadt een bibliotheek.	`import math`	Zet imports bij voorkeur bovenaan het programma.
`math.sqrt()`	Berekent een vierkantswortel.	`math.sqrt(x)`	Vereist `import math`. Let op de haakjes.
`math.pi`	Geeft de wiskundige waarde van pi.	`math.pi`	Gebruik dit liever dan zelf `3.14` te typen.
`math.ceil()`	Rondt naar boven af.	`math.ceil(x)`	Vereist `import math`.
`math.floor()`	Rondt naar beneden af.	`math.floor(x)`	Vereist `import math`.
`random.randint()`	Geeft een willekeurig geheel getal.	`random.randint(1, 6)`	Vereist `import random`. Beide grenzen tellen mee.
`if`	Voert code uit als een voorwaarde waar is.	`if voorwaarde:`	Dubbelepunt verplicht. De code eronder moet inspringen.
`elif`	Test een volgende mogelijkheid.	`elif voorwaarde:`	Je mag meerdere `elif`-blokken gebruiken.
`else`	Vangt alle overige gevallen op.	`else:`	Er mag maar een `else` zijn. Na `else` komt geen voorwaarde.
Vergelijkingsoperatoren	Vergelijken waarden.	`==`, `!=`, `<`, `<=`, `>`, `>=`	`==` vergelijkt. `=` kent een waarde toe.
`and`	Combineert voorwaarden. Beide moeten waar zijn.	`if a > 0 and b > 0:`	Alleen waar als beide voorwaarden waar zijn.
`or`	Combineert voorwaarden. Minstens een moet waar zijn.	`if a > 0 or b > 0:`	Waar zodra een van de voorwaarden waar is.
`not`	Keert een voorwaarde om.	`if not klaar:`	Maakt `True` tot `False` en omgekeerd.
`for`	Herhaalt code een vast aantal keer.	`for i in range(5):`	`range(5)` loopt van `0` tot en met `4`.
`range()`	Bepaalt start, stop en stapgrootte van een herhaling.	`range(1, 6)`	De stopwaarde telt niet mee.
`range()` met stap	Herhaalt met een vaste stapgrootte.	`range(2, 11, 2)`	Deze reeks geeft `2, 4, 6, 8, 10`.
Teller of somvariabele	Houdt een veranderende waarde bij in een lus.	`som = som + getal`	Eerst initialiseren voor de lus.
Lijst maken	Maakt een lege lijst.	`lijst = []`	Gebruik dit om meerdere waarden te bewaren.
`append()`	Voegt een waarde toe aan een lijst.	`lijst.append(waarde)`	Verandert de lijst, maar print niets vanzelf.
`len()`	Telt het aantal elementen of tekens.	`len(lijst)`	Indexen beginnen nog altijd bij `0`.
Indexering	Neemt een element uit een lijst.	`lijst[0]`	Het eerste element heeft index `0`, niet `1`.
Lijst overlopen	Overloopt elk element van een lijst.	`for item in lijst:`	De lusvariabele is tijdelijk en krijgt telkens een nieuwe waarde.
String overlopen	Overloopt elke letter van een string.	`for letter in woord:`	Een string kan je behandelen als een reeks letters.
`while`	Herhaalt zolang een voorwaarde waar is.	`while voorwaarde:`	Zorg dat er in de lus iets verandert, anders stopt de lus nooit.
Invoer blijven vragen	Laat de gebruiker herhaald invoer geven.	`while antwoord != "stop":`	Vergeet niet om `antwoord` in de lus opnieuw te vragen.
Groeiproblemen	Herhaalt tot een doel bereikt is.	`while saldo < doel:`	Pas de waarde in de lus aan, bijvoorbeeld met rente of groei.
Dubbelepunt	Sluit een blok-statement af.	`if ...:`, `for ...:`, `while ...:`	Ontbrekend dubbelepunt geeft een syntaxfout.
Inspringing	Toont welke code bij een keuze of lus hoort.	Vier spaties inspringen	Ongelijke inspringing veroorzaakt fouten.
Exacte uitvoer	Zorgt dat de output klopt met de opdracht.	`print(...)`	Let op punten, komma's, hoofdletters, spaties en exacte formulering.