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

Detta kapitel behandlar viktiga matematiska operationer: **golvdivision** (`//`) och **modulus** (`%`). Dessa operationer är avgörande för olika beräkningar, särskilt inom ekonomisk planering och resursfördelning.

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.

### Golvdivision (`//`)

Golvdivision, betecknad med operatorn `//`, används för att avgöra hur många hela gånger ett tal ryms i ett annat.

Föreställ dig att ett företag har en budget på `38000` dollar och behöver fördela medel till olika avdelningar, där varje avdelning kräver `7000` dollar. Med hjälp av golvdivision kan du beräkna hur många avdelningar som kan finansieras fullt ut:

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

I det här fallet kan företaget fullt ut finansiera `5` avdelningar.

Division (**vanlig division**) returnerar ett flyttal, även om både täljaren och nämnaren är heltal. Heltalsdivision (**golvdivision**) returnerar ett heltalsresultat och ignorerar den decimala delen. `5 / 2` ger `2.5`, medan `5 // 2` ger `2`.

Notering

### Modulus (`%`)

Modulusoperationen, representerad av operatorn `%`, beräknar resten efter division. Detta är användbart för att bestämma återstående medel efter resursfördelning.

Om vi fortsätter med det tidigare scenariot, efter att ha tilldelat `35000` dollar till `5` avdelningar, kan du beräkna den återstående budgeten:

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

Här är resten `3000` dollar, vilket innebär att företaget har `3000` dollar kvar efter att ha finansierat avdelningarna.

### Praktiska tillämpningar

**Heltalsdivision** används ofta i situationer där resurser ska fördelas lika, såsom budgetering, projektfinansiering eller lagerhantering.

**Modulus** är användbart för uppgifter som att bestämma överblivna resurser, hantera periodiska ekonomiska granskningar eller beräkna restvärden i finansiella modeller.

Genom att behärska dessa operationer kan du förbättra din ekonomiska planering och resursallokering, vilket gör din kod mer effektiv och ändamålsenlig.


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

Få en gedigen förståelse för Pythons grundläggande datatyper och lär dig att arbeta effektivt med dem. Utforska tal, booleska värden och strängar genom praktiska övningar och exempel. Bygg upp självförtroende i att utföra grundläggande operationer och utveckla de grundläggande färdigheter som krävs för att skriva ren och effektiv Python-kod.

Upptäck grunderna i numeriska datatyper i Python och lär dig arbeta med heltal och flyttal. Behärska grundläggande aritmetiska operationer, utforska begreppet oföränderlighet och få praktisk erfarenhet av att använda Pythons inbyggda funktioner och verktyg för att hantera tal effektivt i verkliga situationer.

Få en tydlig förståelse för datatypen Boolean, en specialiserad undergrupp av numerisk data som representerar sanningsvärden. Även om det kan verka utmanande till en början är det avgörande att behärska Booleans för att skriva logiska och effektiva program. Detta avsnitt hjälper dig att säkert tillämpa Boolean-logik i verkliga programmeringsscenarier.

Strängar gör det möjligt att arbeta med text i Python, från att visa meddelanden till att bearbeta användarinmatning. Du kommer att utforska hur man skapar, modifierar och hanterar strängar på ett effektivt sätt. Förståelse för strängar är avgörande för att skriva interaktiva program och för att tydligt kommunicera information genom din kod.

Lär dig att hantera datatyper effektivt för att säkerställa noggrannhet och konsekvens i dina program. Konvertera värden till lämplig typ, rensa text före jämförelse och separera numeriska operationer från textformatering. Du kommer även att upptäcka hur man hanterar saknade data medvetet och behandlar läsbar text annorlunda än rå indata, för att uppnå tillförlitliga, konsekventa och lättlästa resultat.

Fördjupning i Avancerade Matematiska Tekniker i Python

Golvdivision (`//`)

Modulus (`%`)

Praktiska tillämpningar

Lösning

Fördjupning i Avancerade Matematiska Tekniker i Python

Golvdivision (//)

Modulus (%)

Praktiska tillämpningar

Lösning

Golvdivision (`//`)

Modulus (`%`)