Summary  
This chapter demonstrates how to integrate Python’s core features—variables, control flow, functions, data structures, modules, file I/O, and error handling—into a cohesive program. It shows how to organize and combine these fundamentals to implement code that performs a complete task.

General domain of usage  
Automating data processing tasks.

import unittest
import importlib
import io
import sys
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):

    def test_receipt_title_and_divider(self):
        import user_code
        captured_output = io.StringIO()
        sys.stdout = captured_output
        importlib.reload(user_code)
        sys.stdout = sys.__stdout__

        output = captured_output.getvalue().strip().split("\\n")
        
        pattern = r"^\s*Shopping Receipt\s*$"
        divider_pattern = r"^\s*-{2,}\s*$"

        _dynamic_test(
            self,
            re.match(pattern, output[0]) and re.match(divider_pattern, output[1]),
            "The receipt title and divider line are printed correctly.",
            "Expected receipt title and divider to be printed correctly."
        )

    def test_first_item_price_correct(self):
        import user_code
        captured_output = io.StringIO()
        sys.stdout = captured_output
        importlib.reload(user_code)
        sys.stdout = sys.__stdout__

        output = captured_output.getvalue().strip().split("\\n")
        expected_price = 162 * 1.2
        pattern = rf"^\s*Item\s*1:\s*\$\s*{expected_price}\s*$"

        _dynamic_test(
            self,
            re.match(pattern, output[2]),
            f"The first item price is calculated correctly as ${expected_price}.",
            f"Expected first item price to be ${expected_price}, but got `{output[2]}`."
        )

    def test_second_item_price_correct(self):
        import user_code
        captured_output = io.StringIO()
        sys.stdout = captured_output
        importlib.reload(user_code)
        sys.stdout = sys.__stdout__

        output = captured_output.getvalue().strip().split("\\n")
        expected_price = 25 - 3
        pattern = rf"^\s*Item\s*2:\s*\$\s*{expected_price}\s*$"

        _dynamic_test(
            self,
            re.match(pattern, output[3]),
            f"The second item price is calculated correctly as ${expected_price}.",
            f"Expected second item price to be ${expected_price}, but got `{output[3]}`."
        )

    def test_subtotal_price_correct(self):
        import user_code
        captured_output = io.StringIO()
        sys.stdout = captured_output
        importlib.reload(user_code)
        sys.stdout = sys.__stdout__

        output = captured_output.getvalue().strip().split("\\n")
        expected_subtotal = (162 * 1.2) + (25 - 3)
        pattern = rf"^\s*Subtotal:\s*\$\s*{expected_subtotal}\s*$"

        _dynamic_test(
            self,
            re.match(pattern, output[5]),
            f"The subtotal price is calculated correctly as ${expected_subtotal}.",
            f"Expected subtotal price to be ${expected_subtotal}, but got `{output[5]}`."
        )

    def test_tax_price_correct(self):
        import user_code
        captured_output = io.StringIO()
        sys.stdout = captured_output
        importlib.reload(user_code)
        sys.stdout = sys.__stdout__

        output = captured_output.getvalue().strip().split("\\n")
        expected_tax = ((162 * 1.2) + (25 - 3)) * 0.08
        pattern = rf"^\s*Tax\s*$\s*8\s*%\s*$:\s*\$\s*{expected_tax}\s*$"

        _dynamic_test(
            self,
            re.match(pattern, output[6]),
            f"The tax is calculated correctly as ${expected_tax}.",
            f"Expected tax price to be ${expected_tax}, but got `{output[6]}`."
        )

    def test_receipt_footer_correct(self):
        import user_code
        captured_output = io.StringIO()
        sys.stdout = captured_output
        importlib.reload(user_code)
        sys.stdout = sys.__stdout__

        output = captured_output.getvalue().strip().split("\\n")
        
        pattern = r"^\s*Thank you for shopping!\s*$"

        _dynamic_test(
            self,
            re.match(pattern, output[8]),
            "The receipt footer is printed correctly.",
            "Expected receipt footer to be printed correctly."
        )

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


test_main.py

Python es un lenguaje de programación interpretado de alto nivel y de propósito general. A diferencia de HTML, CSS y JavaScript, que se utilizan principalmente para el desarrollo web, Python es más versátil y se puede utilizar en diversos campos, incluyendo el desarrollo de software, ciencia de datos, y el desarrollo de back-end. En este curso, explorarás los aspectos básicos de Python y, al final, ¡crearás tus propias funciones!

En esta sección, aprenderás los conceptos básicos de Python, te familiarizarás con tu espacio de trabajo, abordarás operaciones matemáticas sencillas y mostrarás tus resultados.

Bringing Python Fundamentals Together

Solución

Bringing Python Fundamentals Together

Solución