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

I dizionari sono dinamici, il che significa che è possibile **aggiungere**, **aggiornare** o **rimuovere** elementi dopo che il dizionario è stato creato. Analisi delle modalità di aggiunta di nuovi elementi a un dizionario.

Inizio con la creazione di un dizionario chiamato `book` con alcuni dettagli iniziali:

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

Per rendere il nostro dizionario più completo, è possibile aggiungere una nuova coppia chiave-valore. Ad esempio, si può aggiungere il `genre` del libro:

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

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

Dopo aver aggiunto la nuova coppia chiave-valore, il dizionario ora include:

## Aggiornamento di una coppia chiave-valore esistente
Per aggiornare il valore di una chiave già presente, è possibile riassegnare un nuovo valore a quella chiave. Ad esempio, supponiamo che l'anno di pubblicazione del libro sia stato corretto a `1815`:

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

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

Le virgolette singole `' '` e doppie `" "` in Python sono intercambiabili ed equivalenti.

Nota

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 scopri come applicarle efficacemente per risolvere sfide di programmazione reali.

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

Cos'è un dizionario? Un dizionario è una collezione ordinata e modificabile che non consente voci duplicate. È composto da coppie chiave:valore, utilizzate per ottimizzare la sua struttura.

Cos'è una tupla? Una tupla è una collezione ordinata che non può essere modificata. Può contenere elementi duplicati. Pur essendo 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ù comprensibili in Python.

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

Aggiunta di Elementi a un Dizionario: Aggiornamento delle Coppie Chiave-Valore

Aggiornamento di una coppia chiave-valore esistente

Soluzione