Summary  
This chapter explains how to return multiple values from a function in Python either by packing them into a list or tuple or by returning them as comma-separated values, and shows how to unpack or iterate over those returned values.  

General domain of usage  
Data processing

Noen ganger er det nødvendig å returnere **flere objekter** fra en funksjon. Dette kan gjøres på to måter:

## Ved å bruke en liste eller tuple

Lag en liste eller tuple som inneholder alle nødvendige objekter inne i funksjonen, og returner denne som funksjonens resultat.


# Define a function
def return_multiple_objects():
    obj1 = 'Hello'
    obj2 = 42
    obj3 = [1, 2, 3]
	# Return all objects packed into list
    return [obj1, obj2, obj3]
  
# Get the list with corresponding objects
result_list = return_multiple_objects()
for obj in result_list:
	print(obj)

Du opprettet tre ulike objekter inne i funksjonen og returnerte en liste som inneholder dem som funksjonens output. Deretter itererte du gjennom denne listen for å få tilgang til hvert objekt.


## Ved å bruke flere returverdier
Du kan returnere flere verdier direkte, adskilt med komma. Når funksjonen kalles, fanges resultatene opp i separate variabler.

def return_multiple_objects():
    obj1 = "Hello"
    obj2 = 42
    obj3 = [1, 2, 3]
	# Return objects separated by comma
    return obj1, obj2, obj3

# Get the result of the function into three different values
result1, result2, result3 = return_multiple_objects()
print(result1, result2, result3)

I koden over returneres tre variabler separat. Når du bruker denne tilnærmingen, er det viktig å kjenne rekkefølgen variablene returneres i for å bruke dem korrekt i koden.

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 TestValidateRegistration(unittest.TestCase):
    def test_valid_input(self):
        """Checks that valid input passes validation."""
        import user_code
        try:
            result = user_code.validate_registration("JohnDoe", "john@example.com", "securePass")
            expected_output = (True, [])
            condition = result == expected_output
            failure_message = f"For input `('JohnDoe', 'john@example.com', 'securePass')`, expected `{expected_output}`, but got `{result}`."
        except AttributeError:
            condition = False
            failure_message = "The function `validate_registration` is not defined."
        _dynamic_test(self, condition, "The function correctly validates valid input.", failure_message)

    def test_short_username(self):
        """Checks that a username shorter than 3 characters returns an error."""
        import user_code
        try:
            result = user_code.validate_registration("jd", "john@example.com", "securePass")
            expected_output = (False, ["Username must be at least 3 characters long."])
            condition = result == expected_output
            failure_message = f"For input `('jd', 'john@example.com', 'securePass')`, expected `{expected_output}`, but got `{result}`."
        except AttributeError:
            condition = False
            failure_message = "The function `validate_registration` is not defined."
        _dynamic_test(self, condition, "The function correctly detects short usernames.", failure_message)

    def test_invalid_email(self):
        """Checks that an email without '@' returns an error."""
        import user_code
        try:
            result = user_code.validate_registration("JohnDoe", "johnexample.com", "securePass")
            expected_output = (False, ["Invalid email format."])
            condition = result == expected_output
            failure_message = f"For input `('JohnDoe', 'johnexample.com', 'securePass')`, expected `{expected_output}`, but got `{result}`."
        except AttributeError:
            condition = False
            failure_message = "The function `validate_registration` is not defined."
        _dynamic_test(self, condition, "The function correctly detects invalid email format.", failure_message)

    def test_short_password(self):
        """Checks that a password shorter than 6 characters returns an error."""
        import user_code
        try:
            result = user_code.validate_registration("JohnDoe", "john@example.com", "12345")
            expected_output = (False, ["Password must be at least 6 characters long."])
            condition = result == expected_output
            failure_message = f"For input `('JohnDoe', 'john@example.com', '12345')`, expected `{expected_output}`, but got `{result}`."
        except AttributeError:
            condition = False
            failure_message = "The function `validate_registration` is not defined."
        _dynamic_test(self, condition, "The function correctly detects short passwords.", failure_message)

    def test_multiple_errors(self):
        """Checks that multiple validation errors are returned correctly."""
        import user_code
        try:
            result = user_code.validate_registration("jd", "johnexample.com", "12345")
            expected_output = (False, [
                "Username must be at least 3 characters long.",
                "Invalid email format.",
                "Password must be at least 6 characters long."
            ])
            condition = result == expected_output
            failure_message = f"For input `('jd', 'johnexample.com', '12345')`, expected `{expected_output}`, but got `{result}`."
        except AttributeError:
            condition = False
            failure_message = "The function `validate_registration` is not defined."
        _dynamic_test(self, condition, "The function correctly handles multiple validation errors.", 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.

Flere returverdier

Ved å bruke en liste eller tuple

Ved å bruke flere returverdier

Løsning