import unittest
import user_code
import importlib
import io
from contextlib import redirect_stdout
import re

class TestTask(unittest.TestCase):
    def test_withdraw_nonlocal_usage(self):
        with open("user_code.py", "r") as f:
            code = f.read()
        _dynamic_test(
            self,
            "nonlocal" in code,
            "The inner function uses 'nonlocal' to modify the balance.",
            "The inner function does not use 'nonlocal' keyword to modify the balance.",
        )

    def test_withdrawal_sequence(self):
        import user_code
        importlib.reload(user_code)
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.bank_account()
        output = f.getvalue().strip().splitlines()
        _dynamic_test(
            self,
            len(output) == 3,
            "Three results are printed for three withdrawals.",
            f"Expected 3 output lines, got {len(output)}: {output}",
        )
        try:
            first = int(output[0].strip())
        except Exception:
            _dynamic_test(
                self,
                False,
                "First withdrawal returns new balance as integer.",
                f"First output is not an integer: {output[0]}",
            )
            return
        _dynamic_test(
            self,
            first == 800,
            "Balance after withdrawing 200 is 800.",
            f"Expected 800 after withdrawing 200, got {first}",
        )
        _dynamic_test(
            self,
            output[1].strip().lower().startswith('insufficient'),
            "Second withdrawal shows 'Insufficient funds' message.",
            f"Expected 'Insufficient funds', got: {output[1]}",
        )
        try:
            third = int(output[2].strip())
        except Exception:
            _dynamic_test(
                self,
                False,
                "Third withdrawal returns new balance as integer.",
                f"Third output is not an integer: {output[2]}",
            )
            return
        _dynamic_test(
            self,
            third == 700,
            "Balance after withdrawing 100 is 700.",
            f"Expected 700 after withdrawing 100, got {third}",
        )

    def test_balance_hidden(self):
        # Check that 'balance' is not accessible at module level
        import user_code
        importlib.reload(user_code)
        has_balance = hasattr(user_code, 'balance')
        _dynamic_test(
            self,
            not has_balance,
            "The balance variable is not accessible outside the outer function.",
            "The balance variable should not be accessible outside the outer function.",
        )

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)

def normalize_text(text):
    text = text.lower()
    text = re.sub(r"\\s{2,}", " ", text)
    text = re.sub(r"\\s*([,:?])\\s*", r"\\1 ", text)
    return text.strip()

def change_var(code: str, var_name: str, value: str) -> str:
    # Not used in this test
    return code


test_main.py

Hallitse pakkaus- ja purkutekniikat, joustavat funktioargumentit, korkeamman asteen funktiot, lambda-lausekkeet, muuttujien näkyvyysalueet, sulkeumat, iteraattorit ja dekorointifunktiot. Suunniteltu oppijoille, jotka ovat suorittaneet Pythonin peruskurssin ja haluavat kirjoittaa tehokkaampaa, ilmeikkäämpää ja monipuolisempaa koodia.

Tutustu listojen, tuplien ja sanakirjojen pakkaamisen ja purkamisen taitoon kirjoittaaksesi ilmeikkäämpää ja tehokkaampaa Python-koodia.

Syvenny korkeamman asteen funktioiden maailmaan, funktioiden välittämiseen argumentteina ja tiiviiden anonyymien funktioiden kirjoittamiseen lambda-avainsanalla.

Selvitä muuttujien näkyvyyden salaisuudet ja opi, kuinka sisäkkäiset funktiot ja sulut mahdollistavat tehokkaan kapseloinnin.

Syvenny Pythonin iteraatioprotokollaan, mukautettuihin iteraattoreihin ja generaattorifunktioihin tehokasta datankäsittelyä varten.

Challenge: Ulomman Laajuuden Muuttujien Muokkaaminen

Ratkaisu