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

General domain of usage  
Data processing and manipulation

Um auf die Schlüssel eines Wörterbuchs in Python zuzugreifen, können Sie die Methode `keys()` verwenden. Diese gibt ein View-Objekt zurück, das alle Schlüssel im Wörterbuch anzeigt.

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

### Durch Schlüssel iterieren
Sie können mit einer `for`-Schleife durch die Schlüssel in einem Wörterbuch iterieren:

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

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

### Überprüfung auf das Vorhandensein eines Schlüssels
Verwenden Sie das Schlüsselwort in, um zu überprüfen, ob ein bestimmter Schlüssel im Wörterbuch vorhanden ist:

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

Erkunden Sie die grundlegenden Datenstrukturen der Programmiersprache Python, einschließlich Listen, Dictionaries, Tupel und Mengen, und erfahren Sie, wie diese effektiv zur Lösung praxisnaher Programmieraufgaben eingesetzt werden können.

Was ist eine Liste? Eine Liste ist eine geordnete Sammlung, die modifiziert werden kann. Sie erlaubt auch doppelte Elemente.

Was ist ein Wörterbuch? Ein Wörterbuch ist eine geordnete Sammlung, die geändert werden kann, aber keine doppelten Einträge zulässt. Es besteht aus `key:value`-Paaren, die zur Optimierung seiner Struktur verwendet werden.

Was ist ein Tupel? Ein Tupel ist eine geordnete Sammlung, die nicht verändert werden kann. Es kann doppelte Elemente enthalten. Obwohl es einer Liste ähnlich ist, können die Werte in einem Tupel von jedem Typ sein und werden durch ganze Zahlen indiziert. Obwohl es nicht zwingend erforderlich ist, ist es üblich, die Werte eines Tupels in Klammern zu setzen, um sie in Python leichter verständlich zu machen.

Was ist eine Menge? In Python ist eine `set` eine ungeordnete Sammlung, die sowohl `iterierbar` als auch `veränderbar` ist, ohne wiederholte Elemente. Während die Reihenfolge der Elemente in einer Menge nicht festgelegt ist, kann sie eine Vielzahl von Elementen enthalten. Ein wesentlicher Vorteil der Verwendung von Mengen gegenüber Listen ist ihre hocheffiziente Methode zur Bestimmung, ob ein Element innerhalb der Menge existiert.

Zugriff auf Wörterbuchschlüssel

Durch Schlüssel iterieren

Überprüfung auf das Vorhandensein eines Schlüssels

Lösung