Python-functieargumenten

In Python kun je een functie definiëren die een variabel aantal argumenten nodig heeft. In dit artikel leert u dergelijke functies te definiëren met behulp van standaardargumenten, trefwoorden en willekeurige argumenten.

Video:Python-functieargumenten:positioneel, trefwoorden en standaard

Argumenten

In het onderwerp door de gebruiker gedefinieerde functie hebben we geleerd hoe een functie te definiëren en aan te roepen. 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

Hello Monica, Good morning!

Hier de functie greet() heeft 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 aanroepen, geeft de interpreter een foutmelding. Hieronder vindt u een aanroep van deze functie met één en geen argumenten samen met hun respectievelijke foutmeldingen.

>>> greet("Monica")    # only one argument
TypeError: greet() missing 1 required positional argument: 'msg'

>>> greet()    # no arguments
TypeError: greet() missing 2 required positional arguments: 'name' and 'msg'

Argumenten voor variabele functies

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 aannemen.

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 met behulp van de toewijzingsoperator (=). 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

Hello Kate, Good morning!
Hello Bruce, How do you do?

In deze functie wordt de parameter name heeft geen standaardwaarde en is vereist (verplicht) tijdens een gesprek.

Aan de andere kant, de parameter msg heeft een standaardwaarde van "Good morning!" . Het is dus optioneel tijdens een gesprek. Als er een waarde is 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 = "Good morning!", name):

We zouden een foutmelding krijgen als:

SyntaxError: non-default argument follows default argument

Python-zoekwoordargumenten

Wanneer we een functie met enkele waarden aanroepen, worden deze waarden toegewezen aan de argumenten op basis van hun positie.

Bijvoorbeeld in de bovenstaande functie greet() , toen we het noemden als greet("Bruce", "How do you do?") , de waarde "Bruce" wordt toegewezen aan het argument naam en zo ook "How do you do?" naar bericht .

Met Python kunnen functies worden aangeroepen met behulp van 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 geven hetzelfde resultaat.

# 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 mengen met trefwoordargumenten tijdens een functieaanroep. Maar we moeten in gedachten houden dat zoekwoordargumenten positionele argumenten moeten volgen.

Het hebben van een positioneel argument na trefwoordargumenten zal tot fouten leiden. Bijvoorbeeld de functie-aanroep als volgt:

greet(name="Bruce","How do you do?")

Zal resulteren in een fout:

SyntaxError: non-keyword arg after keyword arg

Python Willekeurige Argumenten

Soms weten we niet van tevoren hoeveel argumenten er aan een functie worden doorgegeven. Python stelt ons in staat om met dit soort situaties om te gaan door middel van 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

Hello Monica
Hello Luke
Hello Steve
Hello John

Hier hebben we de functie met meerdere argumenten aangeroepen. Deze argumenten worden verpakt in een tuple voordat ze worden doorgegeven aan de functie. Binnen de functie gebruiken we een for loop om alle argumenten terug te halen.