Hoe functies te definiëren in Python 3

Inleiding

A function is a block of instructions that performs an action and, once defined, can be reused. Functions make code more modular, allowing you to use the same code over and over again.

Python heeft een aantal ingebouwde functies waar je misschien al bekend mee bent, waaronder:

• print() die een object naar de terminal zal afdrukken
• int() die een tekenreeks of numeriek gegevenstype naar een geheel getalgegevenstype zal converteren
• len() die de lengte van een object retourneert

Functienamen bevatten haakjes en kunnen parameters bevatten.

In deze tutorial zullen we bespreken hoe je je eigen functies kunt definiëren om te gebruiken in je programmeerprojecten.

Vereisten

Je moet Python 3 geïnstalleerd hebben en een programmeeromgeving op je computer of server hebben opgezet. Als je nog geen programmeeromgeving hebt ingesteld, kun je de installatie- en instelgidsen raadplegen voor een lokale programmeeromgeving of voor een programmeeromgeving op je server die geschikt is voor je besturingssysteem (Ubuntu, CentOS, Debian, enz.).

Het definiëren van een functie

Laten we beginnen met het omzetten van het klassieke “Hello, World!”-programma in een functie.

We zullen een nieuw tekstbestand maken in onze teksteditor naar keuze en het programma hello.py noemen. Vervolgens zullen we de functie definiëren.

A function is defined by using the def keyword, followed by a name of your choosing, followed by a set of parentheses which hold any parameters the function will take (they can be empty), and ending with a colon.

In dit geval zullen we een functie genaamd hello() definiëren:

def hello():

Dit stelt de initiële verklaring in voor het maken van een functie.

Vanaf hier zullen we een tweede regel toevoegen met een inspringing van 4 spaties om de instructies te geven voor wat de functie doet. In dit geval zullen we Hello, World! naar de console afdrukken:

def hello():
    print("Hello, World!")

Onze functie is nu volledig gedefinieerd, maar als we het programma op dit punt uitvoeren, zal er niets gebeuren omdat we de functie niet hebben aangeroepen.

Dus, buiten ons gedefinieerde functieblok, laten we de functie aanroepen met hello():

def hello():
    print("Hello, World!")

hello()

Nu, laten we het programma uitvoeren:

python hello.py

Je zou de volgende uitvoer moeten ontvangen:

Output
Hello, World!

Functies kunnen ingewikkelder zijn dan de hello()-functie die we hierboven hebben gedefinieerd. We kunnen bijvoorbeeld for-lussen, voorwaardelijke verklaringen en meer gebruiken binnen ons functieblok.

Bijvoorbeeld, de onderstaande functie maakt gebruik van een voorwaardelijke verklaring om te controleren of de invoer voor de variabele name een klinker bevat, en gebruikt vervolgens een for-lus om over de letters in de te itereren name-string.

# Definieer functienamen()
def names():
    # Stel naamvariabele in met invoer
    name = str(input('Enter your name: '))
    # Controleer of naam een klinker bevat
    if set('aeiou').intersection(name.lower()):
        print('Your name contains a vowel.')
    else:
        print('Your name does not contain a vowel.')

    # Itereer over naam
    for letter in name:
        print(letter)

# Roep de functie aan
names()

De names()-functie die we hierboven hebben gedefinieerd, stelt een voorwaardelijke verklaring en een for-lus op, waarbij wordt getoond hoe code kan worden georganiseerd binnen een functiedefinitie. Afhankelijk van wat we willen met ons programma en hoe we onze code willen opzetten, willen we echter mogelijk de voorwaardelijke verklaring en de for-lus definiëren als twee afzonderlijke functies.

Het definiëren van functies binnen een programma maakt onze code modulair en herbruikbaar, zodat we dezelfde functies kunnen aanroepen zonder ze opnieuw te schrijven.

Werken met Parameters

Tot nu toe hebben we gekeken naar functies met lege haakjes die geen argumenten aannemen, maar we kunnen parameters definiëren in functiedefinities binnen hun haakjes.

A parameter is a named entity in a function definition, specifying an argument that the function can accept.

Laten we een klein programma maken dat parameters x, y en z aanneemt. We zullen een functie maken die de parameters bij elkaar optelt in verschillende configuraties. De sommen hiervan worden afgedrukt door de functie. Vervolgens roepen we de functie aan en geven getallen door aan de functie.

def add_numbers(x, y, z):
    a = x + y
    b = x + z
    c = y + z
    print(a, b, c)

add_numbers(1, 2, 3)

We hebben het getal 1 doorgegeven voor de parameter x, 2 voor de parameter y en 3 voor de parameter z. Deze waarden komen overeen met elke parameter in de volgorde waarin ze zijn opgegeven.

