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

Joskus on tarpeen palauttaa **useita olioita** funktiosta. Tämä voidaan tehdä kahdella tavalla:

## Listan tai tuplen käyttäminen

Luo funktiossa lista tai tuple, joka sisältää kaikki tarvittavat oliot, ja palauta se funktion tuloksena.


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

Luoit kolme erilaista oliota funktion sisällä ja palautit listan, joka sisältää ne funktion tuloksena. Tämän jälkeen iteroit tämän listan läpi päästäksesi jokaiseen olioon käsiksi.


## Useiden arvojen palauttaminen
Voit palauttaa useita arvoja suoraan pilkuilla erotettuna. Kun funktio kutsutaan, tulokset tallennetaan erillisiin muuttujiin.

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)

Yllä olevassa koodissa palautetaan kolme muuttujaa erikseen. Tällä lähestymistavalla on tärkeää tietää palautettavien muuttujien järjestys, jotta niitä voidaan käyttää oikein koodissa.


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

Saavuta vankka ymmärrys siitä, miten funktiot muovaavat Python-ohjelmointia. Hallitse funktioiden määrittely ja kutsuminen, argumenttien käsittely, palautusarvojen hallinta sekä joustavan ja tehokkaan koodin luominen rekursion ja lambda-lausekkeiden avulla.

Tutustu siihen, mitä funktiot ovat ja miksi ne ovat olennaisia Pythonissa. Opiskele, kuinka funktioita luodaan, määritellään argumentteja, käsitellään paluuarvoja ja käytetään sisäänrakennettuja funktioita tehokkaasti.

Opi, miten positionaaliset ja valinnaiset argumentit toimivat Pythonissa. Rakenna mukautuvia funktioita, jotka käsittelevät erilaisia syötteitä ja parantavat koodisi joustavuutta.

Ymmärrä, kuinka käsitellä mielivaltaisia ja avainsana-argumentteja vaihtelevan syötteen hallitsemiseksi. Opi, miten nämä tekniikat tekevät funktioistasi dynaamisempia ja järjestelmällisempiä.

Opi, miten paluuarvot edustavat funktion tuotosarvoa. Palauta yksi tai useampi arvo, käytä None-arvoa ja tutustu generaattoreihin edistyneemmän tietovirran hallinnan saavuttamiseksi.

Avaa edistyneet funktiokäsitteet rekursion ja lambda-funktioiden avulla. Opiskele, kuinka rekursio ratkaisee toistuvia ongelmia ja kuinka lambda-lausekkeilla luodaan tiiviitä, yhdellä rivillä kirjoitettuja funktioita.

Useita Palautusarvoja

Listan tai tuplen käyttäminen

Useiden arvojen palauttaminen

Ratkaisu