Functies in Python

Dit artikel legt functies in Python uit.

YouTube Video

Functies in Python

Functies in Python zijn een essentiële functie om herbruikbare codeblokken te definiëren, zodat je je programma kunt organiseren en vereenvoudigen door ze naar behoefte aan te roepen. Het gebruik van functies kan de leesbaarheid van de code verbeteren en voldoet aan het DRY-principe (Don't Repeat Yourself, vermijd het meerdere keren schrijven van dezelfde code).

Functies definiëren

Functies worden gedefinieerd met behulp van het sleutelwoord def. De basis syntax is als volgt:.

1def function_name(arg1, arg2, ..., argN):
2    """docstring (A brief description of the function)"""
3    processing
4    return return_value

Om bijvoorbeeld een functie te definiëren die twee getallen optelt, zou je schrijven:.

1def add(x, y):
2    """A function that adds two numbers and returns the result"""
3    return x + y

Functies aanroepen

Een gedefinieerde functie kan als volgt worden aangeroepen en gebruikt:.

1result = add(3, 4)
2print(result)  # Output: 7

Componenten van een functie

1. Function name

   • De naam van de functie, gebruikt bij het aanroepen.

2. **Argumenten (parameters) *

   • De variabele namen die de gegevens ontvangen die zijn doorgegeven op het moment van de oproep. Je kunt nul of meer argumenten definiëren.

3. **Documentatiestring (docstring) *

   • Een tekenreeks die het doel en het gebruik van de functie beschrijft. Optioneel.

4. Function Body

   • Een ingesprongen blok waar de instructies die door de functie worden uitgevoerd zijn geschreven.

5. *Terugkeerwaarde *

   • De waarde die aan de beller werd teruggegeven met behulp van de verklaring "request". Als return wordt weggelaten, wordt standaard None geretourneerd.

Types van argumenten

In Python zijn er verschillende soorten argumenten.

1. *Positionele argumenten *
   • De gebruikelijke manier om argumenten door te geven aan een functie.
2. Standaard argumenten
   • Standaardwaarden toewijzen aan argumenten zodat ze kunnen worden weggelaten bij het aanroepen van de functie.

1def greet(name, message="Hello"):
2    print(f"{message}, {name}")
3
4greet("Alice")  # "Hello, Alice"
5greet("Bob", "Good morning")  # "Good morning, Bob"

3. Variabele argumenten
   • "Args ontvangt meerdere positionele argumenten als een tupel, en Kwargs ontvangt ze als een woordenboek.

1def func(*args, **kwargs):
2    print("args:", args)
3    print("kwargs:", kwargs)
4
5func(1, 2, 3, a=4, b=5)
6# Output:
7# args: (1, 2, 3)
8# kwargs: {'a': 4, 'b': 5}

Door functies correct te gebruiken, kun je Python-programma's effectiever en efficiënter schrijven.

Lambda-functies in Python

In Python worden lambda-functies gebruikt om anonieme, beknopte functies te definiëren. In tegenstelling tot functies die worden gedefinieerd met het normale sleutelwoord def, kunt u met lambda korte, enkelregelige functies maken. Hier zullen we lambda-functies in Python in detail uitleggen.

Basisprincipes van lambda-functies

lambda-functies, ook wel anonieme functies genoemd, worden gebruikt om tijdelijke functies te definiëren zonder naam, zoals de naam al doet vermoeden. De basis syntax is als volgt:.

1lambda arguments: expression

• Argumenten Wat?
  • De argumenten van een functie specificeren. Meerdere argumenten kunnen worden gespecificeerd, gescheiden door komma's.
• Expressie Wat?
  • Een op de argumenten gebaseerde uitdrukking. Het resultaat van de expressie wordt de retourwaarde van de functie.

Bijvoorbeeld, de volgende code definieert en voert een lambda-functie uit die twee getallen optelt.

1add = lambda x, y: x + y
2print(add(5, 3))  # Output: 8

In dit voorbeeld is lambda x, y: x + y een lambda-functie die twee argumenten, x en y, accepteert en hun som retourneert.

Toepassingen van lambda-functies

lambda-functies zijn nuttig in situaties waarin je ter plekke een eenvoudige functie moet definiëren. Ze komen vooral veel voor in de volgende gevallen:.

1. Wanneer ze als argumenten worden doorgegeven aan functies

   • Het is nuttig in hogere-orde-functies (functies die andere functies als argumenten nemen) bij het doorgeven van korte, tijdelijke functies.

2. Bij het specificeren van sleutels voor het sorteren van lijsten

   • Ze zijn handig voor het specificeren van sorteercriteria (sleutels) in functies zoals sort() of sorted().

Voorbeeldgebruik in hogere-ordefuncties

Typische voorbeelden van hogere-ordefuncties zijn map(), filter() en reduce(). Deze functies nemen andere functies als argumenten en passen ze toe op sequenties zoals lijsten.

1numbers = [1, 2, 3, 4, 5]
2squared = list(map(lambda x: x ** 2, numbers))
3print(squared)  # Output: [1, 4, 9, 16, 25]

In dit voorbeeld wordt een lambda-functie doorgegeven aan de map()-functie om elk getal in een lijst te kwadrateren.

Voorbeelden van het gebruik van lijsten sorteren

De lambda-functie kan soms worden gebruikt om een aangepaste sleutel op te geven bij het sorteren van een lijst. Bijvoorbeeld, de volgende code sorteert een lijst met tuples op basis van het tweede element.

1pairs = [(1, 'one'), (2, 'two'), (3, 'three'), (4, 'four')]
2pairs.sort(key=lambda pair: pair[1])
3print(pairs)
4# Output: [(4, 'four'), (1, 'one'), (3, 'three'), (2, 'two')]

In dit voorbeeld wordt een lambda-functie gebruikt om de tuples te sorteren op basis van hun tweede element (een string).

filter() en lambda

De functie filter() wordt gebruikt om elementen in een lijst (of andere iterables) te filteren op basis van een bepaalde voorwaarde.

1numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9]
2even_numbers = list(filter(lambda x: x % 2 == 0, numbers))
3print(even_numbers)  # Output: [2, 4, 6, 8]

