Summary  
This chapter demonstrates how to use the str() function to convert non-string values into strings for concatenation in code.

General domain of usage  
Formatting printed output

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 TestUserCode(unittest.TestCase):
    # Expected values based on the provided starter data
    EXP_AGE = 19
    EXP_HAS_ID = True
    EXP_TIER = "VIP"
    EXP_SEAT_NUMBER_STR = "023"
    EXP_ZONE = "A"
    EXP_SEAT_NUMBER = 23

    EXP_IS_ADULT = True
    EXP_CAN_ENTER = True
    EXP_VIP_PERK = True
    EXP_MEMBER_FASTLANE = False
    EXP_SEAT_OK = True
    EXP_ENTRY_GRANTED = True

    EXP_SUMMARY = (
        f"{EXP_TIER}-{EXP_SEAT_NUMBER_STR}-{EXP_ZONE} | "
        f"age={EXP_AGE} | enter={EXP_ENTRY_GRANTED} | "
        f"vip={EXP_VIP_PERK} | fastlane={EXP_MEMBER_FASTLANE}"
    )

    def test_age_is_declared(self):
        import user_code
        _dynamic_test(
            self,
            hasattr(user_code, "age"),
            "The `age` variable is declared.",
            "Expected `age` to be declared."
        )

    def test_has_id_is_declared(self):
        import user_code
        _dynamic_test(
            self,
            hasattr(user_code, "has_id"),
            "The `has_id` variable is declared.",
            "Expected `has_id` to be declared."
        )

    def test_conversions_values_and_types(self):
        import user_code
        try:
            age_ok = isinstance(user_code.age, int) and user_code.age == self.EXP_AGE
            has_id_ok = isinstance(user_code.has_id, bool) and user_code.has_id == self.EXP_HAS_ID
            condition = age_ok and has_id_ok
            failure = (
                f"Expected `age` to be int `{self.EXP_AGE}` and `has_id` to be bool `{self.EXP_HAS_ID}`, "
                f"but got `age={getattr(user_code, 'age', None)}` and `has_id={getattr(user_code, 'has_id', None)}`."
            )
        except Exception as e:
            condition = False
            failure = f"Could not validate `age` and `has_id` due to an error: {type(e).__name__}."
        _dynamic_test(
            self,
            condition,
            f"`age` is `{self.EXP_AGE}` (int) and `has_id` is `{self.EXP_HAS_ID}` (bool).",
            failure
        )

    def test_ticket_parts_declared(self):
        import user_code
        needed = ["tier", "seat_number_str", "zone", "seat_number"]
        missing = [v for v in needed if not hasattr(user_code, v)]
        _dynamic_test(
            self,
            len(missing) == 0,
            "Ticket parts variables are declared (`tier`, `seat_number_str`, `zone`, `seat_number`).",
            f"Expected these variables to be declared: {', '.join(missing) if missing else '(none)'}."
        )

    def test_ticket_parts_values(self):
        import user_code
        try:
            condition = (
                user_code.tier == self.EXP_TIER and
                user_code.seat_number_str == self.EXP_SEAT_NUMBER_STR and
                user_code.zone == self.EXP_ZONE and
                user_code.seat_number == self.EXP_SEAT_NUMBER
            )
            failure = (
                f"Expected tier/seat/zone/seat_number to be "
                f"`{self.EXP_TIER}`, `{self.EXP_SEAT_NUMBER_STR}`, `{self.EXP_ZONE}`, `{self.EXP_SEAT_NUMBER}`, "
                f"but got `{getattr(user_code, 'tier', None)}`, `{getattr(user_code, 'seat_number_str', None)}`, "
                f"`{getattr(user_code, 'zone', None)}`, `{getattr(user_code, 'seat_number', None)}`."
            )
        except Exception as e:
            condition = False
            failure = f"Could not validate ticket parts due to an error: {type(e).__name__}."
        _dynamic_test(
            self,
            condition,
            "Ticket parts parsed correctly.",
            failure
        )

    def test_rules_declared(self):
        import user_code
        names = ["is_adult", "can_enter", "vip_perk", "member_fastlane", "seat_ok", "entry_granted"]
        missing = [n for n in names if not hasattr(user_code, n)]
        _dynamic_test(
            self,
            len(missing) == 0,
            "All rule variables are declared.",
            f"Expected these rule variables to be declared: {', '.join(missing) if missing else '(none)'}."
        )

    def test_rules_values(self):
        import user_code
        try:
            condition = (
                user_code.is_adult == self.EXP_IS_ADULT and
                user_code.can_enter == self.EXP_CAN_ENTER and
                user_code.vip_perk == self.EXP_VIP_PERK and
                user_code.member_fastlane == self.EXP_MEMBER_FASTLANE and
                user_code.seat_ok == self.EXP_SEAT_OK and
                user_code.entry_granted == self.EXP_ENTRY_GRANTED
            )
            failure = (
                "Expected rules to be: "
                f"is_adult={self.EXP_IS_ADULT}, can_enter={self.EXP_CAN_ENTER}, vip_perk={self.EXP_VIP_PERK}, "
                f"member_fastlane={self.EXP_MEMBER_FASTLANE}, seat_ok={self.EXP_SEAT_OK}, entry_granted={self.EXP_ENTRY_GRANTED}, "
                f"but got: is_adult={getattr(user_code, 'is_adult', None)}, can_enter={getattr(user_code, 'can_enter', None)}, "
                f"vip_perk={getattr(user_code, 'vip_perk', None)}, member_fastlane={getattr(user_code, 'member_fastlane', None)}, "
                f"seat_ok={getattr(user_code, 'seat_ok', None)}, entry_granted={getattr(user_code, 'entry_granted', None)}."
            )
        except Exception as e:
            condition = False
            failure = f"Could not validate rules due to an error: {type(e).__name__}."
        _dynamic_test(
            self,
            condition,
            "Rules computed correctly.",
            failure
        )

    def test_summary_declared(self):
        import user_code
        _dynamic_test(
            self,
            hasattr(user_code, "summary"),
            "The `summary` variable is declared.",
            "Expected `summary` to be declared."
        )

    def test_summary_value(self):
        import user_code
        try:
            actual = user_code.summary
            condition = actual == self.EXP_SUMMARY
            failure = f"Expected `summary` to be `{self.EXP_SUMMARY}`, but got `{actual}`."
        except Exception as e:
            condition = False
            failure = f"Could not validate `summary` due to an error: {type(e).__name__}."
        _dynamic_test(
            self,
            condition,
            "Summary string computed correctly.",
            failure
        )


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


test_main.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 suorittamiseen 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 erikoisalalaji ja edustaa totuusarvoja. Vaikka aihe voi aluksi vaikuttaa haastavalta, Booleanien hallinta on olennaista loogisten ja tehokkaiden ohjelmien kirjoittamisessa. Tämä osio auttaa sinua soveltamaan Boolean-logiikkaa luottavaisesti käytännön ohjelmointitilanteissa.

Merkkijonot mahdollistavat tekstin käsittelyn Pythonissa, kuten viestien näyttämisen ja käyttäjän syötteen prosessoinnin. 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. Muunna arvot sopivaan tyyppiin, puhdista teksti ennen vertailua ja erottele numeeriset laskutoimitukset tekstin muotoilusta. Opit myös hallitsemaan puuttuvia tietoja tarkoituksellisesti sekä käsittelemään ihmisen luettavaa tekstiä eri tavalla kuin raakadataa, saavuttaen luotettavia, johdonmukaisia ja helposti luettavia tuloksia.

Haaste: Pääsy- ja Lippuetujen Moottori

Ratkaisu

Haaste: Pääsy- ja Lippuetujen Moottori

Ratkaisu