Het programma voert in feite de volgende berekeningen uit op basis van de waarden die we aan de parameters hebben doorgegeven:

a = 1 + 2
b = 1 + 3
c = 2 + 3

De functie drukt ook a, b en c af, en op basis van de bovenstaande berekeningen zouden we verwachten dat a gelijk is aan 3, b gelijk is aan 4 en c gelijk is aan 5. Laten we het programma uitvoeren:

python add_numbers.py

Output
3 4 5

Als we 1, 2 en 3 als parameters doorgeven aan de functie add_numbers(), krijgen we de verwachte output.

Parameters zijn argumenten die typisch gedefinieerd worden als variabelen binnen functiedefinities. Ze kunnen waarden toegewezen krijgen wanneer je de methode uitvoert, door de argumenten door te geven aan de functie.

Naamwoordelijke Argumenten

Naast het oproepen van parameters in volgorde, kun je bij een functieoproep gebruik maken van naamwoordelijke argumenten, waarbij de beller de argumenten identificeert aan de hand van de parameter naam.

Bij het gebruik van naamwoordelijke argumenten, kun je parameters gebruiken zonder specifieke volgorde omdat de Python-interpreter de geleverde trefwoorden zal gebruiken om de waarden aan de parameters te koppelen.

Laten we een functie maken die ons profielinformatie van een gebruiker laat zien. We zullen parameters doorgeven in de vorm van gebruikersnaam (bedoeld als een string) en volgers (bedoeld als een geheel getal).

# Definieer functie met parameters
def profile_info(username, followers):
    print("Username: " + username)
    print("Followers: " + str(followers))

In de functiedefinitie verklaring zijn gebruikersnaam en volgers opgenomen tussen de haakjes van de profiel_info() functie. Het blok van de functie print informatie over de gebruiker als strings, gebruikmakend van de twee parameters.

Nu kunnen we de functie oproepen en parameters eraan toewijzen:

def profile_info(username, followers):
    print("Username: " + username)
    print("Followers: " + str(followers))

# Roep functie aan met parameters toegewezen zoals hierboven
profile_info("sammyshark", 945)

# Roep functie aan met naamwoordelijke argumenten
profile_info(username="AlexAnglerfish", followers=342)

In de eerste functieaanroep hebben we de informatie ingevuld met een gebruikersnaam van sammyshark en volgers 945, in de tweede functieaanroep hebben we trefwoorden gebruikt door waarden toe te wijzen aan de argumentvariabelen.

Laten we het programma uitvoeren:

python profile.py

Output
Username: sammyshark
Followers: 945
Username: AlexAnglerfish
Followers: 342

De uitvoer toont ons de gebruikersnamen en het aantal volgers voor beide gebruikers.

Dit stelt ons ook in staat om de volgorde van de parameters te wijzigen, zoals in dit voorbeeld van hetzelfde programma met een andere aanroep:

def profile_info(username, followers):
    print("Username: " + username)
    print("Followers: " + str(followers))

# Verander volgorde van parameters
profile_info(followers=820, username="cameron-catfish")

Wanneer we het programma opnieuw uitvoeren met het python profile.py commando, ontvangen we de volgende uitvoer:

Output
Username: cameron-catfish
Followers: 820

Omdat de functiedefinitie dezelfde volgorde van print()-verklaringen behoudt, maakt het niet uit in welke volgorde we ze doorgeven aan de functieaanroep wanneer we trefwoorden gebruiken.

Standaardwaarden voor argumenten

We kunnen ook standaardwaarden opgeven voor een of beide van de parameters. Laten we een standaardwaarde maken voor de volgers-parameter met een waarde van 1:

def profile_info(username, followers=1):
    print("Username: " + username)
    print("Followers: " + str(followers))

Nu kunnen we de functie uitvoeren met alleen de toegewezen functienaam en het aantal volgers zal automatisch standaard op 1 staan. We kunnen het aantal volgers ook nog steeds wijzigen als we dat willen.

def profile_info(username, followers=1):
    print("Username: " + username)
    print("Followers: " + str(followers))

profile_info(username="JOctopus")
profile_info(username="sammyshark", followers=945)

Wanneer we het programma uitvoeren met het python profile.py commando, ontvangen we de volgende uitvoer:

Output
Username: JOctopus
Followers: 1
Username: sammyshark
Followers: 945

Het verstrekken van standaardparameters met waarden kan ons in staat stellen om het definiëren van waarden voor elk argument dat al een standaardwaarde heeft over te slaan.

Het retourneren van een waarde

