Summary  
This chapter explains how to perform basic arithmetic operations in Python, covering binary operators (addition, subtraction, multiplication, division, floor division, modulus, exponentiation) and unary plus/minus.

General domain of usage  
Scientific computing

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()

        # Expected values
        cls.expected_total = 8 * 9           # 72
        cls.expected_shortfall = 72 - 60     # 12
        cls.expected_completed = 60 // 9     # 6
        cls.expected_unused = 60 % 9         # 6

    def test_total_minutes(self):
        """Validate total_minutes"""
        declared = hasattr(self.m, "total_minutes")
        correct_type = isinstance(getattr(self.m, "total_minutes", None), int)
        correct_value = declared and self.m.total_minutes == self.expected_total
        uses_multiplication = re.search(
            r"total_minutes\s*=\s*.*\*.*", self.src
        ) is not None

        all_ok = declared and correct_type and correct_value and uses_multiplication
        _dynamic_test(
            self,
            all_ok,
            "Total minutes calculated correctly",
            "Total minutes calculated incorrectly"
        )

    def test_shortfall(self):
        """Validate shortfall"""
        declared = hasattr(self.m, "shortfall")
        correct_type = isinstance(getattr(self.m, "shortfall", None), int)
        correct_value = declared and self.m.shortfall == self.expected_shortfall
        uses_subtraction = re.search(
            r"shortfall\s*=\s*.*-.*", self.src
        ) is not None

        all_ok = declared and correct_type and correct_value and uses_subtraction
        _dynamic_test(
            self,
            all_ok,
            "Shortfall calculated correctly",
            "Shortfall calculated incorrectly"
        )

    def test_completed_calls(self):
        """Validate completed_calls"""
        declared = hasattr(self.m, "completed_calls")
        correct_type = isinstance(getattr(self.m, "completed_calls", None), int)
        correct_value = declared and self.m.completed_calls == self.expected_completed
        uses_floor_division = re.search(
            r"completed_calls\s*=\s*.*//.*", self.src
        ) is not None

        all_ok = declared and correct_type and correct_value and uses_floor_division
        _dynamic_test(
            self,
            all_ok,
            "Completed calls calculated correctly",
            "Completed calls calculated incorrectly"
        )

    def test_unused_time(self):
        """Validate unused_time"""
        declared = hasattr(self.m, "unused_time")
        correct_type = isinstance(getattr(self.m, "unused_time", None), int)
        correct_value = declared and self.m.unused_time == self.expected_unused
        uses_modulo = re.search(
            r"unused_time\s*=\s*.*%.*", self.src
        ) is not None

        all_ok = declared and correct_type and correct_value and uses_modulo
        _dynamic_test(
            self,
            all_ok,
            "Unused time calculated correctly",
            "Unused time calculated incorrectly"
        )

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

test_code.py

Acquisire una solida comprensione dei principali tipi di dati di Python e imparare a utilizzarli in modo efficace. Esplorare numeri, booleani e stringhe attraverso esercizi pratici ed esempi concreti. Sviluppare sicurezza nell'esecuzione delle operazioni di base e acquisire le competenze fondamentali necessarie per scrivere codice Python pulito ed efficiente.

Scopri le nozioni fondamentali dei tipi di dati numerici in Python e apprendi come lavorare con numeri interi e numeri in virgola mobile. Acquisisci padronanza delle operazioni aritmetiche di base, esplora il concetto di immutabilità e ottieni esperienza pratica utilizzando le funzioni e gli strumenti integrati di Python per gestire i numeri in modo efficiente in scenari reali.

Acquisisci una comprensione chiara del tipo di dato booleano, un sottotipo specializzato dei dati numerici che rappresenta valori di verità. Sebbene possa sembrare inizialmente complesso, padroneggiare i booleani è fondamentale per scrivere programmi logici ed efficienti. Questa sezione ti aiuterà ad applicare con sicurezza la logica booleana in scenari di programmazione reali.

Le stringhe consentono di lavorare con il testo in Python, dalla visualizzazione di messaggi all'elaborazione dell'input dell'utente. Verrà illustrato come creare, modificare e manipolare le stringhe in modo efficace. La comprensione delle stringhe è fondamentale per scrivere programmi interattivi e comunicare informazioni in modo chiaro attraverso il codice.

Scopri come gestire efficacemente i tipi di dati per garantire accuratezza e coerenza nei tuoi programmi. Converti i valori nel tipo appropriato, pulisci il testo prima del confronto e separa le operazioni numeriche dalla formattazione del testo. Verrà inoltre illustrato come gestire deliberatamente i dati mancanti e trattare il testo leggibile dall'uomo in modo diverso rispetto all'input grezzo, ottenendo risultati affidabili, coerenti e di facile lettura.

Sfida: Calcolo del Tempo

Soluzione

Sfida: Calcolo del Tempo

Soluzione