Summary  
This chapter covers the use of lambda functions—anonymous, inline functions defined with the `lambda` keyword—including single and multiple arguments, conditional (ternary) expressions, and how to combine them with higher-order functions like `map()`, `filter()`, and built-ins such as `max()`.

General domain of usage  
Data transformation and filtering of collections

Lambda-funktioner er anonyme funktioner, hvilket betyder, at de ikke har et navn. De oprettes ved hjælp af nøgleordet `lambda` og bruges ofte til at definere korte funktioner, hvor du kan angive en funktion direkte.

Den grundlæggende syntaks for en lambda-funktion er som følger:

```python
lambda arguments: expression
```

- `lambda`: nøgleordet, der angiver starten på en lambda-funktionsdefinition;
- `arguments`: listen over argumenter, som funktionen modtager;
- `expression`: udtrykket, der udføres, når funktionen kaldes. Resultatet af udtrykket returneres som funktionens værdi.

Den vigtigste egenskab ved lambda-funktioner er deres kompakte syntaks. De er praktiske, når du har brug for at definere en simpel funktion uden at skrive meget kode.

## Enkelt og flere argumenter

En lambda-funktion kan tage et eller flere argumenter:

# Single argument
square = lambda x: x**2
print(square(5))  # 25

# Multiple arguments
add = lambda x, y: x + y
print(add(3, 5))  # 8

## Betinget logik i lambda-funktioner

En ternær udtryk kan bruges til at tilføje betinget logik i en lambda:

is_even = lambda x: "even" if x % 2 == 0 else "odd"
print(is_even(4))  # "even"
print(is_even(7))  # "odd"

## Brug af lambda med indbyggede funktioner

Et almindeligt anvendelsesområde er at kombinere lambda-funktioner med indbyggede funktioner som `map()` og `filter()`:


prices = [100, 200, 300]

# Apply 10% discount to each price
discounted = list(map(lambda price: price * 0.9, prices))
print(discounted)  # [90.0, 180.0, 270.0]

# Keep only prices above 150
expensive = list(filter(lambda price: price > 150, prices))
print(expensive)  # [200, 300]

Du kan også bruge `max()` inde i en lambda for at håndtere edge cases direkte i udtrykket:

safe_value = lambda x: max(x, 0)  # Returns 0 if x is negative
print(safe_value(-5))  # 0
print(safe_value(10))  # 10

Funktionen `max(a, b)` sammenligner to tal og returnerer det største. Når du parrer en variabel med 0 – som i max(x, 0) – fungerer det som et sikkerhedsnet mod negative tal:
- Hvis x er positiv (f.eks. 100), returnerer `max(100, 0)` værdien 100, fordi 100 er større end 0.

- Hvis x er negativ (f.eks. -50), returnerer `max(-50, 0)` værdien 0, fordi 0 er større end -50.

Dette eliminerer behovet for en kompleks if-else-sætning, når du vil sikre, at ethvert negativt eller ugyldigt beløb straks bliver til 0.

Lambda-funktioner egner sig bedst til kort, enkeltudtrykslogik. Hvis din funktion kræver flere linjer eller kompleks logik, er en almindelig `def`-funktion et bedre valg.

Bemærk

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

Få en solid forståelse af, hvordan funktioner former Python-programmering. Opnå færdigheder i at definere og kalde funktioner, arbejde med argumenter, håndtere returværdier samt skabe fleksibel og effektiv kode ved hjælp af rekursion og lambda-udtryk.

Udforsk, hvad funktioner er, og hvorfor de er essentielle i Python. Lær, hvordan man opretter funktioner, definerer argumenter, håndterer returværdier og bruger indbyggede funktioner effektivt.

Lær hvordan positionelle og valgfrie argumenter fungerer i Python. Byg fleksible funktioner, der håndterer forskellige input og øger fleksibiliteten i din kode.

Forstå hvordan man arbejder med vilkårlige og navngivne argumenter for at håndtere variable inputstørrelser. Lær hvordan disse teknikker gør dine funktioner mere dynamiske og organiserede.

Opdag, hvordan returværdier repræsenterer en funktions output. Lær at returnere enkelt- eller flere værdier, bruge None og udforsk generatorer for mere avanceret styring af dataflow.

Lås op for avancerede funktionskoncepter med rekursion og lambda-funktioner. Lær, hvordan rekursion løser gentagne problemer, og hvordan lambda-udtryk skaber korte, énliniers funktioner.

Lambda-Funktioner

Enkelt og flere argumenter

Betinget logik i lambda-funktioner

Brug af lambda med indbyggede funktioner

Løsning