Summary  
This chapter covers Python’s floor division (//), modulus (%) and exponentiation (**) operators for integer division, remainder calculation, and power operations, demonstrating their use in code with printing.

General domain of usage  
Scientific computing

Python provides several additional math operations, including floor division (`//`) for integer division, modulus (`%`) to find the remainder after division, and exponentiation (`**`) for raising a number to a power.

# Floor division
print(18 // 4)

# Remainder of the division
print(18 % 4)

# Raising to the power
print(18 ** 4)

These mathematical operations may seem confusing at first, especially with division and related operators, but they're actually quite simple.

Floor division gives the whole number result of division, while the remainder shows what's left. Exponentiation is multiplying a number by itself repeatedly.

import unittest
import importlib
import io
import re
import sys

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_floor_division_present(self):
        with open('user_code.py', 'r') as file:
            user_code_source = file.read()

        floor_div_check = re.search(r'250\s*//\s*6', user_code_source)

        _dynamic_test(
            self,
            floor_div_check is not None,
            "The floor division operation `250 // 6` is present.",
            "Expected the floor division operation `250 // 6` to be present."
        )

    def test_modulus_operation_present(self):
        with open('user_code.py', 'r') as file:
            user_code_source = file.read()

        modulus_check = re.search(r'250\s*%\s*6', user_code_source)

        _dynamic_test(
            self,
            modulus_check is not None,
            "The modulus operation `250 % 6` is present.",
            "Expected the modulus operation `250 % 6` to be present."
        )

    def test_floor_division_output_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")

        _dynamic_test(
            self,
            output[0] == "41",
            "The correct result `41` is printed for floor division.",
            f"Expected `41` to be printed, but got `{output[0]}`."
        )

    def test_modulus_output_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")

        _dynamic_test(
            self,
            output[1] == "4",
            "The correct result `4` is printed for modulus.",
            f"Expected `4` to be printed, but got `{output[1]}`."
        )

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


test_main.py

Python est un langage de programmation interprété de haut niveau à usage général. Contrairement à HTML, CSS et JavaScript, qui sont principalement utilisés pour le développement web, Python est polyvalent et peut être utilisé dans divers domaines, y compris le développement logiciel, la science des données et le développement back-end. Dans ce cours, vous explorerez les aspects fondamentaux de Python, et à la fin, vous créerez vos propres fonctions !

Plongez dans les bases de Python, explorez votre espace de travail et effectuez des opérations mathématiques simples. Apprenez à écrire du code lisible en utilisant des commentaires et à gérer des expressions mathématiques à la fois simples et avancées tout en affichant vos résultats.

Apprenez à stocker et gérer des données en Python en travaillant avec des nombres, du texte et des variables. Comprenez comment attribuer des valeurs, suivre les conventions de nommage et explorer différents types de données. Acquérez une expérience pratique avec les opérations sur les chaînes, l'indexation, le découpage et les techniques de rappel de mémoire pour manipuler efficacement le texte en Python.

Apprenez à utiliser les opérateurs de comparaison et logiques, à travailler avec des expressions conditionnelles, et à appliquer des comparaisons d'appartenance et de type. Construisez une base solide pour écrire des programmes qui répondent dynamiquement à différentes conditions en utilisant les structures if/else et if/elif/else.

Élargissez votre compréhension des types de données en apprenant à regrouper plusieurs attributs au sein d'une seule variable. Explorez les lists, les tuples et les dictionaries pour stocker et gérer efficacement des données structurées, ainsi que les méthodes essentielles pour la manipulation et la récupération.

Maîtrisez l'art d'écrire des boucles en Python—des constructions essentielles pour itérer sur des listes, des tuples, des dictionnaires et d'autres structures de données. Apprenez à utiliser efficacement les boucles while et for, explorez la fonction range et travaillez avec des boucles imbriquées pour gérer des modèles d'itération complexes.

Explorez les fonctions intégrées essentielles en Python et passez à l'étape suivante en créant les vôtres. Apprenez à définir des fonctions, à utiliser la logique conditionnelle, à modifier des fonctions existantes et à travailler avec des expressions lambda pour écrire un code efficace et réutilisable.

Handle More Complex Math in Python

Solution