Muista, että rekursiivinen funktio ratkaisee ongelman kutsumalla itseään yksinkertaisemmalla syötteellä, kunnes saavutetaan perusehto, joka pysäyttää rekursion:





def list_sum(numbers):
    if not numbers:                            # Base case
        return 0
    return numbers[0] + list_sum(numbers[1:]) # Recursive case

Huomaa, että jokainen rekursiivinen kutsu käsittelee **pienempää versiota** syötteestä — tässä tapauksessa listaa ilman ensimmäistä alkiota. Sama lähestymistapa toimii myös merkkijonojen käsittelyssä merkki kerrallaan.


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 TestFormatPhoneNumber(unittest.TestCase):

    def test_parentheses_and_spaces(self):
        import user_code
        try:
            result = user_code.format_phone_number("(123) 456-7890")
            expected = "1234567890"
            condition = result == expected
            failure_message = f"Expected `{expected}` for `'(123) 456-7890'`, but got `{result}`."
        except AttributeError:
            condition = False
            failure_message = "The function `format_phone_number` is not defined."
        _dynamic_test(self, condition, f"The `format_phone_number` correctly handles parentheses and spaces.", failure_message)

    def test_dashes_and_plus(self):
        import user_code
        try:
            result = user_code.format_phone_number("  +1-800-555-0199  ")
            expected = "18005550199"
            condition = result == expected
            failure_message = f"Expected `{expected}` for `'  +1-800-555-0199  '`, but got `{result}`."
        except AttributeError:
            condition = False
            failure_message = "The function `format_phone_number` is not defined."
        _dynamic_test(self, condition, "The `format_phone_number` correctly handles dashes and plus signs.", failure_message)

    def test_dots(self):
        import user_code
        try:
            result = user_code.format_phone_number("987.654.3210")
            expected = "9876543210"
            condition = result == expected
            failure_message = f"Expected `{expected}` for `'987.654.3210'`, but got `{result}`."
        except AttributeError:
            condition = False
            failure_message = "The function `format_phone_number` is not defined."
        _dynamic_test(self, condition, "The `format_phone_number` correctly handles dots.", failure_message)

    def test_empty_string(self):
        import user_code
        try:
            result = user_code.format_phone_number("")
            expected = ""
            condition = result == expected
            failure_message = f"Expected an empty string for an empty input, but got `{result}`."
        except AttributeError:
            condition = False
            failure_message = "The function `format_phone_number` is not defined."
        _dynamic_test(self, condition, "The `format_phone_number` correctly returns an empty string for empty input.", failure_message)

    def test_recursion_used(self):
        import user_code
        import inspect
        try:
            source = inspect.getsource(user_code.format_phone_number)
            condition = "format_phone_number(" in source.split("def format_phone_number")[1]
            failure_message = "Expected `format_phone_number` to call itself recursively."
        except AttributeError:
            condition = False
            failure_message = "The function `format_phone_number` is not defined."
        _dynamic_test(self, condition, "The `format_phone_number` function uses recursion.", 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.

Haaste: Puhelinnumeron muotoilu

Ratkaisu