Summary  
This chapter covers how to retrieve a dictionary’s keys using the keys() method, iterate through them with a for loop, and check for the existence of a specific key using the in keyword.

General domain of usage  
Data processing

Per accedere alle chiavi di un dizionario in Python, è possibile utilizzare il metodo `keys()`. Questo restituisce un oggetto view che mostra tutte le chiavi presenti nel dizionario.

book = {
    "title": "Pride and Prejudice",
    "author": "Jane Austen",
    "year": 1813,
    "genre": "Romance"
}
keys = book.keys()
print(keys)  # Output: dict_keys(['title', 'author', 'year', 'genre'])

### Iterazione sulle chiavi
È possibile iterare sulle chiavi di un dizionario utilizzando un ciclo `for`:

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

for item in book.keys():
    print(key)

### Verifica dell'esistenza di una chiave
Utilizzare la parola chiave in per verificare se una chiave specifica esiste nel dizionario:

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

if "author" in book:
    print("The 'author' key exists in the dictionary.")

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_authors_books_is_declared(self):
        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):
        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_keys_variable_is_declared(self):
        import user_code
        _dynamic_test(
            self,
            hasattr(user_code, 'keys'),
            "The `keys` list is declared.",
            "Expected `keys` to be declared."
        )

    def test_keys_contains_correct_values(self):
        import user_code
        expected_keys = list(user_code.authors_books.keys())
        _dynamic_test(
            self,
            set(user_code.keys) == set(expected_keys),
            "The `keys` list contains the correct author names.",
            f"Expected `keys` to contain {expected_keys}, but got {user_code.keys}."
        )

    def test_all_books_variable_is_declared(self):
        import user_code
        _dynamic_test(
            self,
            hasattr(user_code, 'all_books'),
            "The `all_books` list is declared.",
            "Expected `all_books` to be declared."
        )

    def test_all_books_variable_is_list(self):
        import user_code
        _dynamic_test(
            self,
            isinstance(user_code.all_books, list),
            "The `all_books` is of type `list`.",
            "Expected `all_books` to be of type `list`."
        )

    def test_all_books_contains_all_titles(self):
        import user_code
        expected_books = [book for books in user_code.authors_books.values() for book in books]
        _dynamic_test(
            self,
            set(user_code.all_books) == set(expected_books),
            "The `all_books` list contains all book titles.",
            f"Expected `all_books` to contain {expected_books}, but got {user_code.all_books}."
        )

    def test_append_method_used(self):
        with open('user_code.py', 'r') as file:
            user_code_source = file.read()
        _dynamic_test(
            self,
            ".append(" in user_code_source,
            "The `append()` method is used for adding books.",
            "Expected the `append()` method to be used to add books."
        )

    def test_keys_method_used(self):
        with open('user_code.py', 'r') as file:
            user_code_source = file.read()
        _dynamic_test(
            self,
            ".keys(" in user_code_source,
            "The `keys()` method is used.",
            "Expected the `keys()` method to be used."
        )

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.

Accesso alle Chiavi del Dizionario

Iterazione sulle chiavi

Verifica dell'esistenza di una chiave

Soluzione