Summary  
This chapter covers how to retrieve all keys from a dictionary, iterate through those keys, and check whether a specific key exists using the `keys()` method and the `in` keyword.

General domain of usage  
Library catalog management

Om toegang te krijgen tot de sleutels van een dictionary in Python, kun je de methode `keys()` gebruiken. Deze methode retourneert een view-object dat alle sleutels in de dictionary weergeeft.

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

### Itereren door sleutels
Je kunt door de sleutels van een dictionary itereren met een `for`-lus:

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

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

### Controleren of een sleutel bestaat
Gebruik het sleutelwoord in om te controleren of een specifieke sleutel in het woordenboek aanwezig is:

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

Ontdek de fundamentele datastructuren van de programmeertaal Python, waaronder lijsten, woordenboeken, tuples en sets, en leer hoe u deze effectief kunt toepassen om echte programmeeruitdagingen op te lossen.

Wat is een lijst? Een lijst is een geordende verzameling die kan worden gewijzigd. Het staat ook dubbele elementen toe.

Wat is een woordenboek? Een woordenboek is een geordende verzameling die kan worden gewijzigd, maar het staat geen dubbele invoer toe. Het bestaat uit `key:value` paren, die worden gebruikt om de structuur te optimaliseren.

Wat is een tuple? Een tuple is een geordende verzameling die niet kan worden gewijzigd. Het kan dubbele elementen bevatten. Hoewel het vergelijkbaar is met een lijst, kunnen de waarden in een tuple van elk type zijn en worden geïndexeerd door gehele getallen. Hoewel het niet verplicht is, is het gebruikelijk om de waarden van een tuple tussen haakjes te plaatsen, waardoor ze gemakkelijker te begrijpen zijn in Python.

Wat is een set? In Python is een `set` een ongeordende verzameling die zowel `iterable` als `mutable` is, zonder herhaalde elementen. Hoewel de volgorde van items in een set niet vastligt, kan het een verscheidenheid aan elementen bevatten. Een belangrijk voordeel van het gebruik van sets boven lijsten is hun zeer efficiënte methode om te bepalen of een element binnen de set bestaat.

Toegang tot Dictionary-sleutels

Itereren door sleutels

Controleren of een sleutel bestaat

Oplossing