In dit voorbeeld worden even getallen in een lijst gefilterd om een nieuwe lijst te genereren.

lambda en reduce()

De functie reduce() wordt gebruikt om een lijst terug te brengen naar één enkele waarde. Het kan eenvoudig worden geïmplementeerd met behulp van een lambda-functie.

1from functools import reduce
2
3numbers = [1, 2, 3, 4, 5]
4product = reduce(lambda x, y: x * y, numbers)
5print(product)  # Output: 120

In dit voorbeeld worden alle elementen in de lijst met elkaar vermenigvuldigd om een resultaat te verkrijgen.

Vermijd het gebruik van complexe lambda-functies

Het voordeel van lambda-functies is hun beknoptheid, maar ze worden moeilijker leesbaar wanneer ze worden gebruikt voor complexe logica. Daarom is het geschikt om ze te gebruiken voor eenvoudige operaties die in één regel kunnen worden uitgedrukt. Voor complexe operaties is het definiëren van een functie met def leesbaarder en beter onderhoudbaar.

Bijvoorbeeld, je moet het gebruik van complexe lambda-functies zoals de onderstaande vermijden.

1# Complex and hard-to-read lambda function
2complex_func = lambda x, y: (x * 2 + y) if x > y else (x + y * 2)

In dit geval is het beter een functie te gebruiken die is gedefinieerd met def, zoals hieronder getoond.

1def complex_func(x, y):
2    if x > y:
3        return x * 2 + y
4    else:
5        return x + y * 2

Conclusie

lambda-functies in Python zijn een handig hulpmiddel voor het definiëren van tijdelijke, korte functies. Ze worden vaak gebruikt in hogere-orde-functies of lijstbewerkingen om specifieke voorwaarden beknopt te definiëren. Echter, lambda-functies moeten beperkt blijven tot eenvoudige taken, waarbij def-functies de voorkeur hebben voor complexe logica.

Je kunt het bovenstaande artikel volgen met Visual Studio Code op ons YouTube-kanaal. Bekijk ook het YouTube-kanaal.

YouTube Video