Hoe een functie in Python aan te roepen: de ultieme gids

Functies zijn een essentieel concept bij het programmeren waarmee u codeblokken kunt beheren en hergebruiken. Weten hoe je een functie in Python aanroept, is een belangrijke vaardigheid om te leren.

In deze zelfstudie leert u de basisprincipes van het aanroepen van functies, samen met enkele tips voor het schrijven van efficiënte code die gemakkelijker te begrijpen is.

Mastering-functies helpen u niet alleen om meer veelzijdige code te maken, maar stroomlijnen ook uw programmeerproces en verbeteren uw algehele efficiëntie als ontwikkelaar.

Functies hebben dezelfde onderliggende principes, en als je functies eenmaal onder de knie hebt in Python, kun je je begrip van functies uitbreiden in vergelijking met andere programmeertalen zoals Java, R, JavaScript, PHP, enz.

Inhoudsopgave

• Wat is een functie?
• Een functie definiëren in Python
  • Functie syntaxis
  • Parameters en argumenten
    • Het kwargs-argument
• Een functie aanroepen
  • Basisfunctieoproep
  • Positionele Argumenten
  • Trefwoordargumenten
• Retourneer waarden
  • Enkele retourwaarde
  • Meerdere retourwaarden
• Python-functies doorgeven als argumenten
• Geneste functies
• Lambda-functies
• Herhaling
• Veelvoorkomende fouten en probleemoplossing
• Conclusie

Wat is een functie?

Met een functie in Python kunt u herbruikbare stukjes code maken die in uw hele programma kunnen worden aangeroepen, waardoor uw code wordt vereenvoudigd en de leesbaarheid wordt verbeterd. Het voert een specifieke taak of reeks taken uit en kan meerdere keren binnen een programma worden aangeroepen. 

Een functie definiëren in Python

Er zijn twee hoofdcategorieën functies in Python:

• Door de gebruiker gedefinieerde functies: functies die een programmeur definieert om herhaling van code te voorkomen
• Ingebouwde functies : functies die door iemand anders zijn gedefinieerd en die in uw code kunnen worden gebruikt nadat u de benodigde pakketten hebt geïnstalleerd

Dit gedeelte van de Python-zelfstudie richt zich op door de gebruiker gedefinieerde functies. Je zal leren:

• Hoe een functie in Python te definiëren
• De syntaxis van de functie
• Hoe parameters en argumenten te gebruiken

Functie syntaxis

Met het def sleutelwoord, gevolgd door de functienaam en haakjes, kunt u een functie definiëren in Python. De hoofdtekst van de functie is ingesprongen en bevat de code die moet worden uitgevoerd wanneer de functie wordt aangeroepen. Een voorbeeld van een basisfunctie in Python wordt hieronder gegeven:

def greet(): print("Hallo wereld!") greet()

Het def trefwoord definieert een nieuwe functie met de naam greet. De derde regel code roept de functie aan, die de code binnen de functie uitvoert.

De printregel in de bovenstaande code is ook een functie. Als u echter in een Python 2-omgeving werkt, wordt dit gedefinieerd als een statement. Later, in Python 3, werd het veranderd van statement naar een functie.

Parameters en argumenten

Parameters zijn de tijdelijke aanduidingen in de functiedefinitie, terwijl argumenten de waarden zijn die worden doorgegeven bij het aanroepen van de functie.

Om parameters op te geven, neemt u ze op tussen haakjes van de functiedefinitie, gescheiden door komma's als er meerdere parameters zijn. Wanneer u een functie aanroept, geeft u de invoerwaarden op die argumenten worden genoemd. Het volgende voorbeeld demonstreert het definiëren van een functie waaraan twee parameters moeten doorgegeven worden:

def add_numbers(a, b): retourneer a+b

De return instructie in de hoofdtekst van de functie retourneert de optelling van de twee argumenten die erin zijn doorgegeven. Je kunt het zien als een rekenmachine, waar je waarden invoert en het gewenste resultaat terugkrijgt.

