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

Tämä luku käsittelee keskeisiä matemaattisia operaatioita: **lattiajakolasku** (`//`) ja **jäännös** (`%`). Nämä operaatiot ovat tärkeitä erilaisissa laskelmissa, erityisesti taloussuunnittelussa ja resurssien jakamisessa.

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.

### Lattiajakolasku (`//`)

Lattiajakolasku, jota merkitään `//`-operaattorilla, kertoo kuinka monta kokonaista kertaa yksi luku mahtuu toiseen.

Kuvittele, että yrityksellä on budjetti `38000` dollaria ja sen täytyy jakaa varoja eri osastoille, joista kukin tarvitsee `7000` dollaria. Lattiajakolaskun avulla voidaan laskea, kuinka monta osastoa voidaan rahoittaa kokonaan:

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

Tässä tapauksessa yritys voi rahoittaa kokonaan `5` osastoa.

Jakolasku (**tavallinen jakolasku**) palauttaa liukuluvun, vaikka sekä osoittaja että nimittäjä olisivat kokonaislukuja. Kokonaislukujako (**lattiajako**) palauttaa kokonaislukutuloksen, jättäen desimaaliosan pois. `5 / 2` antaa `2.5`, kun taas `5 // 2` antaa `2`.

Huomio

### Jäännös (`%`)

Jäännöslasku, jota edustaa `%`-operaattori, laskee jaon jälkeisen jäännöksen. Tämä on hyödyllistä, kun halutaan selvittää jäljelle jäävät varat resurssien jakamisen jälkeen.

Jatkaen aiemmasta esimerkistä, kun `35000` dollaria on jaettu `5` osastolle, voit laskea jäljellä olevan budjetin:

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

Tässä jakojäännös on `3000` dollaria, mikä tarkoittaa, että yritykselle jää `3000` dollaria osastojen rahoituksen jälkeen.

### Käytännön sovellukset

**Lattiajakolasku** on usein käytössä tilanteissa, joissa resursseja jaetaan tasan, kuten budjetoinnissa, projektirahoituksessa tai varastonhallinnassa.

**Jakojäännös** on hyödyllinen esimerkiksi ylijäämäresurssien selvittämisessä, säännöllisten talouskatsausten käsittelyssä tai jäännösarvojen laskennassa talousmalleissa.

Hallitsemalla nämä operaatiot voit parantaa taloussuunnittelua ja resurssien kohdentamista, tehden koodistasi tehokkaampaa ja toimivampaa.


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

Hanki vankka ymmärrys Pythonin keskeisistä tietotyypeistä ja opi työskentelemään niiden kanssa tehokkaasti. Tutustu numeroihin, totuusarvoihin, merkkijonoihin sekä siihen, miten arvoja muunnetaan ja verrataan turvallisesti eri tyyppien välillä. Kehitä varmuutta aritmeettisten, loogisten ja merkkijono-operaatioiden suorittamisessa sekä perusosaamista, jota tarvitaan selkeän ja luotettavan Python-koodin kirjoittamiseen.

Tutustu Pythonin numeeristen tietotyyppien perusteisiin, kuten kokonaislukuihin ja liukulukuihin, sekä aritmetiikkaan ja operaattorien etusijajärjestykseen. Harjoittele lattiakertolaskua, jakojäännöstä ja math-moduulin funktioita käytännön ajan- ja budjettilaskelmien avulla.

Perusteellinen ymmärrys Boolean-tietotyypistä sekä siitä, miten vertailuoperaattorit arvioivat yhtäsuuruutta, identiteettiä ja totuusarvoja. Loogisten operaattoreiden hyödyntäminen selkeiden ja tarkkojen ehtojen rakentamiseen ohjelmointitilanteissa.

Saat käytännön kokemusta Python-merkkijonoista, niiden luomisesta ja indeksoinnista aina viipalointiin, hakemiseen ja tekstin muotoiluun asti. Ymmärrä, miksi merkkijonot ovat muuttumattomia ja kuinka rakentaa uusia merkkijonoja tehokkaasti vuorovaikutteisia ohjelmia varten.



Opi muuntamaan Pythonin ydintietotyyppejä, vertailemaan merkkijonoja luotettavasti normalisoimalla kirjainkoko ja välilyönnit sekä käsittelemään puuttuvia arvoja None-arvon avulla.
Ymmärrä, milloin käyttää bytes- ja bytearray-tyyppejä raakadatan käsittelyyn käytännön ohjelmissa.



Haaste: Syväsukellus Edistyneeseen Matematiikkaan

Lattiajakolasku (`//`)

Jäännös (`%`)

Käytännön sovellukset

Ratkaisu

Haaste: Syväsukellus Edistyneeseen Matematiikkaan

Lattiajakolasku (//)

Jäännös (%)

Käytännön sovellukset

Ratkaisu

Lattiajakolasku (`//`)

Jäännös (`%`)