Husk at når du definerer en funksjon, kan du gjøre noen argumenter **valgfrie** ved å tilordne dem en standardverdi. Hvis den som kaller funksjonen ikke oppgir en verdi, brukes standardverdien.

```python
def add_user(name, age, role='user', status='active'):
    # Function body here
```

- `name` og `age` er **påkrevd** – må alltid oppgis;
- `role` og `status` er **valgfrie** – hvis de utelates, brukes standardverdiene.

Husk at valgfrie argumenter alltid må komme **etter** alle påkrevde argumenter.

```python
add_user('Alice', 28)           # role='user', status='active' by default
add_user('Bob', 25, role='admin', status='inactive')  # Overriding the defaults
```

def greet(name, greeting='Hello'):
    print(f'{greeting}, {name}!')

# Using only the required argument
greet('Alice')

# Providing both arguments
greet('Bob', greeting='Hi')

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 TestAddUser(unittest.TestCase):
    def setUp(self):
        """Reset users_db before each test"""
        import user_code
        user_code.users_db.clear()

    def test_successful_addition(self):
        """Checks that a new user is added to the database successfully"""
        import user_code
        try:
            result = user_code.add_user("Alice", 30)
            expected_output = "User Alice added successfully!"
            condition = result == expected_output
            failure_message = f"For input `('Alice', 30)`, expected `{expected_output}`, but got `{result}`."
        
        except AttributeError:
            condition = False
            failure_message = "The function `add_user` is not defined."
        
        _dynamic_test(self, condition, "The `add_user` function correctly adds a new user.", failure_message)

    def test_user_count_after_adding(self):
        """Checks that the number of users in the database is correct after adding a new user"""
        import user_code
        try:
            user_code.add_user("Alice", 30)
            condition = len(user_code.users_db) == 1
            failure_message = f"For input `('Alice', 30)`, expected 1 user in the `users_db`, but found {len(user_code.users_db)}."
        
        except AttributeError:
            condition = False
            failure_message = "The function `add_user` is not defined."
        
        _dynamic_test(self, condition, "The number of users in the `users_db` is correct after adding a user.", failure_message)

    def test_add_user_with_default_role_and_status(self):
        """Checks that a new user is added with the default role and status"""
        import user_code
        try:
            user_code.add_user("Alice", 30)
            new_user = user_code.users_db[0]
            condition = (new_user["role"] == "user" and new_user["status"] == "active")
            failure_message = f"For input `('Alice', 30)`, expected user data with default role and status, but got {new_user}."
        
        except AttributeError:
            condition = False
            failure_message = "The function `add_user` is not defined."
        except Exception:
            condition = False
            failure_message = "For input `('Alice', 30)`, expected user data with the default role and status, but the user was not found in `users_db`."
        
        _dynamic_test(self, condition, "The new user is added with default `role` and `status`.", failure_message)

    def test_successful_update(self):
        """Checks that an existing user's data is updated correctly"""
        import user_code
        try:
            user_code.add_user("Alice", 30)
            result = user_code.add_user("Alice", 31, role="admin", status="inactive")
            expected_output = "User Alice updated successfully!"
            condition = result == expected_output and user_code.users_db[0]["age"] == 31 and user_code.users_db[0]["role"] == "admin" and user_code.users_db[0]["status"] == "inactive"
            failure_message = f"For input ('Alice', 30), followed by ('Alice', 31, 'admin', 'inactive'), expected {expected_output} and user data update in users_db, but got {result}."
        
        except AttributeError:
            condition = False
            failure_message = "The function `add_user` is not defined."
        
        _dynamic_test(self, condition, "The `add_user` function correctly updates existing user data.", failure_message)

    def test_user_count_after_update(self):
        """Checks that the number of users in the database remains the same after updating an existing user"""
        import user_code
        try:
            user_code.add_user("Alice", 30)
            user_code.add_user("Alice", 31, role="admin", status="inactive")
            condition = len(user_code.users_db) == 1
            failure_message = f"For input ('Alice', 30), followed by ('Alice', 31, 'admin', 'inactive'), expected users_db to contain exactly 1 user, but found {len(user_code.users_db)}."
        
        except AttributeError:
            condition = False
            failure_message = "The function `add_user` is not defined."
        
        _dynamic_test(self, condition, "The number of users in the `users_db` remains the same after updating a user.", failure_message)
    
    def test_users_db_is_declared(self):
        import user_code
        _dynamic_test(
            self,
            hasattr(user_code, 'users_db'),
            "The `users_db` variable is declared.",
            "Expected `users_db` 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 fleksible funksjoner som håndterer ulike input og gir økt fleksibilitet i koden.

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 én 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 skaper konsise, énlinjers funksjoner.

Utfordring: Valgfrie Argumenter

Løsning