Summary  
Demonstrates how functions return a single value or object, showing how to capture that return in a variable and use printing to display results.

General domain of usage  
String manipulation

Python-funktion **yksi palautusarvo** tarkoittaa, että funktio palauttaa yhden objektin tai arvon. Tämän tyyppistä palautusarvoa on käytetty aiemmissa osioissa.

def add_numbers(a, b):
    return a + b

result = add_numbers(3, 5)
print(result)  # outputs: 8

Funktio `add_numbers` ottaa kaksi argumenttia, laskee niiden summan ja palauttaa **yhden arvon** — summan. Tässä esimerkissä tulos tallennetaan muuttujaan `result` ja tulostetaan konsoliin.




Pythonin `join()`-funktio yhdistää iteroitavan, kuten listan, alkiot yhdeksi merkkijonoksi käyttäen määriteltyä erotinta. <br>Esimerkiksi `", ".join(["a", "b"])` palauttaa `"a, b"`.

Huomautus

# Example of join()
words = ["red", "green", "blue"]
combined = ", ".join(words)
print(combined)

`strip()`-metodi poistaa oletuksena merkkijonon alusta ja lopusta välilyönnit tai määritellyt merkit.
Esimerkiksi `" text ".strip()` palauttaa `"text"` ilman välilyöntejä ja `"a,b,c,".strip(",")` poistaa pilkut alusta ja lopusta, palauttaen `"a,b,c"`.

# Example of strip()
raw_text = ",a,b,c,"
cleaned_text = raw_text.strip(',')
print(cleaned_text)

import unittest
import re

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 TestMergeShoppingLists(unittest.TestCase):
    def test_empty_lists(self):
        """Checks that merging empty lists returns an empty string"""
        import user_code
        try:
            result = user_code.merge_shopping_lists()
            expected_output = ""
            condition = result == expected_output
            failure_message = f"For input `()`, expected `{expected_output}`, but got `{result}`."
        except AttributeError:
            condition = False
            failure_message = "The function `merge_shopping_lists` is not defined."
        _dynamic_test(self, condition, "The function correctly handles empty input.", failure_message)
    
    def test_single_list(self):
        """Checks that a single list is correctly converted to a string"""
        import user_code
        try:
            result = user_code.merge_shopping_lists(["Bread", "Milk", "Eggs"])
            expected_output = "Bread, Milk, Eggs"
            condition = result == expected_output
            failure_message = f"For input `(['Bread', 'Milk', 'Eggs'])`, expected `{expected_output}`, but got `{result}`."
        except AttributeError:
            condition = False
            failure_message = "The function `merge_shopping_lists` is not defined."
        _dynamic_test(self, condition, "The function correctly processes a single list.", failure_message)
    
    def test_multiple_lists(self):
        """Checks that multiple lists are correctly merged"""
        import user_code
        try:
            result = user_code.merge_shopping_lists(["Bread", "Milk"], ["Eggs", "Juice"], ["Meat"])
            expected_output = "Bread, Milk, Eggs, Juice, Meat"
            condition = result == expected_output
            failure_message = f"For input `(['Bread', 'Milk'], ['Eggs', 'Juice'], ['Meat'])`, expected `{expected_output}`, but got `{result}`."
        except AttributeError:
            condition = False
            failure_message = "The function `merge_shopping_lists` is not defined."
        _dynamic_test(self, condition, "The function correctly merges multiple lists.", failure_message)
    
    def test_lists_with_empty_strings(self):
        """Checks that lists with empty strings are correctly handled"""
        import user_code
        try:
            result = user_code.merge_shopping_lists(["Bread", ""], ["Eggs"], [""])
            expected_output = "Bread, , Eggs"
            condition = result == expected_output
            failure_message = f"For input `(['Bread', ''], ['Eggs'], [''])`, expected `{expected_output}`, but got `{result}`."
        except AttributeError:
            condition = False
            failure_message = "The function `merge_shopping_lists` is not defined."
        _dynamic_test(self, condition, "The function correctly handles lists with empty strings.", failure_message)
    
    def test_code_uses_join(self):
        """Checks that the function uses the join() method."""
        with open('user_code.py', 'r') as file:
            user_code_source = file.read()
        _dynamic_test(
            self,
            re.search(r'\.join\s*\(', user_code_source),
            "The function correctly uses the join() method.",
            "Expected the join() method to be used in the function."
        )

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.

Yksi palautusarvo

Ratkaisu