Summary  
This chapter covers the use of anonymous one-line functions (lambda) to define concise operations with single or multiple arguments, inline conditional logic, and integration with higher-order functions like map, filter, and max.

General domain of usage  
Data transformation and filtering

Lambda-funksjoner er anonyme funksjoner, det vil si at de ikke har noe navn. De opprettes ved å bruke nøkkelordet `lambda` og brukes ofte til å definere korte funksjoner der du kan spesifisere en funksjon direkte.

Den grunnleggende syntaksen for en lambda-funksjon er som følger:

```python
lambda arguments: expression
```

- `lambda`: nøkkelordet som markerer starten på en lambda-funksjon;
- `arguments`: listen over argumenter funksjonen tar imot;
- `expression`: uttrykket som utføres når funksjonen kalles. Resultatet av uttrykket returneres som funksjonens verdi.

Hovedtrekket ved lambda-funksjoner er den konsise syntaksen. De er praktiske når du trenger å definere en enkel funksjon uten å skrive mye kode.

## Enkle og flere argumenter

En lambda-funksjon kan ta ett 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 logikk i lambda-funksjoner

Du kan bruke et ternært uttrykk for å legge til betinget logikk inne i en lambda:

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

## Bruk av lambda med innebygde funksjoner

Et vanlig bruksområde er å kombinere lambda-funksjoner med innebygde funksjoner 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å bruke `max()` inne i en lambda for å håndtere spesialtilfeller direkte i uttrykket:

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

Lambda-funksjoner egner seg best for kort, enkel uttrykkslogikk. Hvis funksjonen din krever flere linjer eller kompleks logikk, er en vanlig `def`-funksjon et bedre valg.

Merk

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 av hvordan funksjoner former Python-programmering. Bli ekspert på å definere og kalle funksjoner, arbeide med argumenter, håndtere returverdier og lage fleksibel, effektiv kode ved bruk av rekursjon og lambda-uttrykk.

Utforsk hva funksjoner er og hvorfor de er essensielle i Python. Lær hvordan du oppretter funksjoner, definerer argumenter, håndterer returverdier og bruker innebygde funksjoner effektivt.

Lær hvordan posisjonelle og valgfrie argumenter fungerer i Python. Bygg tilpasningsdyktige funksjoner som håndterer ulike input og gir økt fleksibilitet i koden din.

Forstå hvordan man arbeider med vilkårlige og navngitte argumenter for å håndtere variable mengder input. Lær hvordan disse teknikkene gjør funksjonene dine mer dynamiske og organiserte.

Utforsk hvordan returverdier representerer en funksjons output. Lær å returnere enkeltverdier eller flere verdier, bruke None, og undersøk generatorer for mer avansert kontroll av datastrøm.

Lås opp avanserte funksjonskonsepter med rekursjon og lambda-funksjoner. Lær hvordan rekursjon løser repeterende problemer og hvordan lambda-uttrykk lager konsise, énlinjers funksjoner.

Lambda-funksjoner

Enkle og flere argumenter

Betinget logikk i lambda-funksjoner

Bruk av lambda med innebygde funksjoner

Løsning