Summary  
This chapter covers how to create and use Python dictionaries, including the syntax for defining key–value pairs, the requirement that keys be immutable, and the behavior when duplicate keys are provided.  

General domain of usage  
Library cataloging

This video summarizes the key concepts from the 'Creating a Dictionary' chapter in the 'Mastering Python Dictionaries' section. You will learn what a Python dictionary is—an ordered, mutable collection that maps unique, immutable keys to values of any type. The video explains the basic syntax for creating dictionaries using curly braces `{}` and demonstrates how to use both strings and numbers as keys. You'll see why only immutable types like strings, numbers, and tuples can be used as keys, and what happens when you use duplicate keys—the last value provided for a key will overwrite any previous value. The video walks through real examples, such as representing book details and mapping library shelves, and discusses the code samples shown in the chapter. Finally, it reviews the interactive task where you create a `library` dictionary to store book titles and authors, reinforcing how to properly construct and use dictionaries in Python.

-- video metadata (use this info when making a video) --

Cut all examples of code to a minimum. Show only the essential code. Show code no longer than 10 lines. Remove all possible pieces to demonstrate some code feature. You may show not full code that will not start, but still demonstrates some feature theoritacally.
If code is longer than 8 lines, move code output  blocks to second column.

Un **dizionario Python** è una raccolta **ordinata** e **mutabile** di chiavi uniche e immutabili associate a valori di qualsiasi tipo, che preserva l'ordine di inserimento e consente accesso, aggiunta, aggiornamento e rimozione efficienti degli elementi tramite chiave.

Definizione

La sintassi di base per creare un dizionario è la seguente:
``` python
dictionary_name = {
    key1: value1,
    key2: value2,
    key3: value3
}
```
- **Chiavi**: devono essere **immutabili** (ad esempio, stringhe, numeri, tuple). Una lista o un altro dizionario non possono essere utilizzati come chiave;
- **Valori**: possono essere di qualsiasi tipo di dato (ad esempio, stringhe, numeri, liste, altri dizionari).

Immagina di gestire una biblioteca e di voler memorizzare informazioni su un libro. Ecco come creare un dizionario per rappresentare i dettagli del libro:

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

Questo dizionario utilizza stringhe come chiavi per memorizzare informazioni sul libro.

I dizionari consentono di utilizzare come chiavi qualsiasi tipo di dato **immutabile**. Ad esempio, è possibile utilizzare numeri come chiavi per creare un indice degli scaffali della biblioteca:

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

In questo esempio, i numeri sono utilizzati come chiavi per associare i generi a scaffali specifici della biblioteca.

Un **tipo di dato immutabile** è un tipo di dato che non può essere modificato dopo la creazione. Esempi includono **stringhe**, **numeri** e **tuple**.

Nota

### Cosa succede se le chiavi sono duplicate in un dizionario?
In Python, le chiavi di un dizionario devono essere **uniche**. Se vengono fornite chiavi duplicate durante la creazione o l'aggiornamento di un dizionario, l'ultima occorrenza della chiave sovrascriverà la precedente. Questo significa che il dizionario manterrà solo il valore più recente associato a quella chiave.

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

In questo caso, la seconda chiave `"title"` con il valore `"Animal Farm"` sovrascrive la prima chiave `"title"`.

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

    def test_library_keys_are_unique(self):
        import user_code
        keys = list(user_code.library.keys())
        unique_keys = set(keys)
        _dynamic_test(
            self,
            len(keys) == len(unique_keys),
            "All book titles (keys) in `library` are unique.",
            "Duplicate keys detected in the `library` dictionary. Each book title must appear only once as a key."
        )

    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

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.

Che 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, iterabile e 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.

Creazione di un Dizionario

Cosa succede se le chiavi sono duplicate in un dizionario?

Soluzione