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

Este curso te ayudará a profundizar en los tipos de datos y a trabajar con ellos. Aquí aprenderás operaciones básicas y todos los aspectos de los números, el tipo de dato booleano y las cadenas de texto. El curso incluye numerosas tareas prácticas tras las cuales te convertirás en un programador competente.

Los tipos de datos numéricos son fundamentales en Python y constituyen la base de muchas tareas computacionales. En esta sección, se abordan los aspectos esenciales del trabajo con enteros y números de punto flotante, la realización de operaciones matemáticas básicas y la comprensión de las aplicaciones prácticas de los datos numéricos. También se exploran conceptos clave como la inmutabilidad y se adquiere experiencia práctica con las funciones y herramientas integradas de Python para gestionar números de manera eficaz.

El objetivo principal de esta sección es aclarar los tipos de datos booleanos; es un subtipo de datos numéricos, pero en realidad es más complejo. Dado que siempre es mejor destacar en los temas más difíciles, esta sección es una parte valiosa de tu plan de estudios.

Las cadenas de texto permiten implementar frases en Python, es decir, proporcionar instrucciones a los usuarios que son el público objetivo de su programa. De hecho, siempre es preferible trabajar con cadenas de texto, ya que deben utilizarse en su código. Pronto comprenderá el motivo.

Cambiar los valores al tipo necesario, limpiar el texto antes de comparar y mantener las operaciones matemáticas estrictamente con números mientras se formatean los resultados para su lectura. Marcar los datos faltantes de manera clara y gestionarlos intencionadamente, y tratar el texto humano de forma diferente al contenido bruto de archivos o redes. Los objetivos son reducir errores, obtener comparaciones fiables, resultados consistentes y una salida clara y legible.

Este capítulo consiste en tareas prácticas que combinan todos los temas examinados junto con un poco de teoría.

Desafío: Motor de Acceso y Beneficios de Entradas

Solución

Awesome!

Desafío: Motor de Acceso y Beneficios de Entradas

Solución