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

Esplora le strutture dati fondamentali del linguaggio di programmazione Python, tra cui liste, dizionari, tuple e set, e apprendi come applicarle efficacemente per risolvere sfide di programmazione reali.

Cos'è una lista? Una lista è una collezione ordinata che può essere modificata. Consente anche elementi duplicati.

Cos'è un dizionario? Un dizionario è una raccolta ordinata che può essere modificata, ma non consente voci duplicate. Consiste in coppie `key:value`, che vengono utilizzate per ottimizzare la sua struttura.

Cos'è una tupla? Una tupla è una collezione ordinata che non può essere modificata. Può avere elementi duplicati. Anche se è simile a una lista, i valori in una tupla possono essere di qualsiasi tipo e sono indicizzati da numeri interi. Anche se non è obbligatorio, è comune racchiudere i valori di una tupla tra parentesi, rendendoli più facili da comprendere in Python.

Cos'è un set? In Python, un `set` è una collezione non ordinata che è sia `iterable` che `mutable`, senza elementi ripetuti. Sebbene l'ordine degli elementi in un set non sia fisso, può includere una varietà di elementi. Un vantaggio chiave dell'utilizzo dei set rispetto alle liste è il loro metodo altamente efficiente per determinare se un elemento esiste all'interno del set.

Adding Items to a Dictionary: Updating Key-Value Pairs

Updating an Existing Key-Value Pair

Soluzione