Summary  
This chapter covers how to create and use Python dictionaries, including the syntax for defining key–value pairs, the requirement that keys be immutable, and the behavior when duplicate keys are provided.  

General domain of usage  
Library cataloging

This video summarizes the key concepts from the 'Creating a Dictionary' chapter in the 'Mastering Python Dictionaries' section. You will learn what a Python dictionary is—an ordered, mutable collection that maps unique, immutable keys to values of any type. The video explains the basic syntax for creating dictionaries using curly braces `{}` and demonstrates how to use both strings and numbers as keys. You'll see why only immutable types like strings, numbers, and tuples can be used as keys, and what happens when you use duplicate keys—the last value provided for a key will overwrite any previous value. The video walks through real examples, such as representing book details and mapping library shelves, and discusses the code samples shown in the chapter. Finally, it reviews the interactive task where you create a `library` dictionary to store book titles and authors, reinforcing how to properly construct and use dictionaries in Python.

-- video metadata (use this info when making a video) --

Cut all examples of code to a minimum. Show only the essential code. Show code no longer than 10 lines. Remove all possible pieces to demonstrate some code feature. You may show not full code that will not start, but still demonstrates some feature theoritacally.
If code is longer than 8 lines, move code output  blocks to second column.

**Python-sanakirja** on **järjestetty**, **muokattavissa** oleva kokoelma yksilöllisiä, muuttumattomia avaimia, jotka on yhdistetty minkä tahansa tyyppisiin arvoihin. Se säilyttää lisäysjärjestyksen ja mahdollistaa tehokkaan pääsyn, lisäämisen, päivittämisen ja poistamisen avaimen perusteella.

Määritelmä

Perussyntaksi sanakirjan luomiseen on seuraava:
``` python
dictionary_name = {
    key1: value1,
    key2: value2,
    key3: value3
}
```
- **Avaimet**: täytyy olla **muuttumattomia** (esim. merkkijonot, numerot, tuplet). Lista tai toinen sanakirja ei voi olla avaimena;
- **Arvot**: voivat olla mitä tahansa tietotyyppejä (esim. merkkijonot, numerot, listat, muut sanakirjat).

Kuvittele, että hallinnoit kirjastoa ja haluat tallentaa tietoja kirjasta. Näin voit luoda sanakirjan, joka kuvaa kirjan tiedot:

book = {
    "title": "Pride and Prejudice",
    "author": "Jane Austen",
    "year": 1813,
    "genre": "Romance"
}
print(book)

Tässä sanakirjassa käytetään merkkijonoja avaimina kirjaa koskevien tietojen tallentamiseen.

Sanakirjoissa avaimet voivat olla mitä tahansa **muuttumattomia** tietotyyppejä. Esimerkiksi voit käyttää numeroita avaimina luodaksesi kirjastohyllyjen hakemiston:

shelves = {1: "Classics", 2: "Science Fiction", 3: "Mystery", 4: "Non-fiction"}
print(shelves)

Tässä esimerkissä numerot toimivat avaimina, joiden avulla lajityypit yhdistetään tiettyihin kirjastohyllyihin.

**Muuttumaton tietotyyppi** on tietotyyppi, jota ei voi muuttaa luomisen jälkeen. Esimerkkejä ovat **merkkijonot**, **luvut** ja **tuplet**.

Huomio

### Mitä tapahtuu, jos sanakirjassa on päällekkäisiä avaimia?
Pythonissa sanakirjan avainten täytyy olla **yksilöllisiä**. Jos sanakirjaa luodessa tai päivittäessä annetaan päällekkäisiä avaimia, viimeisin avain korvaa aiemmat. Tämä tarkoittaa, että sanakirjaan jää vain viimeisin arvo kyseiselle avaimelle.

book = {"title": "1984", "author": "George Orwell", "title": "Animal Farm"}
print(book)  # Output: {'title': 'Animal Farm', 'author': 'George Orwell'}