Nadat we de functie hebben gedefinieerd, kunnen we deze aanroepen met argumenten naar keuze.

add_numbers(3, 5)

Het kwargs-argument

kwargs is een afkorting voor "trefwoordargumenten" in Python. Hiermee kunt u de flexibiliteit van een functie uitbreiden door de aanroeper toe te staan ​​een willekeurig aantal trefwoordargumenten op te geven bij het aanroepen van de functie. De trefwoordargumenten worden als een woordenboek aan de functie doorgegeven.

In een functiedefinitie kunt u de dubbele asterisk- **syntaxis vóór de parameternaam gebruiken om trefwoordargumenten te accepteren.

def my_function(**kwargs): for key, value in kwargs.items(): print(f"{key} = {value}") my_function(a=1, b=2, c=3)

In dit voorbeeld kwargs zal een woordenboek zijn met de trefwoordargumenten die aan de functie zijn doorgegeven. De uitvoer wordt weergegeven in de onderstaande afbeelding:

Een functie aanroepen

Het aanroepen van een functie betekent het uitvoeren van de code in de body van de functie. Er zijn vier soorten functieaanroepen in Python:

• Basisfunctieoproep
• Bellen met positionele argumenten
• Bellen met trefwoordargumenten

Basisfunctieoproep

Een basisfunctieaanroep roept de functie aan zonder enige argumenten aan de functie door te geven. Nadat u een functie hebt gedefinieerd, kunt u deze aanroepen door de naam te gebruiken, gevolgd door haakjes.

Als de functie geen argumenten accepteert, zijn de haakjes leeg. De onderstaande code is een voorbeeld van een basisfunctie.

def welcome_message(): print("Welkom bij LuckyTemplates!") welcome_message()

Het uitvoeren van de bovenstaande code geeft de volgende uitvoer:

Positionele Argumenten

Positionele argumenten zijn het meest voorkomende type argument en ze worden aan de functie doorgegeven in dezelfde volgorde als waarin ze zijn opgegeven. Het volgende is een voorbeeld van een functieaanroep met positionele argumenten:

def welcome_message(name): print(f"Welkom bij LuckyTemplates, {name}!") welcome_message("John")

In het bovenstaande voorbeeld heeft de welcome_message()functie één argument nodig, name. Wanneer u deze functie aanroept met het argument John, wordt het bericht naast de naam afgedrukt.

De bovenstaande code geeft de volgende output:

Trefwoordargumenten

Een andere manier om argumenten aan een functie door te geven, is door trefwoordargumenten te gebruiken. Met trefwoordargumenten kunt u de naam van de parameter specificeren samen met de waarde ervan, waardoor de code leesbaarder wordt en de kans kleiner wordt dat argumenten in de verkeerde volgorde worden doorgegeven. 

In het onderstaande voorbeeld worden trefwoordargumenten gebruikt om de welcome_messagefunctie aan te roepen:

def welcome_message(name, message='Welkom bij LuckyTemplates!'): print(message, name) welcome_message(name='Alice', message='Goedemorgen')

In dit voorbeeld hebben we een functie gedefinieerd welcome_message()die twee parameters heeft, name, en message. De berichtparameter heeft een standaardargument van Welcome to LuckyTemplates!Bij het aanroepen van de functie gebruiken we trefwoordargumenten om de waarde door te geven John, wat resulteert in de uitvoerWelcome to LuckyTemplates! John.

Retourneer waarden

Wanneer u met functies werkt, wilt u vaak het resultaat van bewerkingen in de hoofdtekst van uw functie retourneren. Met retourwaarden kan een functie een resultaat terugsturen naar de beller. Door te begrijpen hoe u met enkelvoudige en meervoudige retourwaarden moet werken, kunt u de functionaliteit van uw Python-programma's verbeteren.

Enkele retourwaarde

Een enkele retourwaardefunctie retourneert één waarde van de bewerkingen in een functie.

