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

Ce chapitre aborde les opérations mathématiques essentielles : **division entière** (`//`) et **modulo** (`%`). Ces opérations sont cruciales pour divers calculs, notamment dans la planification financière et l’allocation des ressources.

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.

### Division entière (`//`)

La division entière, représentée par l’opérateur `//`, permet de déterminer combien de fois un nombre entier peut être contenu dans un autre.

Imaginez qu’une entreprise dispose d’un budget de `38000` dollars et doit répartir des fonds entre différents départements, chacun nécessitant `7000` dollars. En utilisant la division entière, il est possible de calculer combien de départements peuvent être entièrement financés :

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

Dans ce cas, l'entreprise peut financer entièrement `5` départements.

La division (**division classique**) retourne un nombre à virgule flottante, même si le numérateur et le dénominateur sont des entiers. La division entière (**division par plancher**) retourne un résultat entier, en supprimant la partie fractionnaire. `5 / 2` donne `2.5`, tandis que `5 // 2` donne `2`.

Remarque

### Modulo (`%`)

L'opération de modulo, représentée par l'opérateur `%`, calcule le reste après une division. Ceci est utile pour déterminer les fonds restants après l'allocation des ressources.

En poursuivant avec le scénario précédent, après avoir alloué `35000` dollars à `5` départements, vous pouvez calculer le budget restant :

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

Ici, le reste est de `3000` dollars, ce qui signifie que l'entreprise dispose de `3000` dollars après avoir financé les départements.

### Applications pratiques

**La division entière** est souvent utilisée dans des situations nécessitant une répartition équitable des ressources, telles que la budgétisation, le financement de projets ou la gestion des stocks.

**Le modulo** est utile pour des tâches comme la détermination des ressources restantes, la gestion des bilans financiers périodiques ou le calcul des valeurs résiduelles dans les modèles financiers.

La maîtrise de ces opérations permet d'améliorer la planification financière et les stratégies d'allocation des ressources, rendant votre code plus efficace et performant.


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

Acquérir une compréhension solide des principaux types de données de Python et apprendre à les manipuler efficacement. Explorer les nombres, les booléens et les chaînes de caractères à travers des exercices pratiques et des exemples concrets. Développer la confiance dans l'exécution des opérations de base et acquérir les compétences fondamentales nécessaires pour écrire un code Python propre et efficace.

Découvrez les principes fondamentaux des types de données numériques en Python et apprenez à manipuler les entiers et les nombres à virgule flottante. Maîtrise des opérations arithmétiques de base, exploration du concept d'immuabilité et mise en pratique avec les fonctions et outils intégrés de Python pour gérer efficacement les nombres dans des situations réelles.

Acquérir une compréhension claire du type de données booléen, un sous-type spécialisé des données numériques qui représente les valeurs de vérité. Bien qu'il puisse sembler difficile au début, la maîtrise des booléens est essentielle pour écrire des programmes logiques et efficaces. Cette section vous aidera à appliquer avec assurance la logique booléenne à des scénarios de programmation réels.

Les chaînes de caractères permettent de travailler avec du texte en Python, qu'il s'agisse d'afficher des messages ou de traiter des entrées utilisateur. Vous étudierez comment créer, modifier et manipuler efficacement les chaînes de caractères. La compréhension des chaînes de caractères est essentielle pour écrire des programmes interactifs et transmettre clairement des informations à travers votre code.

Apprenez à gérer efficacement les types de données afin d'assurer l'exactitude et la cohérence dans vos programmes. Convertissez les valeurs au type approprié, nettoyez le texte avant toute comparaison et séparez les opérations numériques du formatage du texte. Découvrez également comment gérer de manière délibérée les données manquantes et traiter différemment le texte lisible par l'humain des entrées brutes, pour obtenir des résultats fiables, cohérents et faciles à lire.

Approfondissement des Techniques Mathématiques Avancées en Python

Division entière (`//`)

Modulo (`%`)

Applications pratiques

Solution

Approfondissement des Techniques Mathématiques Avancées en Python

Division entière (//)

Modulo (%)

Applications pratiques

Solution

Division entière (`//`)

Modulo (`%`)