Python-functies: zo schrijf en roep je functies aan

Standaardargumenten

Standaardargumenten zijn argumenten die een standaardwaarde aannemen als er tijdens de functieaanroep geen argumentwaarde wordt doorgegeven. Je wijst deze standaardwaarde toe met de toekenningsoperator =, net zoals in het volgende voorbeeld:

Vereiste argumenten

Zoals de naam al aangeeft, zijn de vereiste argumenten van een UDF de argumenten die erbij moeten zitten. Deze argumenten moeten tijdens de functieaanroep worden doorgegeven en in precies de juiste volgorde, zoals in het volgende voorbeeld:

Je hebt argumenten nodig die mappen naar zowel de parameter a als b om de functie aan te roepen zonder fouten te krijgen. Als je a en b omwisselt, zal het resultaat niet verschillen, maar dat kan wel als je plus() als volgt wijzigt:

Keyword-argumenten

Als je zeker wilt weten dat je alle parameters in de juiste volgorde aanroept, kun je keyword-argumenten gebruiken bij je functieaanroep. Daarmee identificeer je de argumenten via hun parameternaam. Laten we het voorbeeld van hierboven nemen om dit te verduidelijken:

Let op dat je met keyword-argumenten ook de volgorde van de parameters kunt omdraaien en toch hetzelfde resultaat krijgt wanneer je je functie uitvoert:

Variabel aantal argumenten

In gevallen waarin je het exacte aantal argumenten dat je aan een functie wilt doorgeven niet kent, kun je de volgende syntax met *args gebruiken:

De asterisk (*) staat vóór de variabelenaam die de waarden bevat van alle niet-keyword variabele argumenten. Merk op dat je hier net zo goed *varint, *var_int_args of een andere naam aan de functie plus() had kunnen doorgeven.

Tip: probeer *args te vervangen door een andere naam die de asterisk bevat. Je zult zien dat de bovenstaande code gewoon blijft werken!

Je ziet dat de bovenstaande functie gebruikmaakt van de ingebouwde Python-functie sum() om alle argumenten op te tellen die aan plus() worden doorgegeven. 

Globale vs. lokale variabelen

In het algemeen hebben variabelen die binnen een functiebody zijn gedefinieerd een lokale scope, en variabelen die daarbuiten zijn gedefinieerd hebben een globale scope. Dat betekent dat lokale variabelen binnen een functielichaam zijn gedefinieerd en alleen binnen die functie toegankelijk zijn, terwijl globale variabelen door alle functies in je script kunnen worden benaderd:

Je zult zien dat je een NameError krijgt waarin staat dat de name 'total' is not defined wanneer je probeert de lokale variabele total te printen die binnen het functielichaam is gedefinieerd. De variabele init daarentegen kan zonder problemen worden geprint.

Alleen-positionele en alleen-keyword-parameters

Sinds Python 3.8 kun je meer controle nemen over hoe argumenten moeten worden doorgegeven met twee speciale markeringen in je functiedeclaratie: / en *. Alles vóór de / mag alleen positioneel worden doorgegeven; alles na de * mag alleen via keywords worden doorgegeven.

def greet(name, /, greeting="Hello", *, punctuation="!"):
    print(f"{greeting} {name}{punctuation}")

 Zo pakt dat uit op de aanroepplaats:

greet("Alice")                          # werkt
greet("Alice", greeting="Hi")           # werkt
greet("Alice", "Hi", punctuation="?")   # werkt

greet(name="Alice")                     # TypeError: name is positional-only
greet("Alice", "Hi", "?")               # TypeError: punctuation is keyword-only

Waarom zou je dit willen? Twee hoofdredenen.

Ten eerste laten alleen-positionele parameters je ze later hernoemen zonder iemands code te breken — omdat niemand de parameternaam als keyword mag gebruiken, ben je vrij om die te wijzigen.

Ten tweede dwingen alleen-keyword-parameters aanroepers om expliciet te zijn over wat ze doorgeven, wat aanroepen leesbaarder maakt wanneer je meerdere optionele vlaggen of instellingen hebt.

Kortom, het is een nette manier om intentie af te dwingen.

Anonieme functies in Python

Anonieme functies worden in Python ook lambda-functies genoemd, omdat je in plaats van ze te declareren met het standaardtrefwoord def, het trefwoord lambda gebruikt.

In het bovenstaande DataCamp Light-blok is lambda x: x*2 de anonieme of lambda-functie. x is het argument en x*2 is de expressie of instructie die wordt geëvalueerd en geretourneerd. Het bijzondere aan deze functie is dat ze geen naam heeft, in tegenstelling tot de voorbeelden die je in het eerste deel van deze functietutorial hebt gezien. Als je de bovenstaande functie als UDF zou schrijven, krijg je het volgende:

def double(x):
  return x*2

Laten we nog een voorbeeld van een lambda-functie bekijken waarin je met twee argumenten werkt:

Je gebruikt anonieme functies wanneer je een naamloze functie nodig hebt voor een korte periode, die tijdens runtime wordt aangemaakt. Specifieke contexten waarin dit relevant is, zijn wanneer je werkt met filter(), map() en reduce():

De functie filter() filtert, zoals de naam al suggereert, de oorspronkelijke invoerlijst my_list op basis van een criterium >10. Met map() pas je daarentegen een functie toe op alle items van de lijst my_list. In dit geval vermenigvuldig je alle elementen met 2.

Let op dat de functie reduce() deel uitmaakt van de bibliotheek functools. Je past deze functie cumulatief toe op de items van de lijst my_list, van links naar rechts, en reduceert de reeks tot één waarde, in dit geval 55.

main() gebruiken als functie in Python

Als je ervaring hebt met andere programmeertalen zoals Java, weet je dat de functie main nodig is om functies uit te voeren. Zoals je in de bovenstaande voorbeelden hebt gezien, is dat voor Python niet per se nodig. Toch kan het opnemen van een main()-functie in je Python-programma handig zijn om je code logisch te structureren: alle belangrijkste onderdelen staan dan in deze main()-functie.

Je kunt eenvoudig een main()-functie definiëren en aanroepen, net zoals je met alle andere functies hierboven hebt gedaan:

Zoals het er nu uitziet, wordt de code van je main()-functie echter aangeroepen wanneer je deze als module importeert. Om ervoor te zorgen dat dit niet gebeurt, roep je de functie main() aan wanneer __name__ == '__main__'.

Dat betekent dat de code uit het bovenstaande codeblok wordt:

Let op dat je naast de functie __main__ ook een functie __init__ hebt die een instantie van een klasse of een object initialiseert. Simpel gezegd werkt die als een constructor of initializer en wordt automatisch aangeroepen wanneer je een nieuwe instantie van een klasse maakt. Met die functie wordt het nieuw aangemaakte object toegewezen aan de parameter self, die je eerder in deze tutorial hebt gezien. Bekijk het volgende voorbeeld:

class Dog:
    """A simple Dog class.

    Args:
        legs: Number of legs so that the dog can walk.
        color: The color of the fur.
    """

    def __init__(self, legs: int, color: str) -> None:
        self.legs = legs
        self.color = color

    def bark(self) -> str:
        return "bark" * 2

if __name__ == "__main__":
    dog = Dog(4, "brown")
    print(dog.bark())