Opstap¶
Naspelen¶
Leerdoel: een functie met twee recursieve aanroepen aanroep voor aanroep naspelen.
Deze opdrachten horen bij het eerste college. Voorspel bij elke opdracht eerst de uitvoer, en voer daarna de cel uit.
Opdracht 1¶
Deze functie is exact_change uit het eerste college, met een print aan het
begin. Zo zie je elke aanroep.
a. Hoeveel aanroepen van function drukt dit programma af?
b. Teken de boom van aanroepen, zoals de figuur van subset in het college. Zet
in elk vak het bedrag en de munten, en wat de aanroep teruggeeft.
c. Wat drukt de laatste regel af?
def function(amount, coins):
print(amount, coins)
if amount == 0:
return True
elif amount < 0:
return False
elif coins == []:
return False
else:
use_it = function(amount - coins[0], coins[1:])
lose_it = function(amount, coins[1:])
return use_it or lose_it
print(function(3, [1, 2]))
Is je antwoord af? Voer dan de cel hieronder uit om het te controleren. De
functie check doet hetzelfde als function, maar drukt bij elke aanroep twee
regels af: de aanroep zelf, en met -> wat hij teruggeeft. Wat een aanroep zelf
weer aanroept, staat eronder en springt verder in. Zo kun je je boom vak voor vak
vergelijken.
def check(amount, coins, depth):
"""Doet hetzelfde als function en drukt elke aanroep af, met wat hij teruggeeft."""
print(" " * depth + "function(" + str(amount) + ", " + str(coins) + ")")
if amount == 0:
result = True
elif amount < 0:
result = False
elif coins == []:
result = False
else:
use_it = check(amount - coins[0], coins[1:], depth + 1)
lose_it = check(amount, coins[1:], depth + 1)
result = use_it or lose_it
print(" " * depth + "-> " + str(result))
return result
check(3, [1, 2], 0)
Opdracht 2¶
Deze functie is subset uit het eerste college.
a. Wat geeft function(5, [4, 3, 2]) terug, en welke items horen daarbij?
b. Bij welke aanroepen past het eerste item niet, zodat alleen lose it wordt
geprobeerd?
def function(capacity, items):
if items == []:
return 0
first = items[0]
rest = items[1:]
if first > capacity:
return function(capacity, rest)
else:
use_it = first + function(capacity - first, rest)
lose_it = function(capacity, rest)
return max(use_it, lose_it)
print(function(5, [4, 3, 2]))
Is je antwoord af? Voer dan de cel hieronder uit om het te controleren. Net als
bij opdracht 1 drukt check elke aanroep af, met -> wat hij teruggeeft. Bij een
aanroep waarin het eerste item niet past, staat ook past niet.
def check(capacity, items, depth):
"""Doet hetzelfde als function en drukt elke aanroep af, met wat hij teruggeeft."""
print(" " * depth + "function(" + str(capacity) + ", " + str(items) + ")")
if items == []:
result = 0
elif items[0] > capacity:
print(" " * depth + "past niet: " + str(items[0]))
result = check(capacity, items[1:], depth + 1)
else:
use_it = items[0] + check(capacity - items[0], items[1:], depth + 1)
lose_it = check(capacity, items[1:], depth + 1)
result = max(use_it, lose_it)
print(" " * depth + "-> " + str(result))
return result
check(5, [4, 3, 2], 0)
Lezen¶
Leerdoel: nagaan wat een aanroep met key= of een lambda-functie teruggeeft.
Deze opdrachten horen bij het tweede college. Voorspel bij elke opdracht eerst de uitvoer, en voer daarna de cel uit.
Opdracht 3¶
Wat drukt dit programma af? Waarom geven de twee aanroepen van max iets anders
terug?
animals = ["olifant", "kat", "zebra"]
print(sorted(animals))
print(max(animals))
print(max(animals, key=len))
print(min(animals, key=len))
Opdracht 4¶
Wat drukt dit programma af? Wat geeft de lambda-functie terug voor "b2"?
codes = ["b2", "a3", "c1"]
print(sorted(codes))
print(sorted(codes, key=lambda s: s[1]))
Opdracht 5¶
a. Hoe vaak roept function de functie f aan?
b. Wat drukt dit programma af?
def function(f, x):
return f(f(x))
print(function(lambda x: x + 3, 10))
print(function(lambda s: s + "!", "hoi"))
Schrijven¶
Leerdoel: een functie meegeven als argument, als bestaande functie, als eigen functie en als lambda-functie.
Deze opdrachten horen bij het tweede college. Voer de cel hieronder eerst uit; de opdrachten gebruiken deze gegevens.
words = ["vuurtoren", "de", "draait", "nacht"]
pairs = [["b", 2], ["a", 3], ["c", 1]]
prices = {"brood": 3.2, "kaas": 6.5, "melk": 1.25, "appels": 2.8}
Opdracht 6¶
Schrijf met sorted, max en min en key=len:
a. by_length: de woorden uit words van kort naar lang;
b. longest: het langste woord;
c. shortest: het kortste woord.
Hint
len staat achter key= zonder haakjes: je geeft de functie mee, je roept haar
niet aan.
by_length = ...
longest = ...
shortest = ...
assert by_length == ["de", "nacht", "draait", "vuurtoren"]
assert longest == "vuurtoren"
assert shortest == "de"
Opdracht 7¶
a. Schrijf de functie second(pair), die het tweede element van een paar
teruggeeft.
b. Sorteer pairs op hun tweede element met key=second, en noem het resultaat
by_second.
c. Doe hetzelfde zonder second, met een lambda-functie, en noem het resultaat
by_second_lambda.
Variabele |
Waarde |
|---|---|
|
|
# jouw oplossing
assert second(["b", 2]) == 2
assert by_second == [["c", 1], ["b", 2], ["a", 3]]
assert by_second_lambda == [["c", 1], ["b", 2], ["a", 3]]
Opdracht 8¶
prices is een dictionary van product naar prijs. Schrijf met key=prices.get:
a. cheapest: het goedkoopste product;
b. by_price: de producten van goedkoop naar duur.
Hint
min en sorted lopen bij een dictionary de sleutels langs: de producten.
prices.get geeft bij elk product de prijs.
cheapest = ...
by_price = ...
assert cheapest == "melk"
assert by_price == ["melk", "appels", "brood", "kaas"]
Opdracht 9¶
Schrijf de functie all_pass(L, test). test is een functie die bij elk element
True of False teruggeeft. all_pass geeft True als test voor elk element
van L True teruggeeft, en anders False. Gebruik recursie.
Aanroep |
Resultaat |
|---|---|
|
|
|
|
|
|
Hint
De vorm is die van only_digits uit het
tweede college van week 3. In plaats van te
vragen of het eerste teken een cijfer is, vraag je test(L[0]).
# jouw oplossing
assert all_pass([2, 4, 6], lambda x: x % 2 == 0) == True
assert all_pass([2, 3, 4], lambda x: x % 2 == 0) == False
assert all_pass(["kat", "ezel"], lambda s: len(s) >= 3) == True
assert all_pass([], lambda x: x > 0) == True