Lussen

Deze pagina bevat uitvoerbare code.

Looping for a while

for lussen

for number in [0, 1, 2]:
    print("number is", number)

number is 0
number is 1
number is 2

for number in range(0, 3):
    print("number is", number)

number is 0
number is 1
number is 2

for number in [10, 15, 2020]:
    print("number is", number)

number is 10
number is 15
number is 2020

for number in ...:
    print("Gefeliciteerd")

Hoe kan dit 10 keer worden uitgevoerd? Hier is een reeks aan oplossingen mogelijk…

for number in range(10):
    print("Gefeliciteerd!")

Gefeliciteerd!
Gefeliciteerd!
Gefeliciteerd!
Gefeliciteerd!
Gefeliciteerd!
Gefeliciteerd!
Gefeliciteerd!
Gefeliciteerd!
Gefeliciteerd!
Gefeliciteerd!

Iteratief ontwerp

Lussen! Variabelen!

for

for number in [40, 41, 42]:
    print(number)

while

number = 42
while number > 0:
    print(number)
    number -= 1

Variabelen

x = 41
x += 1

Variabelen

Variëren!

age = 41

age = age + 1

Wat hetzelfde is als …

age += 1

In het kort

hwToGo = 7
hwToGo = hwToGo - 1

hwToGo -= 1

total = 21000000
total = total * 2

total *= 2

u235 = 84000000000000000
u235 = u235 / 2

u235 /= 2

for!

for number in [2, 4, 6, 8]:
    print("number is", number)

print("Done!")

Stap voor stap

  1. ken elk element toe aan number

for number in [2, 4, 6, 8]:

  1. de body van de lus gebruikt de waarde van number

  2. en vervolg de lus met het volgende element

    print("number is", number)

  1. code na de lus wordt pas uitgevoerd als de lus klaar is!

print("Done!")

Faculteit met for

def fac(n):
    result = 1                      # nog geen eindresultaat

    for number in range(1, n + 1):  # range begint bij 0, tel er 1 bij op
        result *= number            # vermenigvuldig het resultaat met number

    return result                   # geef het resultaat terug

fac(5)

120

Quiz

x = 0

for number in range(4):
    x += 10

print(x)

Wat wordt geprint voor x?

Oplossing

40

string = "time to think this over! "
result = ""

for ix in range(len(string)):  # ix is een gangbare afkorting voor index
    if string[ix - 1] == " ":
        result += string[ix]

print(result)

Wat wordt geprint voor result?

Oplossing

'tttto'

result

string[ix - 1]

string[ix]

ix

't'

' '

't'

0

't'

'i'

1

'i'

'm'

2

'm'

'e'

3

'e'

' '

4

'tt'

' '

't'

5

't'

'o'

6

'o'

' '

7

'ttt'

' '

't'

8

Zo gaat het door tot en met ix = 24. result groeit daarna nog twee keer: bij ix = 14 naar 'tttt' en bij ix = 19 naar 'tttto'. Bij elke andere index staat er links van string[ix] geen spatie en verandert er niets.

Twee typen for

Elementen versus index

Op basis van element

my_list = [3, 15, 17, 7]

for item in my_list:
    print(item)

string = "een fijne lus"

for char in string:
    print(char)

Op basis van index

my_list = [3, 15, 17, 7]

for ix in range(len(my_list)):
    print(my_list[ix])

string = "een fijne lus"

for ix in range(len(string)):
    print(string[ix])

Let op, het is niet heel gewoon om in lussen te printen, maar is wel heel nuttig voor debuggen!

Welke van de twee?

Elementen: eenvoudiger

Indices: flexibeler

Denk aan het “time to think this over! “ voorbeeld, in de lus kon op basis van de index steeds “terug” worden gekeken in de string met string[ix - 1]!

Extreme lussen

guess = 42

print("It keeps on")

while guess == 42:
    print("going and")

print("Phew! I'm done!")

Wat doet deze lus?

while lussen

Een lus tot een bepaalde conditie is bereikt.

Tests?

  • 42 == 42

  • guess > 42

  • …

Ontsnappen

import random

guess = 0  # startwaarde

while guess != 42:  # test of de lus doorgaat
    print('Help! Let me out!')
    guess = random.choice([41, 42, 43])  # pas op voor een lus die niet stopt

print('At last!')  # na afloop van de lus

Help! Let me out!
Help! Let me out!
At last!

Denken in lussen

for

for number in range(42):
    print(number)

while

x = 1

while x < 42:
    print(x)
    x *= 2

Verschillen

Wat zijn de verschillen in ontwerp tussen deze twee Python lussen?

for - begrensde lus

Het aantal herhalingen ligt vast voordat de lus begint: de lengte van de lijst, of het bereik van range.

while - onbegrensde lus

Het aantal herhalingen ligt niet vast. Jij schrijft de conditie waaronder de lus doorgaat, en jij zorgt dat die ooit niet meer waar is.

Het lusrecept

Bijna elke lus in deze week doet hetzelfde: iets verzamelen terwijl je ergens langsloopt.

Vijf vragen brengen je van het probleem naar de code. Beantwoord ze eerst, schrijf dan pas.

  1. Wat verzamel je, en wat is de startwaarde? Die variabele heet de verzamelvariabele.

  2. Wat loop je langs? Daaruit volgt for of while. Bij een for kies je hier ook tussen de twee typen hierboven: op element of op index.

  3. Wat gebeurt er per stap met wat je verzamelt?

  4. Wanneer is het klaar? Bij een begrensde lus ligt dat vast. Bij een onbegrensde lus schrijf je het zelf.

  5. Wat geef je terug, en waar staat die regel?

