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

Et **Python dictionary** er en **ordnet**, **muterbar** samling af unikke, uforanderlige nøgler, der er knyttet til værdier af enhver type. Bevarer indsættelsesrækkefølgen og muliggør effektiv adgang, tilføjelse, opdatering og fjernelse af elementer via nøgle.

Definition

Den grundlæggende syntaks for at oprette et dictionary er som følger:
``` python
dictionary_name = {
    key1: value1,
    key2: value2,
    key3: value3
}
```
- **Nøgler**: skal være **uforanderlige** (f.eks. strenge, tal, tupler). En liste eller et andet dictionary kan ikke være en nøgle;
- **Værdier**: kan være enhver datatype (f.eks. strenge, tal, lister, andre dictionaries).

Forestil dig, at du administrerer et bibliotek og vil gemme information om en bog. Her er, hvordan du kan oprette et dictionary til at repræsentere bogens detaljer:

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

Denne ordbog bruger strenge som nøgler til at gemme information om bogen.

Ordbøger tillader, at nøgler kan være enhver **uforanderlig** datatype. For eksempel kan du bruge tal som nøgler til at oprette et indeks over bibliotekshylder:

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

I dette eksempel bruges tal som nøgler til at matche genrer med specifikke bibliotekshylder.

En **uforanderlig datatyp** er en type data, der ikke kan ændres efter oprettelse. Eksempler inkluderer **strenge**, **tal** og **tupler**.

Bemærk

## Hvad sker der, hvis nøgler duplikeres i et dictionary?
I Python skal dictionary-nøgler være **unikke**. Hvis der angives duplikerede nøgler ved oprettelse eller opdatering af et dictionary, vil den sidste forekomst af nøglen overskrive den forrige. Det betyder, at dictionaryen kun bevarer den nyeste værdi, der er knyttet til den nøgle.

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

I dette tilfælde overskriver den anden `"title"`-nøgle med værdien `"Animal Farm"` den første `"title"`-nøgle.

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

Udforsk de grundlæggende datastrukturer i programmeringssproget Python, herunder lister, ordbøger, tupler og mængder, og lær hvordan de anvendes effektivt til at løse virkelige programmeringsudfordringer.

Hvad er en liste? En liste er en ordnet samling, der kan ændres. Den tillader også duplikerede elementer.

Hvad er et dictionary? Et dictionary er en ordnet samling, der kan ændres, men som ikke tillader dublerede poster. Det består af nøgle:værdi-par, som bruges til at optimere dets struktur.

Hvad er et tuple? Et tuple er en ordnet samling, der ikke kan ændres. Det kan indeholde duplikerede elementer. Selvom det ligner en liste, kan værdierne i et tuple være af enhver type og indekseres med heltal. Selvom det ikke er obligatorisk, er det almindeligt at omslutte værdierne i et tuple med parenteser, hvilket gør dem lettere at forstå i Python.

Hvad er et set? I Python er et set en uordnet samling, der både er itererbar og muterbar, uden gentagne elementer. Selvom rækkefølgen af elementer i et set ikke er fastlagt, kan det indeholde forskellige elementer. En vigtig fordel ved at bruge sets frem for lister er deres meget effektive metode til at afgøre, om et element findes i settet.

Oprettelse af et Dictionary i Python: Lagring af Nøgle-Værdi-Par

Hvad sker der, hvis nøgler duplikeres i et dictionary?

Løsning