Laat functies samenwerken

Een functie kan een andere functie aanroepen. Zo bouw je een grotere bewerking uit kleinere onderdelen met een naam.

Stel dat je de spaties rond een menutitel wilt verwijderen en de letters in hoofdletters wilt omzetten:

def clean_title(text):
    return text.strip().upper()

Een tweede functie kan dat resultaat gebruiken:

def make_heading(text):
    clean = clean_title(text)
    return f"=== {clean} ==="

Het programma start vervolgens de hele keten met één aanroep:

heading = make_heading("  reading list  ")
print(heading)

De aanroepen vinden in deze volgorde plaats:

1. Het programma roept make_heading aan.

2. make_heading roept clean_title aan.

3. clean_title geeft "READING LIST" terug aan make_heading.

4. make_heading bouwt "=== READING LIST ===" en geeft die string terug aan het programma.

5. Het programma slaat het resultaat op en drukt het af.

Elke functie heeft één gerichte taak. clean_title weet hoe tekst wordt opgeschoond. make_heading weet hoe het opgeschoonde resultaat wordt opgemaakt.

Waarom niet alles in één functie zetten?

Deze versie is korter:

def make_heading(text):
    return f"=== {text.strip().upper()} ==="

Voor één kleine expressie kan dat prima duidelijk zijn. Afzonderlijke functies worden waardevol wanneer:

• een bewerking een nuttige naam heeft;

• de bewerking op meer dan één plek nodig is;

• elk onderdeel apart gecontroleerd moet kunnen worden;

• het opsplitsen van het werk een grotere functie leesbaarder maakt.

Maak niet van elke regel een functie. Kies grenzen die de lezer helpen het programma te begrijpen.

Teruggegeven waarden verbinden functies

Let erop dat clean_title tekst teruggeeft. De functie drukt die niet af. make_heading heeft die tekst nodig om een andere waarde te bouwen, dus een teruggegeven waarde is de juiste verbinding.

Als clean_title alleen zou afdrukken, zouden deze regels binnen make_heading de verkeerde kop bouwen:

clean = clean_title(text)
return f"=== {clean} ==="

clean zou None bevatten, waardoor de teruggegeven string "=== None ===" zou zijn. De code zou worden uitgevoerd, maar niet de opgeschoonde naam teruggeven.

De ideeën uit de afgelopen drie lessen komen samen:

• parameters brengen informatie een functie binnen;

• lokale variabelen bewaren haar tussenresultaten;

• teruggegeven waarden brengen bruikbare resultaten terug naar de aanroeper;

• een andere functie kan die aanroeper zijn.

def clean_word(text):
    return text.strip().lower()

def make_label(text):
    word = clean_word(text)
    return f"[{word}]"

label = make_label(" Map ")