Summary  
This chapter explains how to use floor division (`//`) to obtain integer quotients rounded down and modulus (`%`) to calculate remainders in Python.  

General domain of usage  
financial planning

In diesem Kapitel werden grundlegende mathematische Operationen behandelt: **Ganzzahlige Division** (`//`) und **Modulus** (`%`). Diese Operationen sind entscheidend für verschiedene Berechnungen, insbesondere in der Finanzplanung und Ressourcenverteilung.

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.

### Ganzzahlige Division (`//`)

Die ganzzahlige Division, dargestellt durch den Operator `//`, gibt an, wie oft eine Zahl vollständig in eine andere passt.

Stellen Sie sich vor, ein Unternehmen verfügt über ein Budget von `38000` Dollar und muss Mittel auf verschiedene Abteilungen verteilen, wobei jede Abteilung `7000` Dollar benötigt. Mit der ganzzahligen Division lässt sich berechnen, wie viele Abteilungen vollständig finanziert werden können:

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

In diesem Fall kann das Unternehmen `5` Abteilungen vollständig finanzieren.

Die Division (**normale Division**) ergibt eine Fließkommazahl, selbst wenn sowohl Zähler als auch Nenner Ganzzahlen sind. Die Ganzzahldivision (**Abrundungsdivision**) liefert ein ganzzahliges Ergebnis und verwirft den Nachkommabereich. `5 / 2` ergibt `2.5`, während `5 // 2` `2` ergibt.

Hinweis

### Modulo (`%`)

Die Modulo-Operation, dargestellt durch den Operator `%`, berechnet den Rest nach einer Division. Dies ist nützlich, um die verbleibenden Mittel nach der Ressourcenverteilung zu bestimmen.

Im vorherigen Szenario kann nach der Zuweisung von `35000` Dollar an `5` Abteilungen das verbleibende Budget berechnet werden:

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

Hier beträgt der Rest `3000` Dollar, was bedeutet, dass das Unternehmen nach der Finanzierung der Abteilungen noch `3000` Dollar übrig hat.

### Praktische Anwendungen

**Ganzzahlige Division** wird häufig in Situationen verwendet, in denen Ressourcen gleichmäßig verteilt werden müssen, wie zum Beispiel bei Budgetierung, Projektfinanzierung oder Bestandsverwaltung.

**Modulus** ist nützlich für Aufgaben wie das Ermitteln verbleibender Ressourcen, die Durchführung periodischer Finanzüberprüfungen oder die Berechnung von Restwerten in Finanzmodellen.

Durch das Beherrschen dieser Operationen können Finanzplanung und Ressourcenallokation verbessert werden, wodurch der Code effizienter und wirkungsvoller wird.


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

Erwerben Sie ein fundiertes Verständnis der grundlegenden Datentypen in Python und lernen Sie, wie Sie effektiv mit ihnen arbeiten. Erkunden Sie Zahlen, Booleans, Strings sowie die sichere Umwandlung und den Vergleich von Werten zwischen verschiedenen Typen. Stärken Sie Ihr Vertrauen im Umgang mit arithmetischen, logischen und String-Operationen und entwickeln Sie die grundlegenden Fähigkeiten, um sauberen und zuverlässigen Python-Code zu schreiben.

Erkunden Sie die Grundlagen der numerischen Datentypen in Python, einschließlich Ganzzahlen und Fließkommazahlen, sowie Arithmetik und Operatorrangfolge. Üben Sie Ganzzahldivision, Modulo und Funktionen des math-Moduls anhand praxisnaher Zeit- und Budgetberechnungen.

Erwerben Sie ein fundiertes Verständnis des Booleschen Datentyps und wie Vergleichsoperatoren Gleichheit, Identität und Wahrheitswerte auswerten. Anwenden von logischen Operatoren zur Erstellung klarer, präziser Bedingungen für praxisnahe Programmieraufgaben.



Praktische Erfahrungen mit Python-Strings, von der Erstellung und Indizierung bis hin zum Slicing, Suchen und Formatieren von Text. Verständnis der Unveränderlichkeit von Strings und effiziente Erstellung neuer Strings für interaktive Programme.



Erfahren Sie, wie Sie zwischen den grundlegenden Datentypen von Python konvertieren, Zeichenfolgen durch Normalisierung von Groß-/Kleinschreibung und Leerzeichen zuverlässig vergleichen und fehlende Werte mit None behandeln. Verstehen Sie, wann bytes und bytearray für rohe Binärdaten in praxisnahen Programmen verwendet werden.



Herausforderung: Vertiefung in Fortgeschrittene Mathematik

Ganzzahlige Division (`//`)

Modulo (`%`)

Praktische Anwendungen

Lösung

Herausforderung: Vertiefung in Fortgeschrittene Mathematik

Ganzzahlige Division (//)

Modulo (%)

Praktische Anwendungen

Lösung

Ganzzahlige Division (`//`)

Modulo (`%`)