Oefeningen functies¶

def verdrievoudigen(x):
    """Verdrievoudigen."""
    return 3 * x

print(verdrievoudigen(4), verdrievoudigen("ab"), verdrievoudigen(1.5))

def kwadraat(x):
    """Kwadraat van x."""
    print(x ** 2)

resultaat = kwadraat(5)
print(resultaat)

def verschil(a, b):
    """Verschil van a en b."""
    return a - b

x = 10
y = 4
print(verschil(y, x), verschil(x, y))

def volgende(x):
    """Het volgende getal."""
    return x + 1
    print("klaar")

def volgende_bis(x):
    """Het volgende getal."""
    print("klaar")
    return x + 1

print(volgende(volgende(2)))
print(volgende_bis(volgende_bis(2)))

def verhoog(getal):
    """Getal verhogen met 10."""
    getal = getal + 10
    return getal

getal = 5
nieuw = verhoog(getal)
print(getal, nieuw)

def opp_vierkant(z):
    """Oppervlakte van een vierkant met zijde z."""
    return z ** 2

def opp_kubus(z):
    """Totale oppervlakte van een kubus met ribbe z."""
    return 6 * opp_vierkant(z)

print(opp_kubus(3), opp_vierkant(opp_vierkant(2)))

import math

def schuine_zijde(a, b):
    """Schuine zijde van een rechthoekige driehoek met rechthoekszijden a en b."""
    return math.sqrt(a ** 2 + b ** 2)

print(schuine_zijde(3, 4), int(schuine_zijde(5, 5)))

def prijs_met_btw(prijs):
    """Prijs inclusief 21 % btw."""
    return prijs * 1.21

p = input("Prijs zonder btw? ")
print(p * 2, prijs_met_btw(float(p)))

def procent(x, p):
    """p procent van x."""
    return x * p / 100

for g in [50, 80, 300]:
    print(f"20 % van {g} is {procent(g, 20)}")

def beoordeling(punt):
    """Geslaagd of niet."""
    if punt >= 10:
        return "geslaagd"
    return "niet geslaagd"

print(beoordeling(12), "-", beoordeling(9.5))

def halveren(x):
    """Helft van x."""
    helft = x / 2

print(halveren(10) + 1)

def opp_rechthoek(l, b):
    """Oppervlakte van een rechthoek met lengte l en breedte b."""
    return l * b

print(opp_rechthoek(7))

def f(x):
    """f(x) = x² - 4x + 3"""
    return x ** 2 - 4 * x + 3

for x in range(0, 5):
    print(x, f(x))

def bewerking1(a, b):
    """Kwadraat van de som van a en b."""
    return (a + b) ** 2

def bewerking2(a, b):
    """Som van de kwadraten van a en b."""
    return a ** 2 + b ** 2

print(bewerking1(3, 4), bewerking2(3, 4), bewerking1(3, 4) - bewerking2(3, 4))

#uitbreiding (bonusvraag)
class Rechthoek:
    """Klasse Rechthoek."""

    def __init__(self, lengte, breedte):
        """Initialisatie: een rechthoek heeft een lengte en een breedte."""
        self.l = lengte
        self.b = breedte

    def oppervlakte(self):
        """Oppervlakte van de rechthoek."""
        return self.l * self.b

r1 = Rechthoek(4, 3)
r2 = Rechthoek(2, 5)
print(r1.oppervlakte() + r2.oppervlakte(), r1.l)

def omtrek_vierkant(z)
    """Omtrek van een vierkant met zijde z."""
    return 4 * z

print(omtrek_vierkant(6))

def verdubbelen(x):
    """Verdubbelen."""
    dubbel = 2 * x

print(f"Het dubbel van 7 is {verdubbelen(7)}.")

def prijs_na_korting(pr, per):
    """Prijs na een korting van per procent op een prijs pr."""
    nieuwe_prijs = pr * (1 - pr / 100)
    return nieuwe_prijs

print(f"De prijs na korting is {prijs_na_korting(100, 35)} euro.")

print(opp_driehoek(6, 4))

def opp_driehoek(b, h):
    """Oppervlakte van een driehoek met basis b en hoogte h."""
    return b * h / 2

def opp_cirkel(r):
    """Oppervlakte van een cirkel met straal r."""
    return math.pi * r ** 2

print(round(opp_cirkel(2), 2))

def inhoud_kubus(z):
    """Inhoud van een kubus met ribbe z."""
    return z ** 3

zijde = input("Ribbe van de kubus? ")
print(f"De inhoud is {inhoud_kubus(zijde)}.")

def inhoud_piramide(z, h):
    """Inhoud van een piramide met vierkant grondvlak met zijde z en hoogte h."""
    return z ** 2 * h / 3

# piramide met een vierkant grondvlak met zijde 6 m en hoogte 9 m
print(f"Inhoud: {inhoud_piramide(9, 6)} m³")

def som_lijst(getallen):
    """Som van alle getallen in de lijst."""
    totaal = 0
    for g in getallen:
        totaal += g
        return totaal

print(som_lijst([4, 7, 9]))

def gemiddelde(a, b, c):
    """Gemiddelde van a, b en c."""
    gem = (a + b + c) / 3
    return gem

gemiddelde(12, 15, 18)
print(gem)

#uitbreiding (bonusvraag)
class Gletsjer:
    """Klasse Gletsjer."""

    def __init__(self, gletsjer_naam, gletsjer_land):
        """Initialisatie: naam en land van de gletsjer."""
        self.naam = gletsjer_naam
        self.land = gletsjer_land

    def kenmerken(self):
        """Geeft attributen weer."""
        print(f"De gletsjer {naam} ligt in {self.land}!")

gletsjer1 = Gletsjer("Aletschgletsjer", "Zwitserland")
gletsjer1.kenmerken()

import math

def omtrek_cirkel(r):
    """Omtrek van een cirkel met straal r."""
    ...
    return omtrek

# omtrek van een cirkel met diameter 10 cm
...
print(f"De omtrek is {...} cm.")

def naar_fahrenheit(...):
    """..."""
    ...
    return ...

for c in [0, 20, 37, 100]:
    print(f"{c} °C = {...} °F")

import math

def opp_cirkel(r):
    """Oppervlakte van een cirkel met straal r."""
    return math.pi * r ** 2

def opp_ring(R, r):
    """Oppervlakte van een cirkelring met buitenstraal R en binnenstraal r."""
    ...

print(round(opp_ring(5, 3), 2))

def f(x):
    """f(x) = -x² + 6x - 5"""
    ...

for x in ...:
    ...

def is_rechthoekig(a, b, c):
    """..."""
    ...

print(is_rechthoekig(3, 4, 5), is_rechthoekig(5, 6, 7), is_rechthoekig(5, 12, 13))

import math

class Cirkel:
    """Klasse Cirkel."""

    def __init__(self, ...):
        """Initialisatie: een cirkel heeft een straal."""
        ...

    def omtrek(self):
        """Omtrek van de cirkel."""
        ...

    def oppervlakte(self):
        """Oppervlakte van de cirkel."""
        ...

c1 = ...
print(round(c1.omtrek(), 2), round(c1.oppervlakte(), 2))