Python-functies onder de knie: definitie, aanroep, inspringing, argumenten en return-waarden

Functies zijn de bouwstenen van elke Python-applicatie. Ze kapselen herbruikbare logica in, houden je code DRY (Don't Repeat Yourself) en maken programma's makkelijker leesbaar, testbaar en onderhoudbaar. In deze gids doorlopen we elke stap die je nodig hebt om functies in Python 3 te schrijven, aan te roepen en te debuggen – met ook aandacht voor de verschillen met Python 2.

Wat is een functie in Python?

Een Python-functie is een zelfstandig blok code dat wordt uitgevoerd wanneer je het aanroept. Je kunt het zien als een miniprogramma dat één welgedefinieerde taak uitvoert en overal herbruikbaar is. Python wordt standaard geleverd met talloze ingebouwde functies (zoals print(), input()), maar je kunt er ook zelf schrijven, waardoor je code de kracht krijgt om te evolueren en te schalen.

Een functie definiëren en aanroepen

Functies declareer je met het sleutelwoord def, gevolgd door de functienaam en een lijst met parameters tussen haakjes. De functiebody begint met een dubbele punt en moet inspringen.

def groet():
    print("Hallo, Python!")

# Roep de functie aan
groet()

Output: Hallo, Python!

Waarom inspringing cruciaal is

Python gebruikt geen accolades of expliciete begin/end-statements. In plaats daarvan definieert inspringing de scope. Elk codeblok – functies, lussen, conditionals – moet een consistente inspringingsniveau delen.

1. Minimaal één inspringingsniveau (meestal vier spaties) is verplicht na een functiedefinitie.
2. Alle statements binnen die functie moeten dezelfde inspringing gebruiken.
3. Het mengen van tabs en spaties, of het variëren van inspringingsdiepte, leidt tot een IndentationError.

Voorbeeld van correcte inspringing:

def demo():
    print("Regel 1")
    print("Regel 2")

En een veelgemaakte fout:

def demo():
print("Oeps")

wat resulteert in: IndentationError: expected an indented block

Return-statements gebruiken

Het sleutelwoord return stuurt een waarde terug naar de aanroeper. Als een functie het einde bereikt zonder return te tegenkomen, geeft het impliciet None terug.

def kwadraat(x):
    return x * x

print(kwadraat(4))  # 16

Zonder return:

def kwadraat(x):
    x * x

print(kwadraat(4))  # None

Daarnaast toont het printen van het functie-object zelf (bijv. print(kwadraat)) het geheugenadres, wat in toepassingscode zelden nuttig is.

Argumenten doorgeven aan functies

Argumenten leveren de data die een functie nodig heeft om te opereren. Parameters zijn de placeholders die in de functiesignatuur gedefinieerd worden.

def vermenigvuldig(x, y=1):
    return x * y

print(vermenigvuldig(4))        # 4 (y default 1)
print(vermenigvuldig(4, 2))     # 8
print(vermenigvuldig(y=3, x=2)) # 6 (keyword arguments staan herordening toe)

Variabele lengte argumenten (*args en **kwargs)

Soms heb je een functie nodig die een willekeurig aantal argumenten accepteert. Gebruik *args voor positionele argumenten en **kwargs voor keyword-argumenten.

def samengevat(*waarden, **opties):
    totaal = sum(waarden)
    print(f"Totaal: {totaal}")
    if opties.get("toon_details"):
        print("Waarden:", waarden)

samengevat(1, 2, 3, 4, 5, toon_details=True)

Python 2 vs Python 3: Belangrijkste verschillen

• Print-syntaxis: print "tekst" in Python 2 vs print("tekst") in Python 3.
• Functie-overloading (meerdere handtekeningen met dezelfde naam) wordt in Python 2 niet ondersteund, maar is in Python 3 beschikbaar via functools.singledispatch of door argumenttypen te inspecteren.
• Gehele deling: 5/2 levert 2 op in Python 2 en 2.5 in Python 3 (gebruik // voor floor division in beide versies).

Best practices voor functieontwerp

• Houd functies gefocust: één functie moet één duidelijke taak uitvoeren.
• Documenteer met een docstring op de eerste regel binnen de functie.

  def optellen(a, b):
      """Geef de som van a en b terug."""
      return a + b

• Gebruik type hints (Python 3.5+) om verwachte argumenttypen en returntypen te verduidelijken.

  def optellen(a: int, b: int) -> int:
      return a + b

• Kies bij voorkeur keyword-argumenten voor optionele parameters om de leesbaarheid te verbeteren.

Complete voorbeeld

# Voorbeeld van een uitgebreid Python 3-script
def groet():
    """Print een vriendelijke groet."""
    print("Hallo, Python!")

def kwadraat(x: int) -> int:
    """Geef het kwadraat van x terug."""
    return x * x

def vermenigvuldig(x: int, y: int = 1) -> int:
    """Geef het product van x en y terug, met y standaard 1."""
    return x * y

# Demonstratie
if __name__ == "__main__":
    groet()
    print(kwadraat(4))           # 16
    print(vermenigvuldig(4))     # 4
    print(vermenigvuldig(4, 2))  # 8
    print(vermenigvuldig(y=2, x=4)) # 8

Voor meer gedetailleerde informatie, raadpleeg de officiële Python-documentatie over functiedefinities.