Een voorbeeld van een enkele retourwaardefunctie wordt hieronder gegeven:

def get_greeting(naam): return "Hallo, " + naam + "!" groet = get_greeting("Alice") print(groet)

In het bovenstaande voorbeeld neemt de functie get_greetingeen naam terwijl het functieargument deze compileert en een gepersonaliseerde begroeting retourneert. De retourwaarde wordt vervolgens opgeslagen in de variabele begroeting en afgedrukt naar de console.

Meerdere retourwaarden

Soms moet u meer dan één waarde retourneren van een functie in Python. Om dit te bereiken, kunt u een tuple of een lijst gebruiken om de geretourneerde waarden in te pakken.

Hieronder volgt een voorbeeld van een functie met meerdere retourwaarden in de programmeertaal Python.

def get_name_and_age(): return ("John", 30) naam, leeftijd = get_name_and_age() print(naam) print(leeftijd)

In dit voorbeeld get_name_and_ageis een functie die een tuple retourneert met twee waarden: a name en an age.

U kunt ook een lijst met waarden uit een functie in Python retourneren . De onderstaande functie demonstreert een lijstretourwaarde van een functie.

def bereken_gebieden(hoogte, breedte): return [hoogte * breedte, (hoogte * breedte) / 2] gebied, driehoek_gebied = bereken_gebieden(10, 5) print(gebied) print(driehoek_gebied)

In dit geval neemt de functie calculate_areastwee argumenten, height, en width, en retourneert een lijst met de oppervlakte van een rechthoek en de oppervlakte van een driehoek.

Python-functies doorgeven als argumenten

Met Python kun je functies als argumenten doorgeven aan andere functies. Wanneer een functie een andere functie als argument accepteert, wordt dit een functie van hogere orde genoemd.

De onderstaande code is een voorbeeld van het doorgeven van een functie aan een andere functie in Python:

def square(x): return x * x def double(x): return x * 2 def apply_func(func, x): return func(x) result = apply_func(square, 5)

Geneste functies

Geneste functies zijn functies die zijn gedefinieerd binnen een andere functie, ook wel innerlijke functies genoemd. Deze kunnen handig zijn bij het maken van afsluitingen en modulaire code. 

Om een ​​geneste functie te maken, definieert u eenvoudig een functie binnen een andere functie:

def outer_function(x, y): def inner_function(z): return x + y + z result = inner_function(3) return result # Roep de outer functie aan print(outer_function(1, 2))

In het bovenstaande voorbeeld wordt de inner_function gedefinieerd binnen de outer_function. De binnenste functie heeft toegang tot de variabelen van de buitenste functie, waardoor deze er bewerkingen op kan uitvoeren.

Lambda-functies

Lambda-functies, ook wel anonieme functies genoemd, zijn een manier om kleine functies voor eenmalig gebruik in Python te maken. In data science-projecten werk je vaak met Lambda-functies voor het maken van efficiënte datastructuren en pijplijnen.

Om een ​​lambda-functie te maken, kunt u het trefwoord lambda gebruiken, gevolgd door een lijst met argumenten, een dubbele punt en vervolgens een uitdrukking. De expressie is wat de lambda-functie zal retourneren zodra deze wordt aangeroepen. Het volgende is een voorbeeld van de lambda-functie in Python:

optellen = lambda a, b: a + b resultaat = optellen(3, 4) print(resultaat) # Uitvoer: 7

In het bovenstaande voorbeeld hebben we een lambda-functie gemaakt die twee argumenten ( a en b) nodig heeft en hun som retourneert. We hebben deze lambda-functie toegewezen aan een variabele met de naam add.

Lambda kan nuttig zijn in de volgende scenario's:

• Als argumenten voor functies van hogere orde zoals map(), filter() en sorted().
• Als sleutelfuncties bij het sorteren van lijsten of woordenboeken.

Het volgende voorbeeld demonstreert het gebruik van hogere orde functie filter() met lambda:

