Summary  
This chapter explains how to dynamically add new key-value pairs to a dictionary and update existing values by assigning to dictionary keys.

General domain of usage  
Book cataloging systems

Dictionaries are dynamic, meaning you can **add**, **update**, or **remove** items after the dictionary has been created. Let's explore how to add new items to a dictionary.

Start with creating a dictionary called `book` with some initial details:

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

To make our dictionary more complete, we can add a new key-value pair to it. For example, we might want to add the `genre` of the book:

book = {"title": "Pride and Prejudice", "author": "Jane Austen", "year": 1813}

book["genre"] = "Romance"
print(book)

After adding the new key-value pair, the dictionary now includes:

## Updating an Existing Key-Value Pair
If you need to update the value of an existing key, you can do so by reassigning a new value to that key. For example, let's assume the book's publication year was corrected to `1815`:

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

book["year"] = 1815
print(book)

Single `' '` and double `" "` quotes in Python are interchangeable and equivalent.

Note

import unittest
import importlib

def _dynamic_test(test_case, condition, success_message, failure_message):
    """
    A reusable function for handling assertions dynamically.
    """
    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_authors_books_is_declared(self):
        """
        Test to ensure `authors_books` is declared.
        """
        import user_code
        _dynamic_test(
            self,
            hasattr(user_code, 'authors_books'),
            "The `authors_books` dictionary is declared.",
            "Expected `authors_books` to be declared."
        )

    def test_authors_books_is_dict(self):
        """
        Test to ensure `authors_books` is of type dictionary.
        """
        import user_code
        _dynamic_test(
            self,
            isinstance(user_code.authors_books, dict),
            "The `authors_books` is of type `dict`.",
            "Expected `authors_books` to be of type `dict`."
        )
    
    def test_new_author_added(self):
        """
        Test to ensure the new author is added to `authors_books`.
        """
        import user_code
        expected_author = "F. Scott Fitzgerald"
        _dynamic_test(
            self,
            expected_author in user_code.authors_books,
            "The new author `F. Scott Fitzgerald` is added to `authors_books`.",
            "Expected `F. Scott Fitzgerald` to be added to `authors_books`."
        )

    def test_new_author_books_are_list(self):
        """
        Test to ensure the books of the new author are stored as a list.
        """
        import user_code
        expected_author = "F. Scott Fitzgerald"
        _dynamic_test(
            self,
            isinstance(user_code.authors_books.get(expected_author, []), list),
            "The books for `F. Scott Fitzgerald` are stored as a list.",
            "Expected books for `F. Scott Fitzgerald` to be stored as a list."
        )
    
    def test_new_author_books_correct(self):
        """
        Test to ensure the books of the new author match expected values.
        """
        import user_code
        expected_author = "F. Scott Fitzgerald"
        expected_books = [
            "The Great Gatsby", "Tender Is the Night", "This Side of Paradise", 
            "The Beautiful and Damned", "The Last Tycoon"
        ]
        _dynamic_test(
            self,
            set(user_code.authors_books.get(expected_author, [])) == set(expected_books),
            "The books for `F. Scott Fitzgerald` are correctly added.",
            f"Expected books for `F. Scott Fitzgerald` to be {expected_books}, but got {user_code.authors_books.get(expected_author, [])}."
        )
    
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 kan anvendes effektivt til at løse virkelige programmeringsudfordringer.

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

Hvad er en ordbog? En ordbog er en ordnet samling, der kan ændres, men den tillader ikke dublerede poster. Den består af `key:value` par, som bruges til at optimere dens struktur.

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

Hvad er et sæt? I Python er et `set` en uordnet samling, der både er `iterable` og `mutable`, uden gentagne elementer. Selvom rækkefølgen af elementer i et sæt ikke er fast, kan det inkludere en række forskellige elementer. En vigtig fordel ved at bruge sæt frem for lister er deres meget effektive metode til at bestemme, om et element findes inden for sættet.

Adding Items to a Dictionary: Updating Key-Value Pairs

Updating an Existing Key-Value Pair

Løsning