U kunt een parameterwaarde doorgeven aan een functie, en een functie kan ook een waarde produceren.

A function can produce a value with the return statement, which will exit a function and optionally pass an expression back to the caller. If you use a return statement with no arguments, the function will return None.

Tot nu toe hebben we de print()-verklaring gebruikt in plaats van de return-verklaring in onze functies. Laten we een programma maken dat in plaats van afdrukken een variabele retourneert.

In een nieuw tekstbestand genaamd square.py zullen we een programma maken dat de parameter x kwadrateert en de variabele y retourneert. We geven een oproep uit om de variabele result af te drukken, die wordt gevormd door de functie square() uit te voeren met 3 eraan doorgegeven.

def square(x):
    y = x ** 2
    return y

result = square(3)
print(result)

We kunnen het programma uitvoeren en de output ontvangen:

python square.py

Output
9

Het gehele getal 9 wordt als output geretourneerd, wat we zouden verwachten door Python te vragen het kwadraat van 3 te vinden.

Om verder te begrijpen hoe de return-verklaring werkt, kunnen we de return-verklaring in het programma uitcommentariëren:

def square(x):
    y = x ** 2
    # return y

result = square(3)
print(result)

Laten we het programma nu opnieuw uitvoeren:

python square.py

Output
None

Zonder de return-verklaring hier te gebruiken, kan het programma geen waarde retourneren, dus de waarde wordt standaard None.

Als een ander voorbeeld kunnen we in het programma add_numbers.py hierboven de print()-verklaring vervangen door een return-verklaring.

def add_numbers(x, y, z):
    a = x + y
    b = x + z
    c = y + z
    return a, b, c

sums = add_numbers(1, 2, 3)
print(sums)

Buiten de functie stellen we de variabele sums gelijk aan het resultaat van de functie waarin 1, 2 en 3 worden ingevoerd, zoals we hierboven hebben gedaan. Vervolgens roepen we een afdruk op van de variabele sums.

Laten we het programma opnieuw uitvoeren nu het de return-verklaring heeft:

python add_numbers.py

Output
(3, 4, 5)

We ontvangen dezelfde getallen 3, 4 en 5 als uitvoer die we eerder hebben ontvangen door de print()-verklaring in de functie te gebruiken. Deze keer wordt het geleverd als een tuple omdat de return-verklaring een expressielijst heeft met minstens één komma.

Functies verlaten onmiddellijk wanneer ze een return-verklaring tegenkomen, ongeacht of ze een waarde retourneren.

def loop_five():
    for x in range(0, 25):
        print(x)
        if x == 5:
            # Stop functie bij x == 5
            return
    print("This line will not execute.")

loop_five()

Het gebruik van de return-verklaring binnen de for-lus beëindigt de functie, dus de regel die buiten de lus staat zal niet worden uitgevoerd. Als we in plaats daarvan een break-verklaring hadden gebruikt, zou alleen de lus op dat moment worden beëindigd en zou de laatste print()-regel worden uitgevoerd.

De return-verklaring verlaat een functie en kan een waarde retourneren wanneer deze met een parameter wordt uitgegeven.

Het gebruik van main() als functie

Hoewel je in Python de functie onderaan je programma kunt aanroepen en deze zal worden uitgevoerd (zoals we hierboven hebben gedaan), vereisen veel programmeertalen (zoals C++ en Java) een main-functie om uit te voeren. Het toevoegen van een main()-functie, hoewel niet vereist, kan onze Python-programma’s op een logische manier structureren die de belangrijkste componenten van het programma in één functie plaatst. Het kan onze programma’s ook gemakkelijker maken voor niet-Python-programmeurs om te lezen.

We beginnen met het toevoegen van een main()-functie aan het bovenstaande hello.py-programma. We behouden onze hello()-functie en definiëren vervolgens een main()-functie:

def hello():
    print("Hello, World!")

def main():

In de main()-functie voegen we een print()-verklaring toe om ons te laten weten dat we ons in de main()-functie bevinden. Daarnaast roepen we de hello()-functie aan binnen de main()-functie:

def hello():
    print("Hello, World!")


def main():
    print("This is the main function")
    hello()

Tenslotte roepen we onderaan het programma de main()-functie aan:

def hello():
    print("Hello, World!")

def main():
    print("This is the main function.")
    hello()

main()

Op dit punt kunnen we ons programma uitvoeren:

python hello.py

We zullen de volgende uitvoer ontvangen:

Output
This is the main function.
Hello, World!

Omdat we de hello()-functie binnen main() hebben aangeroepen en vervolgens alleen main() hebben aangeroepen om uit te voeren, werd de tekst Hello, World! slechts één keer afgedrukt, na de string die ons vertelde dat we ons in de hoofdfunctie bevonden.

