Summary  
This chapter covers creating and using Python dictionaries to store key-value pairs, enforce immutable unique keys, and demonstrate how duplicate keys overwrite previous values.

General domain of usage  
Library management

Een **Python dictionary** is een **geordende**, **mutabele** verzameling van unieke, onveranderlijke sleutels gekoppeld aan waarden van elk type, waarbij de invoegvolgorde behouden blijft en efficiënte toegang, toevoeging, bijwerking en verwijdering van items op sleutel mogelijk is.

Definitie

De basis-syntaxis voor het aanmaken van een dictionary is als volgt:
``` python
dictionary_name = {
    key1: value1,
    key2: value2,
    key3: value3
}
```
- **Sleutels**: moeten **onveranderlijk** zijn (bijv. strings, nummers, tuples). Een lijst of een andere dictionary kan geen sleutel zijn;
- **Waarden**: kunnen elk gegevenstype zijn (bijv. strings, nummers, lijsten, andere dictionaries).

Stel je beheert een bibliotheek en wilt informatie over een boek opslaan. Zo kun je een dictionary maken om de details van het boek weer te geven:

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

Dit woordenboek gebruikt strings als sleutels om informatie over het boek op te slaan.

Woordenboeken staan toe dat sleutels elk **onveranderlijk** gegevenstype kunnen zijn. Je kunt bijvoorbeeld getallen als sleutels gebruiken om een index van bibliotheekplanken te maken:

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

In dit voorbeeld zijn getallen sleutels om genres aan specifieke bibliotheekplanken te koppelen.

Een **immutable gegevenstype** is een type gegevens dat na creatie niet kan worden gewijzigd. Voorbeelden zijn **strings**, **getallen** en **tuples**.

Opmerking

## Wat gebeurt er als sleutels worden gedupliceerd in een dictionary?
In Python moeten dictionary-sleutels **uniek** zijn. Als dubbele sleutels worden opgegeven bij het maken of bijwerken van een dictionary, zal het laatste voorkomen van de sleutel de vorige overschrijven. Dit betekent dat de dictionary alleen de meest recente waarde die aan die sleutel is gekoppeld, zal behouden.

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

In dit geval overschrijft de tweede `"title"`-sleutel met de waarde `"Animal Farm"` de eerste `"title"`-sleutel.

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_at_least_three_entries(self):
        import user_code
        _dynamic_test(
            self,
            len(user_code.library) >= 3,
            "The `library` contains at least three books.",
            f"Expected `library` to contain at least 3 books, but got {len(user_code.library)}."
        )

    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

Ontdek de fundamentele datastructuren van de programmeertaal Python, waaronder lijsten, woordenboeken, tuples en sets, en leer hoe u deze effectief kunt toepassen om programmeeruitdagingen uit de praktijk op te lossen.

Wat is een lijst? Een lijst is een geordende collectie die kan worden aangepast. Het staat ook dubbele elementen toe.

Wat is een dictionary? Een dictionary is een geordende, wijzigbare collectie die geen dubbele items toestaat. Het bestaat uit key:value-paren, die worden gebruikt om de structuur te optimaliseren.

Wat is een tuple? Een tuple is een geordende verzameling die niet kan worden gewijzigd. Een tuple kan dubbele elementen bevatten. Hoewel het lijkt op een lijst, kunnen de waarden in een tuple van elk type zijn en worden ze geïndexeerd door gehele getallen. Hoewel het niet verplicht is, is het gebruikelijk om de waarden van een tuple tussen haakjes te plaatsen, wat het in Python overzichtelijker maakt.

Wat is een set? In Python is een set een ongeordende verzameling die zowel itereerbaar als muteerbaar is, zonder herhaalde elementen. Hoewel de volgorde van items in een set niet vastligt, kan deze verschillende elementen bevatten. Een belangrijk voordeel van het gebruik van sets ten opzichte van lijsten is de zeer efficiënte methode om te bepalen of een element zich in de set bevindt.

Een Dictionary Maken in Python: Sleutel-Waardeparen Opslaan

Wat gebeurt er als sleutels worden gedupliceerd in een dictionary?

Oplossing