getallen = [1, 2, 3, 4, 5, 6, 7, 8, 9] even_getallen = lijst(filter(lambda x: x % 2 == 0, getallen)) print(even_getallen) # Uitvoer: [2, 4, 6, 8]

In dit voorbeeld hebben we een lambda-functie gebruikt om de filtercriteria voor de filter()-functie te definiëren. De functie lambda controleert of een getal even is en de functie filter() retourneert een nieuwe lijst met alleen de even getallen.

Bekijk de onderstaande video om een ​​voorbeeld te zien van hoe functies nuttig kunnen zijn in verschillende data science-scenario's:

Herhaling

Recursie is een techniek bij het programmeren waarbij een functie zichzelf aanroept. Dit kan een handige manier zijn om complexe problemen op te lossen door ze op te splitsen in kleinere, identieke deelproblemen.

Bij het maken van een recursieve functie moet u twee dingen in gedachten houden: het basisgeval en het recursieve geval. 

• Het basisscenario is de voorwaarde die de recursie stopt
• Het recursieve geval is waar de functie zichzelf aanroept. Het recursieve geval fungeert als een iterator voor de functie

Het volgende voorbeeld demonstreert recursieve functies in Python:

def faculteit(n): als n == 1: return 1 return n * faculteit(n - 1) faculteit(5)

In dit voorbeeld is de basiscase when n == 1en retourneert de functie 1. Het recursieve geval doet zich voor wanneer n niet gelijk is aan 1, en de functie roept zichzelf aan met n - 1.

Veelvoorkomende fouten en probleemoplossing

Als u een beginnende programmeur bent, zult u vaak fouten tegenkomen bij het implementeren van functies zoals recursieve en lambda-functies. In de volgende secties worden enkele veelvoorkomende fouten en tips voor het oplossen van problemen besproken om u te helpen deze efficiënt op te lossen.

1. TypeError: een vereist argument ontbreekt : deze fout treedt op wanneer u niet het juiste aantal argumenten opgeeft dat de functie verwacht.

def my_function(fname, lname): print(fname, lname) # Correcte aanroep my_function("John", "Doe") # Geeft een foutmelding my_function("John")

Om deze fout op te lossen, moet u ervoor zorgen dat u het juiste aantal argumenten aan uw functie doorgeeft.

2. TypeError: niet-ondersteund operandtype . Deze fout kan optreden wanneer u een operator probeert te gebruiken met incompatibele typen.

def add_number(a, b): return a + b # Correct call result = add_number(5, 3) print(result) # Geeft een fout als gevolg van onjuiste argumenten result = add_number("5", 3) print(result)

Om deze fout op te lossen, controleert u of uw functies met de juiste gegevenstypen te maken hebben en kunt u indien nodig typecasting overwegen

3. NameError: naam 'functie_naam' is niet gedefinieerd : deze fout suggereert dat de functie niet is gedefinieerd voordat deze wordt aangeroepen. 

# Correcte volgorde def greet(): print("Hallo, daar!") greet() # Onjuiste volgorde vaarwel() def vaarwel(): print("Tot ziens!")

Om deze fout op te lossen, moet u ervoor zorgen dat uw functie correct is gedefinieerd en dat u deze na de definitie aanroept.

Conclusie

Om samen te vatten en u te helpen uw begrip te verstevigen, vatten de volgende punten de belangrijkste aspecten samen van het aanroepen van functies in Python:

• Om een ​​functie aan te roepen, gebruikt u de functienaam gevolgd door haakjes (bijvoorbeeld function_name()).
• Als de functie argumenten accepteert, zet deze dan tussen haakjes (bijv. function_name(arg1, arg2)).
• U kunt uw eigen functies maken met behulp van het sleutelwoord def, waarbij u het bereik van de functie en eventuele vereiste argumenten definieert.
• Wanneer u een functie aanroept die een waarde retourneert, kunt u het resultaat toewijzen aan een variabele voor later gebruik (bijv. result = function_name(args)).