Volgende gaan we werken met meerdere functies, dus het is de moeite waard om de variabelenbereik van globale en lokale variabelen te herzien. Als je een variabele definieert binnen een functieblok, kun je die variabele alleen binnen die functie gebruiken. Als je variabelen over functies heen wilt gebruiken, is het misschien beter om een ​​globale variabele te declareren.

In Python is '__main__' de naam van de scope waar toplevencode zal uitvoeren. Wanneer een programma wordt uitgevoerd vanaf standaardinvoer, een script, of vanuit een interactieve prompt, wordt zijn __name__ ingesteld op '__main__'.

Vanwege dit is er een conventie om de volgende constructie te gebruiken:

if __name__ == '__main__':
    # Code om uit te voeren wanneer dit het hoofdprogramma is

Dit stelt programma-bestanden in staat om ofwel:

• als het hoofdprogramma te worden gebruikt en wat volgt na de if-verklaring uit te voeren
• als een module te worden gebruikt en niet uit te voeren wat volgt na de if-verklaring.

Alle code die niet binnen deze verklaring staat, wordt uitgevoerd bij het uitvoeren. Als je je programma-bestand als een module gebruikt, wordt de code die niet in deze verklaring staat ook uitgevoerd bij het importeren ervan tijdens het uitvoeren van het secundaire bestand.

Laten we ons names.py programma hierboven uitbreiden en een nieuw bestand genaamd more_names.py maken. In dit programma zullen we een globale variabele declareren en onze oorspronkelijke names() functie aanpassen zodat de instructies in twee afzonderlijke functies staan.

De eerste functie, has_vowel(), zal controleren of de name-string een klinker bevat.

De tweede functie, print_letters(), zal elke letter van de name-string afdrukken.

# Declareer de globale variabele naam voor gebruik in alle functies
name = str(input('Enter your name: '))


# Definieer functie om te controleren of naam een klinker bevat
def has_vowel():
    if set('aeiou').intersection(name.lower()):
        print('Your name contains a vowel.')
    else:
        print('Your name does not contain a vowel.')


# Itereer over letters in naamstring
def print_letters():
    for letter in name:
        print(letter)

Met deze opstelling definiëren we de main() functie die een oproep zal bevatten naar zowel de has_vowel() als de print_letters() functies.

# Declareer de globale variabele naam voor gebruik in alle functies
name = str(input('Enter your name: '))


# Definieer functie om te controleren of naam een klinker bevat
def has_vowel():
    if set('aeiou').intersection(name.lower()):
        print('Your name contains a vowel.')
    else:
        print('Your name does not contain a vowel.')


# Itereer over letters in naamstring
def print_letters():
    for letter in name:
        print(letter)


# Definieer hoofdmethode die andere functies aanroept
def main():
    has_vowel()
    print_letters()

Tenslotte zullen we de if __name__ == '__main__': constructie onderaan het bestand toevoegen. Voor onze doeleinden, aangezien we alle functies die we willen uitvoeren in de main() functie hebben geplaatst, zullen we de main() functie aanroepen na deze if verklaring.

# Declareer de globale variabele naam voor gebruik in alle functies
name = str(input('Enter your name: '))


# Definieer functie om te controleren of de naam een klinker bevat
def has_vowel():
    if set('aeiou').intersection(name.lower()):
        print('Your name contains a vowel.')
    else:
        print('Your name does not contain a vowel.')


# Itereer over letters in naam string
def print_letters():
    for letter in name:
        print(letter)


# Definieer hoofdmethode die andere functies aanroept
def main():
    has_vowel()
    print_letters()


# Voer de main() functie uit
if __name__ == '__main__':
    main()

We kunnen het programma nu uitvoeren:

python more_names.py

Het programma zal dezelfde output tonen als het names.py programma, maar hier is de code meer georganiseerd en kan het op een modulaire manier worden gebruikt zonder aanpassing.

Als je geen main() functie wilde declareren, kon je het programma ook op deze manier beëindigen:

...
if __name__ == '__main__':
    has_vowel()
    print_letters()

Het gebruik van main() als een functie en de if __name__ == '__main__': verklaring kan je code op een logische manier organiseren, waardoor deze leesbaarder en modulairer wordt.

Conclusie

Functies zijn codeblokken van instructies die acties uitvoeren binnen een programma, waardoor onze code herbruikbaar en modulair wordt.

Om meer te leren over hoe je je code meer modulair kunt maken, kun je onze gids lezen over Hoe modules te schrijven in Python 3.