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

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

Definition

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 può essere la 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 puoi 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 che le chiavi siano di qualsiasi tipo di dato **immutabile**. Ad esempio, puoi usare 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 chiavi per mappare i generi a specifici scaffali della biblioteca.

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

## Cosa succede se le chiavi sono duplicate in un dizionario?
In Python, le chiavi del 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. Ciò 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_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

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.

Creare un Dizionario in Python: Memorizzare Coppie Chiave-Valore

Cosa succede se le chiavi sono duplicate in un dizionario?

Soluzione