Summary  
This chapter explains how to define functions that accept an arbitrary number of positional arguments using `*args`, automatically collecting them into a tuple for flexible processing.  

General domain of usage  
Mathematical computations (e.g., summing variable sets of values)

Du kjenner allerede til **posisjonelle** og **valgfrie** argumenter. Men når en funksjon kan motta mange innverdier, eller du ikke vet dem på forhånd, kan du bruke **vilkårlige posisjonelle argumenter**. Disse lar en funksjon ta imot et hvilket som helst antall verdier.

Hvert argument kan være en hvilken som helst datastruktur (liste, dict, osv.). Vilkårlige argumenter lar deg sende så mange slike objekter som nødvendig.

Merk

For å definere vilkårlige posisjonelle argumenter, plasser en stjerne `*` foran parameternavnet. Eksempel:

# Define function with arbitrary positional arguments named values
def calculate_sum(*values):
	return sum(values)

# Test the function using different number of arguments
print(calculate_sum(1, 2, 3))
print(calculate_sum(1, 2, 3, 4))
print(calculate_sum(1, 2, 3, 4, 5))

Her samler `*values` alle sendte posisjonsargumenter i en tuple. Inne i funksjonen bruker du variabelnavnet **uten** `*`. Resultatet blir korrekt uansett hvor mange argumenter som oppgis.

Selv om hvilket som helst navn fungerer, er den vanlige og lesbare formen `*args`.

def example_function(*args):
    print(type(args))
    print(args)
    for arg in args:
        print(arg)

print("Call without arguments:")
example_function()

print("\nCall with one argument:")
example_function(1)

print("\nCall with multiple arguments:")
example_function(1, 2, 3, 'hello', [4, 5, 6])

Som vist:

* Ingen argumenter → `args` er `()`;
* Ett argument → `(1,)`;
* Flere argumenter → alle verdier vises i en tuple, f.eks. `(1, 2, 3, 'hello', [4, 5, 6])`.

`*args` oppfører seg som enhver annen tuple, og gir full fleksibilitet når du håndterer mange innverdier.


Siden `*args` bare er en tuple, kan du bruke hvilken som helst logikk på verdiene – inkludert betingelser. For eksempel, etter å ha summert alle priser, kan du sjekke totalen og bruke ulike regler avhengig av resultatet.

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 TestCalculateTotal(unittest.TestCase):
    def test_no_items_in_cart(self):
        """Checks that an empty cart returns the correct message"""
        import user_code
        try:
            result = user_code.calculate_total()
            expected_output = "Your cart is empty."
            condition = result == expected_output
            failure_message = f"For input `()`, expected `{expected_output}`, but got `{result}`."
        except AttributeError:
            condition = False
            failure_message = "The function `calculate_total` is not defined."
        _dynamic_test(self, condition, "The function correctly handles an empty cart.", failure_message)
    
    def test_no_discount(self):
        """Checks that no discount is applied for a total below $100"""
        import user_code
        try:
            result = user_code.calculate_total(20, 20, 50)
            expected_output = "Final total: $90.00"
            condition = result == expected_output
            failure_message = f"For input `(20, 20, 50)`, expected `{expected_output}`, but got `{result}`."
        except AttributeError:
            condition = False
            failure_message = "The function `calculate_total` is not defined."
        _dynamic_test(self, condition, "The function correctly calculates the total without a discount (total below $100).", failure_message)
    
    def test_ten_percent_discount(self):
        """Checks that a 10% discount is applied for a total between 100 and 200"""
        import user_code
        try:
            result = user_code.calculate_total(100, 20, 30)
            expected_output = "Final total: $135.00"
            condition = result == expected_output
            failure_message = f"For input `(100, 20, 30)`, expected `{expected_output}`, but got `{result}`."
        except AttributeError:
            condition = False
            failure_message = "The function `calculate_total` is not defined."
        _dynamic_test(self, condition, "The function correctly applies a 10% discount.", failure_message)
    
    def test_twenty_percent_discount(self):
        """Checks that a 20% discount is applied for a total greater than 200"""
        import user_code
        try:
            result = user_code.calculate_total(150, 100)
            expected_output = "Final total: $200.00"
            condition = result == expected_output
            failure_message = f"For input `(150, 100)`, expected `{expected_output}`, but got `{result}`."
        except AttributeError:
            condition = False
            failure_message = "The function `calculate_total` is not defined."
        _dynamic_test(self, condition, "The function correctly applies a 20% discount.", failure_message)

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.

Vilkårlige posisjonsargumenter

Løsning