import unittest
import importlib
import re

def _dynamic_test(test_case, condition, success_msg, failure_msg):
    if condition:
        test_case._testMethodName = success_msg
        test_case.assertTrue(True, success_msg)
    else:
        test_case._testMethodName = failure_msg
        test_case.fail(failure_msg)

class TestUserCode(unittest.TestCase):
    @classmethod
    def setUpClass(cls):
        cls.m = importlib.import_module("user_code")
        with open("user_code.py", "r", encoding="utf-8") as f:
            cls.src = f.read()

        cls.exp_name_clean = "Ada Lovelace"
        cls.exp_has_quick = True
        cls.exp_inside_parens = "quick"
        cls.exp_o_count = 4
        cls.exp_domain = "example.com"
        cls.exp_report = f"{cls.exp_name_clean} | {cls.exp_domain} | {cls.exp_o_count}"

    def test_name_clean(self):
        ok = hasattr(self.m, "name_clean") and self.m.name_clean == self.exp_name_clean
        used_strip = re.search(r"full_name\s*\.\s*strip\s*\(\s*\)", self.src)
        _dynamic_test(self, ok and used_strip,
                      "name_clean computed correctly",
                      "name_clean computed incorrectly")

    def test_has_quick_and_o_count(self):
        ok = hasattr(self.m, "has_quick") and hasattr(self.m, "o_count")
        vals = ok and self.m.has_quick == self.exp_has_quick and self.m.o_count == self.exp_o_count
        pat_quick = re.search(r'''["']quick["']\s+in\s+sentence\s*\.\s*lower''', self.src)
        pat_count = re.search(r'''sentence\s*\.\s*lower\s*\(\s*\)\s*\.\s*count\s*\(\s*["']o["']\s*\)''', self.src)
        _dynamic_test(self, vals and pat_quick and pat_count,
                      "has_quick and o_count computed correctly",
                      "has_quick or o_count computed incorrectly")

    def test_inside_parens(self):
        ok = hasattr(self.m, "inside_parens") and self.m.inside_parens == self.exp_inside_parens
        slice_pat = re.search(r"sentence\s*\[\s*start\s*\+\s*1\s*:\s*end\s*\]", self.src)
        _dynamic_test(self, ok and slice_pat,
                      "inside_parens computed correctly",
                      "inside_parens computed incorrectly")

    def test_domain(self):
        ok = hasattr(self.m, "domain") and self.m.domain == self.exp_domain
        pat_strip = re.search(r"email\s*\.\s*strip\s*\(\s*\)\s*\.\s*lower\s*\(\s*\)", self.src)
        pat_find = re.search(r'''find\s*\(\s*["']@["']\s*\)''', self.src)
        _dynamic_test(self, ok and pat_strip and pat_find,
                      "domain computed correctly",
                      "domain computed incorrectly")

    def test_report(self):
        ok = hasattr(self.m, "report") and self.m.report == self.exp_report
        pat_f = re.search(r'''f["']\{name_clean\}.*\{SEP\}.*\{domain\}.*\{SEP\}.*\{o_count\}["']''', self.src)
        _dynamic_test(self, ok and pat_f,
                      "report computed correctly",
                      "report computed incorrectly")

if __name__ == "__main__":
    unittest.main()

test_code.py

Hanki vankka ymmärrys Pythonin keskeisistä tietotyypeistä ja opi työskentelemään niiden kanssa tehokkaasti. Tutustu numeroihin, totuusarvoihin ja merkkijonoihin käytännön harjoitusten ja esimerkkien avulla. Rakenna varmuutta perusoperaatioiden suorittamisessa ja kehitä perustaidot, joita tarvitaan selkeän ja tehokkaan Python-koodin kirjoittamiseen.

Tutustu Pythonin numeeristen tietotyyppien perusteisiin ja opi käsittelemään kokonais- ja liukulukuja. Hallitse peruslaskutoimitukset, perehdy muuttumattomuuden käsitteeseen ja saa käytännön kokemusta Pythonin sisäänrakennettujen funktioiden ja työkalujen hyödyntämisestä numeroiden käsittelyssä todellisissa tilanteissa.

Saat selkeän käsityksen Boolean-tietotyypistä, joka on numeerisen datan erikoistyyppi ja edustaa totuusarvoja. Vaikka aihe voi aluksi vaikuttaa haastavalta, Boolean-arvojen hallinta on olennaista loogisten ja tehokkaiden ohjelmien kirjoittamisessa. Tämä osio auttaa sinua soveltamaan Boolean-logiikkaa luottavaisesti todellisissa ohjelmointitilanteissa.

Merkkijonot mahdollistavat tekstin käsittelyn Pythonissa, viestien näyttämisestä käyttäjän syötteen käsittelyyn. Tässä osiossa perehdytään merkkijonojen luomiseen, muokkaamiseen ja käsittelyyn tehokkaasti. Merkkijonojen ymmärtäminen on olennaista vuorovaikutteisten ohjelmien kirjoittamisessa ja tiedon selkeässä välittämisessä koodin kautta.

Opi käsittelemään tietotyyppejä tehokkaasti varmistaaksesi ohjelmiesi tarkkuuden ja johdonmukaisuuden.
Arvojen muuntaminen sopivaan tyyppiin.
Tekstin puhdistaminen ennen vertailua.
Numeraalisten operaatioiden erottaminen tekstin muotoilusta.
Puuttuvien tietojen hallinta tarkoituksellisesti.
Ihmisten luettavaksi tarkoitetun tekstin käsittely eri tavalla kuin raakasyötteen.
Luotettavien, johdonmukaisten ja helposti luettavien tulosten saavuttaminen.

Haaste: Viipalointi- ja Hakuharjoitukset

Ratkaisu

Haaste: Viipalointi- ja Hakuharjoitukset

Ratkaisu