Tässä tapauksessa toinen `"title"`-avain arvolla `"Animal Farm"` korvaa ensimmäisen `"title"`-avaimen.

import unittest
import importlib

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_library_is_declared(self):
        import user_code
        _dynamic_test(
            self,
            hasattr(user_code, 'library'),
            "The `library` dictionary is declared.",
            "Expected `library` to be declared."
        )

    def test_library_is_a_dict(self):
        import user_code
        _dynamic_test(
            self,
            isinstance(user_code.library, dict),
            "The `library` is of type `dict`.",
            "Expected `library` to be of type `dict`."
        )

    def test_library_contains_exactly_three_entries(self):
        import user_code
        _dynamic_test(
            self,
            len(user_code.library) == 3,
            "The `library` contains exactly three books.",
            f"Expected `library` to contain exactly 3 books, but got {len(user_code.library)}."
        )

    def test_library_keys_are_unique(self):
        import user_code
        keys = list(user_code.library.keys())
        unique_keys = set(keys)
        _dynamic_test(
            self,
            len(keys) == len(unique_keys),
            "All book titles (keys) in `library` are unique.",
            "Duplicate keys detected in the `library` dictionary. Each book title must appear only once as a key."
        )

    def test_library_keys_are_strings(self):
        import user_code
        _dynamic_test(
            self,
            all(isinstance(key, str) for key in user_code.library.keys()),
            "All book titles (keys) in `library` are strings.",
            "Expected all book titles (keys) in `library` to be of type `str`."
        )

    def test_library_values_are_strings(self):
        import user_code
        _dynamic_test(
            self,
            all(isinstance(value, str) for value in user_code.library.values()),
            "All authors (values) in `library` are strings.",
            "Expected all authors (values) in `library` to be of type `str`."
        )

    def test_library_created_using_curly_braces(self):
        with open('user_code.py', 'r') as file:
            user_code_source = file.read()
        _dynamic_test(
            self,
            '{' in user_code_source and '}' in user_code_source,
            "The `library` dictionary was created using curly braces `{}`.",
            "Expected `library` to be created using `{}` (curly braces)."
        )

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

test_main.py

Tutustu Python-ohjelmointikielen keskeisiin tietorakenteisiin, kuten listoihin, sanakirjoihin, tuplisiin ja joukkoihin, sekä niiden tehokkaaseen hyödyntämiseen todellisten ohjelmointiongelmien ratkaisemisessa.

Mikä on lista? Lista on järjestetty kokoelma, jota voidaan muokata. Se sallii myös päällekkäiset alkiot.

Mikä on sanakirja? Sanakirja on järjestetty kokoelma, jota voidaan muokata, mutta se ei salli päällekkäisiä merkintöjä. Se koostuu avain:arvo-pareista, joita käytetään rakenteen optimointiin.

Mikä on tuple? Tuple on järjestetty kokoelma, jota ei voi muuttaa. Se voi sisältää päällekkäisiä alkioita. Vaikka se muistuttaa listaa, tuplen arvot voivat olla mitä tahansa tyyppiä ja ne indeksoidaan kokonaisluvuilla. Vaikka se ei ole pakollista, on tavallista sulkea tuplen arvot sulkuihin, mikä tekee niistä helpommin ymmärrettäviä Pythonissa.

Mikä on joukko? Pythonissa joukko on järjestämätön kokoelma, joka on iteroitava ja muokattavissa, eikä siinä ole toistuvia alkioita. Vaikka joukon alkioiden järjestys ei ole kiinteä, se voi sisältää erilaisia alkioita. Merkittävä etu joukkojen käyttämisessä listoihin verrattuna on niiden erittäin tehokas tapa selvittää, kuuluuko alkio joukkoon.

Sanakirjan Luominen

Mitä tapahtuu, jos sanakirjassa on päällekkäisiä avaimia?

Ratkaisu