Summary  
This chapter introduces the floor division (`//`) and modulus (`%`) operators in Python, explaining how floor division yields the integer quotient of a division and how modulus returns the remainder. It shows how these two operations work together to provide complete division information.

General domain of usage  
Financial planning

Questo capitolo tratta le operazioni matematiche essenziali: **divisione intera** (`//`) e **modulo** (`%`). Queste operazioni sono fondamentali per vari calcoli, in particolare nella pianificazione finanziaria e nell'allocazione delle risorse.

Watch this video for a clear, visual explanation of floor division (`//`) and modulus (`%`) operations in Python. See real-world examples and step-by-step demonstrations to reinforce your understanding of how these operators work and when to use them in practical scenarios.

### Divisione Intera (`//`)

La divisione intera, indicata dall'operatore `//`, permette di determinare quante volte un numero sta interamente in un altro.

Immagina che un'azienda abbia un budget di `38000` dollari e debba allocare fondi a diversi dipartimenti, ognuno dei quali necessita di `7000` dollari. Utilizzando la divisione intera, è possibile calcolare quanti dipartimenti possono essere finanziati completamente:

departments = 38000 // 7000
print(departments)  # Output: 5

In questo caso, l'azienda può finanziare completamente `5` dipartimenti.

La divisione (**divisione regolare**) restituisce un numero in virgola mobile, anche se sia il numeratore che il denominatore sono interi. La divisione intera (**floor division**) restituisce un risultato intero, scartando la parte frazionaria. `5 / 2` restituisce `2.5`, mentre `5 // 2` restituisce `2`.

Nota

### Modulo (`%`)

L'operazione di modulo, rappresentata dall'operatore `%`, calcola il resto dopo la divisione. Questo è utile per determinare i fondi rimanenti dopo l'allocazione delle risorse.

Continuando con lo scenario precedente, dopo aver allocato `35000` dollari a `5` dipartimenti, è possibile calcolare il budget rimanente:

remaining_budget = 38000 % 7000
print(remaining_budget)  # Output: 3000

Qui, il resto è di `3000` dollari, il che significa che l'azienda ha `3000` dollari rimasti dopo aver finanziato i dipartimenti.

### Applicazioni pratiche

**Divisione intera** utilizzata spesso in scenari che richiedono una distribuzione equa delle risorse, come la pianificazione del budget, il finanziamento di progetti o la gestione dell'inventario.

**Modulo** utile per attività come determinare le risorse residue, gestire revisioni finanziarie periodiche o calcolare valori residui nei modelli finanziari.

Padroneggiando queste operazioni, è possibile migliorare la pianificazione finanziaria e le strategie di allocazione delle risorse, rendendo il codice più efficiente ed efficace.


import unittest
import importlib
import re

# Helper function to dynamically generate test names and assertions
def _dynamic_test(test_case, condition, success_message, failure_message):
    if condition:
        test_case._testMethodName = success_message  # Rename the test for better readability
        test_case.assertTrue(True, success_message)  # Pass the test with a success message
    else:
        test_case._testMethodName = failure_message  # Rename the test with a failure description
        test_case.fail(failure_message)  # Fail the test with a failure message

class TestUserCode(unittest.TestCase):

    def setUp(self):
        # Reload the module to make sure we are testing the latest code
        self.module = importlib.import_module('user_code')
        importlib.reload(self.module)

    # Test if `completed` is declared
    def test_completed_is_declared(self):
        _dynamic_test(
            self,
            hasattr(self.module, 'completed'),
            "The `completed` variable is declared.",
            "Expected `completed` variable to be declared."
        )

    # Test if `minutes` is declared
    def test_minutes_is_declared(self):
        _dynamic_test(
            self,
            hasattr(self.module, 'minutes'),
            "The `minutes` variable is declared.",
            "Expected `minutes` variable to be declared."
        )

    # Test if `completed` is an integer
    def test_completed_is_integer(self):
        _dynamic_test(
            self,
            hasattr(self.module, 'completed') and isinstance(self.module.completed, int),
            "The `completed` is of type `int`.",
            "Expected `completed` to be of type `int`."
        )

    # Test if `minutes` is an integer
    def test_minutes_is_integer(self):
        _dynamic_test(
            self,
            hasattr(self.module, 'minutes') and isinstance(self.module.minutes, int),
            "The `minutes` is of type `int`.",
            "Expected `minutes` to be of type `int`."
        )

    # Test if `completed` has the correct value
    def test_completed_correct_value(self):
        expected_value = 60 // 7  # 60 minutes divided by 7 minutes per transaction
        _dynamic_test(
            self,
            hasattr(self.module, 'completed') and self.module.completed == expected_value,
            f"The `completed` is `{expected_value}`.",
            f"Expected `completed` to be `{expected_value}`, but got `{getattr(self.module, 'completed', 'undefined')}`."
        )

    # Test if `minutes` has the correct value
    def test_minutes_correct_value(self):
        expected_value = 60 % 7  # Remaining minutes after completing transactions
        _dynamic_test(
            self,
            hasattr(self.module, 'minutes') and self.module.minutes == expected_value,
            f"The `minutes` is `{expected_value}`.",
            f"Expected `minutes` to be `{expected_value}`, but got `{getattr(self.module, 'minutes', 'undefined')}`."
        )

    # Test if floor division `//` is used for `completed`
    def test_floor_division_used(self):
        with open('user_code.py', 'r') as file:
            user_code_source = file.read()
        _dynamic_test(
            self,
            re.search(r'completed\s*=\s*[\d\w_]+\s*//\s*[\d\w_]+', user_code_source),
            "The floor division `//` is used for `completed`.",
            "Expected floor division `//` to be used for `completed`."
        )

    # Test if modulo `%` is used for `minutes`
    def test_modulo_used(self):
        with open('user_code.py', 'r') as file:
            user_code_source = file.read()
        _dynamic_test(
            self,
            re.search(r'minutes\s*=\s*[\d\w_]+\s*%\s*[\d\w_]+', user_code_source),
            "The modulo `%` is used for `minutes`.",
            "Expected modulo `%` to be used for `minutes`."
        )

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

test_main.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 sui 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 nell'utilizzo delle funzioni e degli strumenti integrati di Python per gestire i numeri in modo efficiente in scenari reali.

Acquisire una comprensione chiara del tipo di dato Booleano, un sottotipo specializzato dei dati numerici che rappresenta valori di verità. Sebbene possa sembrare complesso inizialmente, la padronanza dei Booleani è fondamentale per scrivere programmi logici ed efficienti. Questa sezione aiuterà ad applicare con sicurezza la logica booleana a 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 tramite il codice.

Imparare a gestire efficacemente i tipi di dati per garantire accuratezza e coerenza nei programmi. Convertire i valori nel tipo appropriato, pulire il testo prima del confronto e separare le operazioni numeriche dalla formattazione del testo. Scoprire anche come gestire deliberatamente i dati mancanti e trattare il testo leggibile dall'uomo in modo diverso rispetto ai dati grezzi, ottenendo risultati affidabili, coerenti e di facile lettura.

Approfondimento sulle Tecniche Matematiche Avanzate in Python

Divisione Intera (`//`)

Modulo (`%`)

Applicazioni pratiche

Soluzione

Approfondimento sulle Tecniche Matematiche Avanzate in Python

Divisione Intera (//)

Modulo (%)

Applicazioni pratiche

Soluzione

Divisione Intera (`//`)

Modulo (`%`)