Summary  
Lambda functions are anonymous, single-expression functions defined with the `lambda` keyword for concise, on-the-spot function definitions.  

General domain of usage  
Functional programming (e.g., using lambdas in map, filter, or as callbacks)

Lambda-functies zijn anonieme functies, wat betekent dat ze geen naam hebben. Ze worden aangemaakt met het `lambda`-sleutelwoord en worden vaak gebruikt om korte functies te definiëren waarbij je direct een functie kunt specificeren.

De basis-syntaxis van een lambda-functie is als volgt:

```python
lambda arguments: expression
```

- `lambda`: het sleutelwoord dat het begin van een lambda-functiedefinitie aangeeft;
- `arguments`: de lijst met argumenten die de functie accepteert;
- `expression`: de expressie die wordt uitgevoerd wanneer de functie wordt aangeroepen. Het resultaat van de expressie wordt als waarde van de functie geretourneerd.

Het belangrijkste kenmerk van lambda-functies is hun beknopte syntaxis. Ze zijn handig wanneer je een eenvoudige functie wilt definiëren zonder veel code te schrijven.

square = lambda x: x**2
result = square(5)
print(result) 

import unittest

def _dynamic_test(test_case, condition, success_message, failure_message):
    if condition:
        test_case._testMethodName = success_message
        test_case.assertTrue(True, success_message)
    else:
        test_case._testMethodName = failure_message
        test_case.fail(failure_message)

class TestApplyTax(unittest.TestCase):
    def test_apply_tax_single_value(self):
        """Checks tax deduction on a single price"""
        import user_code
        try:
            result = user_code.apply_tax(200)
            expected_output = 174.0
            condition = result == expected_output
            failure_message = f"For input `200`, expected `{expected_output}`, but got `{result}`."
        except AttributeError:
            condition = False
            failure_message = "The function `apply_tax` is not defined."
        _dynamic_test(self, condition, "The function correctly calculates tax for a single price.", failure_message)
    
    def test_apply_tax_zero(self):
        """Checks that tax deduction on zero returns zero"""
        import user_code
        try:
            result = user_code.apply_tax(0)
            expected_output = 0.0
            condition = result == expected_output
            failure_message = f"For input `0`, expected `{expected_output}`, but got `{result}`."
        except AttributeError:
            condition = False
            failure_message = "The function `apply_tax` is not defined."
        _dynamic_test(self, condition, "The function correctly handles zero input.", failure_message)

    def test_negative_price(self):
        """Checks that negative prices are handled correctly and return 0"""
        import user_code
        result = user_code.apply_tax(-123)
        expected_output = 0
        condition = result == expected_output
        failure_message = f"For input `-123`, expected `{expected_output}`, but got `{result}`."
        _dynamic_test(self, condition, "The function correctly handles negative values.", failure_message)
    
    def test_apply_tax_is_declared(self):
        import user_code
        _dynamic_test(
            self,
            hasattr(user_code, 'apply_tax'),
            "The `apply_tax` variable is declared.",
            "Expected `apply_tax` to be declared."
        )
if __name__ == '__main__':
    unittest.main()

test_main.py

Verkrijg een grondig begrip van hoe functies de Python-programmering vormgeven. Beheers het definiëren en aanroepen van functies, het werken met argumenten, het omgaan met returnwaarden en het creëren van flexibele, efficiënte code met behulp van recursie en lambda-expressies.

Ontdek wat functies zijn en waarom ze essentieel zijn in Python. Leer hoe functies worden gemaakt, argumenten worden gedefinieerd, returnwaarden worden afgehandeld en ingebouwde functies effectief worden gebruikt.

Leer hoe positionele en optionele argumenten werken in Python. Ontwikkel aanpasbare functies die verschillende invoer verwerken en de flexibiliteit van uw code verbeteren.

Inzicht in het werken met willekeurige en sleutelwoordargumenten om variabele invoergroottes te verwerken. Begrijpen hoe deze technieken functies dynamischer en georganiseerder maken.

Ontdek hoe returnwaarden de output van een functie vertegenwoordigen. Leer hoe u één of meerdere waarden retourneert, gebruikmaakt van None en generatoren inzet voor geavanceerdere beheersing van gegevensstromen.

Ontgrendel geavanceerde functiethema's met recursie en lambda-functies. Begrijp hoe recursie herhalende problemen oplost en hoe lambda-expressies beknopte, eenregelige functies creëren.

Lambda-Functies

Oplossing

Awesome!

Lambda-Functies

Oplossing