In Python kun je een functie definiëren waaraan een variabel aantal argumenten moet doorgegeven worden. In dit artikel leert u dergelijke functies te definiëren met behulp van standaard-, trefwoord- en willekeurige argumenten.
Video: Python-functieargumenten: positioneel, trefwoorden en standaard
Argumenten
In het onderwerp door de gebruiker gedefinieerde functie hebben we geleerd hoe we een functie kunnen definiëren en aanroepen. Anders resulteert de functieaanroep in een fout. Hier is een voorbeeld.
def greet(name, msg): """This function greets to the person with the provided message""" print("Hello", name + ', ' + msg) greet("Monica", "Good morning!")
Uitvoer
Hallo Monica, goedemorgen!
Hier heeft de functie greet()twee parameters.
Omdat we deze functie met twee argumenten hebben aangeroepen, werkt deze soepel en krijgen we geen foutmelding.
Als we het met een ander aantal argumenten noemen, zal de tolk een foutmelding geven. Hieronder vindt u een aanroep van deze functie met één en geen argumenten samen met hun respectievelijke foutmeldingen.
>>> greet ("Monica") # slechts één argument TypeError: greet () mist 1 vereist positioneel argument: 'msg'
>>> greet () # geen argumenten TypeError: greet () mist 2 vereiste positionele argumenten: 'naam' en 'msg'
Variabele functieargumenten
Tot nu toe hadden functies een vast aantal argumenten. In Python zijn er andere manieren om een functie te definiëren die een variabel aantal argumenten kan hebben.
Hieronder worden drie verschillende vormen van dit type beschreven.
Python-standaardargumenten
Functieargumenten kunnen standaardwaarden hebben in Python.
We kunnen een standaardwaarde aan een argument geven door de toewijzingsoperator (=) te gebruiken. Hier is een voorbeeld.
def greet(name, msg="Good morning!"): """ This function greets to the person with the provided message. If the message is not provided, it defaults to "Good morning!" """ print("Hello", name + ', ' + msg) greet("Kate") greet("Bruce", "How do you do?")
Uitvoer
Hallo Kate, goedemorgen! Hallo Bruce, hoe maakt u het?
In deze functie heeft de parameter namegeen standaardwaarde en is deze vereist (verplicht) tijdens een oproep.
Aan de andere kant heeft de parameter msgeen standaardwaarde van "Good morning!". Het is dus optioneel tijdens een gesprek. Als er een waarde wordt opgegeven, wordt de standaardwaarde overschreven.
Elk aantal argumenten in een functie kan een standaardwaarde hebben. Maar als we eenmaal een standaardargument hebben, moeten alle argumenten aan de rechterkant ook standaardwaarden hebben.
Dit betekent dat niet-standaardargumenten geen standaardargumenten kunnen volgen. Als we bijvoorbeeld de functiekop hierboven hadden gedefinieerd als:
def greet (msg = "Goedemorgen!", naam):
We zouden een foutmelding krijgen als:
SyntaxError: niet-standaardargument volgt standaardargument
Python-trefwoordargumenten
Wanneer we een functie met enkele waarden aanroepen, worden deze waarden toegewezen aan de argumenten op basis van hun positie.
In de bovenstaande functie greet(), wanneer we het bijvoorbeeld noemden greet("Bruce", "How do you do?"), wordt de waarde "Bruce"toegewezen aan de argumentnaam en op dezelfde manier "How do you do?"aan msg.
Met Python kunnen functies worden aangeroepen met trefwoordargumenten. Als we functies op deze manier aanroepen, kan de volgorde (positie) van de argumenten worden gewijzigd. De volgende aanroepen van de bovenstaande functie zijn allemaal geldig en leveren hetzelfde resultaat op.
# 2 keyword arguments greet(name = "Bruce",msg = "How do you do?") # 2 keyword arguments (out of order) greet(msg = "How do you do?",name = "Bruce") 1 positional, 1 keyword argument greet("Bruce", msg = "How do you do?")
Zoals we kunnen zien, kunnen we positionele argumenten combineren met trefwoordargumenten tijdens een functieaanroep. Maar we moeten in gedachten houden dat trefwoordargumenten positionele argumenten moeten volgen.
Het hebben van een positioneel argument na trefwoordargumenten zal resulteren in fouten. De functie roept bijvoorbeeld als volgt aan:
greet(name="Bruce","How do you do?")
Zal resulteren in een fout:
SyntaxError: niet-trefwoord arg na trefwoord arg
Python Willekeurige argumenten
Soms weten we van tevoren niet hoeveel argumenten er aan een functie worden doorgegeven. Python stelt ons in staat om met dit soort situaties om te gaan via functieaanroepen met een willekeurig aantal argumenten.
In de functiedefinitie gebruiken we een asterisk (*) voor de parameternaam om dit soort argument aan te duiden. Hier is een voorbeeld.
def greet(*names): """This function greets all the person in the names tuple.""" # names is a tuple with arguments for name in names: print("Hello", name) greet("Monica", "Luke", "Steve", "John")
Uitvoer
Hallo Monica Hallo Luke Hallo Steve Hallo John
Hier hebben we de functie aangeroepen met meerdere argumenten. Deze argumenten worden in een tuple verpakt voordat ze aan de functie worden doorgegeven. Binnen de functie gebruiken we een forlus om alle argumenten terug te halen.