Vraag 4 was nog niet beantwoord. Bij een for beantwoordt Python hem voor je: de lijst raakt op. Bij een while niet. Onbegrensd wil zeggen dat de grens van de schrijver moet komen, en dat is precies wat je bij deze lus moet ontwerpen.

Voorbeeld: total(L)

De som van de getallen in een lijst.

  1. Verzamelen: result, startwaarde 0

  2. Langs: de elementen van L, dus een for op element

  3. Per stap: result erbij optellen

  4. Klaar: als L op is

  5. Terug: return result, na de lus

def total(L):
    """Geeft de som van de getallen in de lijst L."""
    result = 0  # 1. verzamelen, startwaarde

    for number in L:  # 2. langs de elementen, 4. klaar als L op is
        result = result + number  # 3. per stap erbij

    return result  # 5. na de lus


assert total([1, 2, 3]) == 6
assert total([-4, 4]) == 0
assert total([]) == 0

result is de naam die in opdracht 2 terugkomt. Eén naam voor één idee: dit is de verzamelvariabele.

Voorbeeld: power_of_two(limit)

De kleinste macht van 2 die minstens limit is.

  1. Verzamelen: result, startwaarde 1

  2. Langs: geen bestaande reeks, dus een while

  3. Per stap: result verdubbelen

  4. Klaar: zodra result minstens limit is. Elke stap verdubbelt result, dus dat gebeurt ook echt

  5. Terug: return result, na de lus

def power_of_two(limit):
    """Geeft de kleinste macht van 2 die minstens limit is."""
    result = 1  # 1. verzamelen, startwaarde

    while result < limit:  # 2. een while, 4. klaar zodra result groot genoeg is
        result = result * 2  # 3. per stap verdubbelen

    return result  # 5. na de lus


assert power_of_two(1) == 1
assert power_of_two(42) == 64
assert power_of_two(64) == 64

Hier doet vraag 4 het werk. Deze lus stopt omdat result elke stap groter wordt en limit dus een keer passeert. Haal die vermenigvuldiging weg en de lus stopt nooit. Dat is geen eigenschap van while, dat is een fout in stap 3.

continue en break

De instructie break zal een lus meteen laten stoppen en het programma gaat verder onder de lus.

De instructie continue gaat naar het einde van de lus en indien nodig wordt de lus herhaald.

Opdracht 1

a. Wat is de output?

def fun1B():
    for number in range(1, 6):
        if number % 2 == 0:
            print("number is", number)
            return


fun1B()

# controleer jouw antwoord

b. Wat is de output?

def fun2B():
    for number in range(1, 6):
        if number % 2 == 0:
            print("number is", number)
        return


fun2B()

# controleer jouw antwoord

c. Wat is de output?

def fun3B():
    for number in range(1, 6):
        if number % 2 == 0:
            print("number is", number)
    return


fun3B()

# controleer jouw antwoord

d. Wat is de output?

def fun4B():
    for number in range(1, 6):
        if number % 2 == 0:
            print("number is", number)


return

fun4B()

# controleer jouw antwoord

Opdracht 2

Wat is de output van het volgende programma?

def function(my_list):
    result = []
    for item in my_list:
        if item < 5:
            result += [item]
    return result


print(function([1, 2, 3, 4, 5, 6]))

# controleer jouw antwoord

Opdracht 3

Schrijf een functie factors(n) die:

  • Een integer n accepteert

  • Een lijst teruggeeft met alle factoren van n

  • Gebruik hiervoor een lus

Beantwoord eerst de vijf vragen van het lusrecept en schrijf daarna pas de code. Je verzamelvariabele is hier een lijst.

Tip

De modulo-operator (%) kan hier heel handig zijn!

  1. Wat verzamel je en wat is de startwaarde?

  2. Waar loop je langs?

  3. Wat doe je per stap?

  4. Wanneer ben je klaar?

  5. Wat geef je terug?

Vergeet niet de functie voldoende te testen, bijvoorbeeld:

assert factors(12) == [1, 2, 3, 4, 6, 12]
assert factors(15) == [1, 3, 5, 15]

# 1. Wat verzamel je en wat is de startwaarde?
# 2. Waar loop je langs?
# 3. Wat doe je per stap?
# 4. Wanneer ben je klaar?
# 5. Wat geef je terug?

# jouw oplossing

Opdracht 4

Wat is de output van het volgende programma?

def function(string):
    result = ""
    for char in string:
        result = char + result
    return result


print(function("Hanze"))

# controleer jouw antwoord

Opdracht 5

Schrijf een functie count_vowels(string) die:

  • Een string string accepteert

  • Alle klinkers in de string telt en dat aantal teruggeeft als integer

  • Gebruik een lus voor het tellen

Beantwoord ook hier eerst de vijf vragen van het lusrecept. Je verzamelvariabele is dit keer een getal.

Tel a, e, i, o en u; y telt niet mee. De operator in controleert of een teken voorkomt in een string: char in "aeiou" levert True of False op. Dat is een andere in dan die van for char in string, waar het woord alleen bij for hoort.

  1. Wat verzamel je en wat is de startwaarde?

  2. Waar loop je langs?

  3. Wat doe je per stap?

  4. Wanneer ben je klaar?

  5. Wat geef je terug?

Maak zelf assertions om je functie te testen, bijvoorbeeld:

assert count_vowels("Hanze") == 2
assert count_vowels("rhythm") == 0

# 1. Wat verzamel je en wat is de startwaarde?
# 2. Waar loop je langs?
# 3. Wat doe je per stap?
# 4. Wanneer ben je klaar?
# 5. Wat geef je terug?

# jouw oplossing