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

Tämä luku käsittelee keskeisiä matemaattisia operaatioita: **lattiajako** (`//`) 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.

### Lattiajako (`//`)

Lattiajako, 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. Lattiajaon 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ösoperaatio, 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 määrittämisessä, säännöllisten talouskatsausten käsittelyssä tai jäännösarvojen laskemisessa talousmalleissa.

Hallitsemalla nämä operaatiot voit parantaa taloussuunnittelua ja resurssien jakamista, tehden koodistasi tehokkaampaa ja vaikuttavampaa.


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 ja merkkijonoihin käytännön harjoitusten ja esimerkkien avulla. Rakenna varmuutta perusoperaatioiden suorittamisessa ja kehitä perustaidot, joita tarvitaan selkeän ja tehokkaan Python-koodin kirjoittamiseen.

Tutustu Pythonin numeeristen tietotyyppien perusteisiin ja opi käsittelemään kokonais- ja liukulukuja. Hallitse peruslaskutoimitukset, perehdy muuttumattomuuden käsitteeseen ja saa käytännön kokemusta Pythonin sisäänrakennettujen funktioiden ja työkalujen hyödyntämisestä numeroiden tehokkaaseen käsittelyyn todellisissa tilanteissa.

Saat selkeän käsityksen Boolean-tietotyypistä, joka on numeerisen datan erikoistyyppi ja edustaa totuusarvoja. Vaikka aihe voi aluksi vaikuttaa haastavalta, Booleanien hallinta on olennaista loogisten ja tehokkaiden ohjelmien kirjoittamisessa. Tämä osio auttaa sinua soveltamaan Boolean-logiikkaa luottavaisesti todellisissa ohjelmointitilanteissa.

Merkkijonot mahdollistavat tekstin käsittelyn Pythonissa, viestien näyttämisestä käyttäjän syötteen käsittelyyn. Tässä osiossa perehdytään merkkijonojen luomiseen, muokkaamiseen ja käsittelyyn tehokkaasti. Merkkijonojen ymmärtäminen on olennaista vuorovaikutteisten ohjelmien kirjoittamisessa ja tiedon selkeässä välittämisessä koodin kautta.

Opi käsittelemään tietotyyppejä tehokkaasti varmistaaksesi ohjelmiesi tarkkuuden ja johdonmukaisuuden. Muunna arvot sopivaan tietotyyppiin, puhdista teksti ennen vertailua ja erottele numeeriset laskutoimitukset tekstin muotoilusta. Opit myös hallitsemaan puuttuvia tietoja tarkoituksellisesti sekä käsittelemään ihmisen luettavaa tekstiä eri tavalla kuin raakadataa, saavuttaen luotettavia, johdonmukaisia ja helposti luettavia tuloksia.

Syväsukellus Pythonin Edistyneisiin Matemaattisiin Tekniikoihin

Lattiajako (`//`)

Jäännös (`%`)

Käytännön sovellukset

Ratkaisu

Syväsukellus Pythonin Edistyneisiin Matemaattisiin Tekniikoihin

Lattiajako (//)

Jäännös (%)

Käytännön sovellukset

Ratkaisu

Lattiajako (`//`)

Jäännös (`%`)