Summary  
This chapter explains how to use comparison operators (==, >, <, >=, <=) to evaluate equality and lexicographical ordering of strings and printing the Boolean results.

General domain of usage  
Alphabetical sorting of textual data

import unittest
import importlib
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 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()

        # Expected values from fixed inputs
        cls.exp_age = 19
        cls.exp_has_id = True
        cls.exp_tier = "VIP"
        cls.exp_seat_number_str = "023"
        cls.exp_zone = "A"
        cls.exp_seat_number = 23
        cls.exp_is_adult = True
        cls.exp_can_enter = True
        cls.exp_vip_perk = True
        cls.exp_member_fastlane = False
        cls.exp_seat_ok = True
        cls.exp_entry_granted = True
        cls.exp_summary = f"{cls.exp_tier}-{cls.exp_seat_number_str}-{cls.exp_zone} | age={cls.exp_age} | enter={cls.exp_entry_granted} | vip={cls.exp_vip_perk} | fastlane={cls.exp_member_fastlane}"

    # 1) Conversions group: age, has_id
    def test_conversions_group(self):
        has_age = hasattr(self.m, 'age')
        has_hasid = hasattr(self.m, 'has_id')
        type_ok = has_age and isinstance(self.m.age, int) and has_hasid and isinstance(self.m.has_id, bool)
        value_ok = has_age and has_hasid and (self.m.age == self.exp_age) and (self.m.has_id == self.exp_has_id)

        pat_age = r"""age\s*=\s*int\s*\(\s*age_str\s*\.\s*strip\s*\(\s*\)\s*\)"""
        pat_hasid = r"""has_id\s*=\s*has_id_str\s*\.\s*strip\s*\(\s*\)\s*\.\s*casefold\s*\(\s*\)\s*==\s*["']yes["']"""
        src_ok = (
            re.search(pat_age, self.src, re.DOTALL) is not None and
            re.search(pat_hasid, self.src, re.DOTALL) is not None
        )

        _dynamic_test(
            self,
            type_ok and value_ok and src_ok,
            "conversions computed correctly",
            "conversions computed incorrectly"
        )

    # 2) Parsing group: tier, seat_number_str, zone, seat_number
    def test_parsing_group(self):
        has_all = all(hasattr(self.m, v) for v in ['tier', 'seat_number_str', 'zone', 'seat_number'])
        types_ok = (
            has_all and
            isinstance(self.m.tier, str) and
            isinstance(self.m.seat_number_str, str) and
            isinstance(self.m.zone, str) and
            isinstance(self.m.seat_number, int)
        )
        values_ok = (
            has_all and
            self.m.tier == self.exp_tier and
            self.m.seat_number_str == self.exp_seat_number_str and
            self.m.zone == self.exp_zone and
            self.m.seat_number == self.exp_seat_number
        )

        pat_tier = r"""tier\s*=\s*ticket_code\s*\[\s*:\s*3\s*\]"""
        pat_numstr = r"""seat_number_str\s*=\s*ticket_code\s*\[\s*4\s*:\s*7\s*\]"""
        pat_zone = r"""zone\s*=\s*ticket_code\s*\[\s*-1\s*\]"""
        pat_seatnum = r"""seat_number\s*=\s*int\s*\(\s*seat_number_str\s*\)"""
        src_ok = all(re.search(p, self.src, re.DOTALL) is not None for p in [pat_tier, pat_numstr, pat_zone, pat_seatnum])

        _dynamic_test(
            self,
            types_ok and values_ok and src_ok,
            "ticket parsing computed correctly",
            "ticket parsing computed incorrectly"
        )

    # 3) Rules group
    def test_rules_group(self):
        names = ['is_adult','can_enter','vip_perk','member_fastlane','seat_ok','entry_granted']
        has_all = all(hasattr(self.m, v) for v in names)
        types_ok = (
            has_all and
            all(isinstance(getattr(self.m, v), bool) for v in names)
        )
        values_ok = (
            has_all and
            self.m.is_adult == self.exp_is_adult and
            self.m.can_enter == self.exp_can_enter and
            self.m.vip_perk == self.exp_vip_perk and
            self.m.member_fastlane == self.exp_member_fastlane and
            self.m.seat_ok == self.exp_seat_ok and
            self.m.entry_granted == self.exp_entry_granted
        )

        pat_adult = r"""is_adult\s*=\s*age\s*>=\s*adult_age"""
        pat_enter = r"""can_enter\s*=\s*has_id\s*and\s*is_adult"""
        pat_vip = r"""vip_perk\s*=\s*tier\s*==\s*["']VIP["']"""
        pat_fast = r"""member_fastlane\s*=\s*is_member\s*and\s*can_enter"""
        pat_range = r"""seat_ok\s*=\s*1\s*<=\s*seat_number\s*<=\s*max_seat_number"""
        pat_entry = r"""entry_granted\s*=\s*can_enter\s*and\s*seat_ok"""
        src_ok = all(re.search(p, self.src, re.DOTALL) is not None for p in [pat_adult, pat_enter, pat_vip, pat_fast, pat_range, pat_entry])

        _dynamic_test(
            self,
            types_ok and values_ok and src_ok,
            "rules computed correctly",
            "rules computed incorrectly"
        )

    # 4) Summary group
    def test_summary_group(self):
        has_summary = hasattr(self.m, 'summary')
        value_ok = has_summary and (self.m.summary == self.exp_summary)

        pat = r"""summary\s*=\s*f["']\{tier\}-\{seat_number_str\}-\{zone\}\s*\|\s*age=\{age\}\s*\|\s*enter=\{entry_granted\}\s*\|\s*vip=\{vip_perk\}\s*\|\s*fastlane=\{member_fastlane\}["']"""
        src_ok = re.search(pat, self.src, re.DOTALL) is not None

        _dynamic_test(
            self,
            value_ok and src_ok,
            "summary computed correctly",
            "summary computed incorrectly"
        )

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


test_code.py

This course is going to help you dive deeper into data types and try to work with them. Here you will learn basic operations and all ins and outs of numbers, boolean data type, and strings. This course consists of a lot of practical tasks after which you will become a skillful programmer.

Numerical data types are fundamental in Python, forming the backbone of many computational tasks. In this section, you'll dive into the essentials of working with integers and floating-point numbers, performing basic mathematical operations, and understanding the real-world applications of numerical data. You'll also explore critical concepts such as immutability and gain hands-on experience with Python’s built-in functions and tools for handling numbers effectively.

The main goal of this section is to clarify the boolean data types; it's a sub type of numeric data, but indeed it is more challenging. Since it is always better to excel in the more difficult topics, this section is a valuable part of your curriculum.

Strings are a way for us to implement your phrases in Python, that is, to give instructions to users who are the target audience of your program. Indeed, it is always better to be able to work with strings because they should be used in your code. You'll understand why soon.

Change values to the kind you need, clean text before comparing, and keep math strictly with numbers while formatting results for people to read. Mark missing data clearly and handle it on purpose, and treat human text differently from raw file or network content. The goals are fewer mistakes, reliable comparisons, consistent results, and clear, readable output.


This chapter consists of practical tasks that combine all the examined topics together with a bit of theory.

Challenge: Access & Ticket Perks Engine

Oplossing

Awesome!

Challenge: Access & Ticket Perks Engine

Oplossing

Awesome!