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

Soms is het nodig om **meerdere objecten** uit een functie te retourneren. Dit kan op twee manieren:

## Gebruik van een lijst of tuple

Maak binnen de functie een lijst of tuple aan die alle benodigde objecten bevat en retourneer deze als resultaat van de functie.


# 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)

Er zijn drie verschillende objecten binnen de functie aangemaakt en een lijst met deze objecten is als uitvoer van de functie geretourneerd. Vervolgens is door deze lijst geïtereerd om elk object te benaderen.


## Gebruik van meerdere returnwaarden
Het is mogelijk om direct meerdere waarden, gescheiden door komma's, te retourneren. Wanneer de functie wordt aangeroepen, worden de resultaten in afzonderlijke variabelen opgeslagen.

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)

In de bovenstaande code worden drie variabelen afzonderlijk geretourneerd. Bij het gebruik van deze methode is het belangrijk om de volgorde van de geretourneerde variabelen te kennen, zodat ze correct in de code kunnen worden gebruikt.


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

Verkrijg een grondig begrip van hoe functies de Python-programmering vormgeven. Beheers het definiëren en aanroepen van functies, het werken met argumenten, het omgaan met returnwaarden en het creëren van flexibele, efficiënte code met behulp van recursie en lambda-expressies.

Ontdek wat functies zijn en waarom ze essentieel zijn in Python. Leer hoe functies worden gemaakt, argumenten worden gedefinieerd, returnwaarden worden afgehandeld en ingebouwde functies effectief worden gebruikt.

Leer hoe positionele en optionele argumenten werken in Python. Ontwikkel aanpasbare functies die verschillende invoer verwerken en de flexibiliteit van uw code verbeteren.

Inzicht in het werken met willekeurige en sleutelwoordargumenten om variabele invoergroottes te verwerken. Begrijpen hoe deze technieken functies dynamischer en georganiseerder maken.

Ontdek hoe returnwaarden de output van een functie vertegenwoordigen. Leer hoe u één of meerdere waarden retourneert, gebruikmaakt van None en generatoren inzet voor geavanceerdere beheersing van gegevensstromen.

Ontgrendel geavanceerde functiethema's met recursie en lambda-functies. Begrijp hoe recursie herhalende problemen oplost en hoe lambda-expressies beknopte, eenregelige functies creëren.

Meerdere Retourwaarden

Gebruik van een lijst of tuple

Gebruik van meerdere returnwaarden

Oplossing