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

General domain of usage  
Structured data processing

In this video, you will learn how to access dictionary keys in Python. Discover how the `keys()` method works to retrieve all keys from a dictionary as a view object. See how to iterate through dictionary keys using a `for` loop, and how to check if a specific key exists in the dictionary with the `in` keyword.

Key points covered:

- Using `keys()` to get all keys from a dictionary;
- Iterating through keys with a `for` loop;
- Checking for the existence of a key using `in`;
- Practical code examples:

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

# Access all keys
dict_keys_obj = book.keys()
print(dict_keys_obj)  # Output: dict_keys(['title', 'author', 'year', 'genre'])

# Iterate through keys
for key in book.keys():
    print(key)

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

By the end of this video, you will be able to confidently access, iterate, and check for keys in any Python dictionary.

-- 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.

Um auf die Schlüssel eines Dictionaries in Python zuzugreifen, kann die Methode `keys()` verwendet werden. Diese gibt ein View-Objekt zurück, das alle Schlüssel im Dictionary 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'])

### Durchlaufen von Schlüsseln
Die Schlüssel eines Dictionaries können mit einer `for`-Schleife durchlaufen werden:

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

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

### Überprüfen auf das Vorhandensein eines Schlüssels
Das Schlüsselwort `in` verwenden, um zu prüfen, ob ein bestimmter Schlüssel im Dictionary 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. Please ensure you have a variable named 'authors_books'."
        )

    def test_authors_books_is_dict(self):
        import user_code
        _dynamic_test(
            self,
            hasattr(user_code, 'authors_books') and 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` variable is declared.",
            "Expected `keys` to be declared. Please ensure you have a variable named 'keys'."
        )

    def test_keys_contains_correct_values(self):
        import user_code
        _dynamic_test(
            self,
            hasattr(user_code, 'authors_books') and hasattr(user_code, 'keys'),
            "Both `authors_books` and `keys` are present.",
            "Missing either 'authors_books' or 'keys'. Please check your variable names."
        )
        expected_keys = list(user_code.authors_books.keys())
        # Accept both dict_keys and list types for keys
        user_keys = user_code.keys
        if hasattr(user_keys, '__iter__'):
            user_keys_list = list(user_keys)
        else:
            user_keys_list = []
        _dynamic_test(
            self,
            set(user_keys_list) == set(expected_keys),
            "The `keys` variable contains the correct author names.",
            f"Expected `keys` to contain {expected_keys}, but got {user_keys_list}."
        )

    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. Please ensure you have a variable named 'all_books'."
        )

    def test_all_books_variable_is_list(self):
        import user_code
        _dynamic_test(
            self,
            hasattr(user_code, 'all_books') and 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
        _dynamic_test(
            self,
            hasattr(user_code, 'authors_books') and hasattr(user_code, 'all_books'),
            "Both `authors_books` and `all_books` are present.",
            "Missing either 'authors_books' or 'all_books'. Please check your variable names."
        )
        expected_books = [book for books in user_code.authors_books.values() for book in books]
        actual_books = user_code.all_books if hasattr(user_code, 'all_books') else []
        _dynamic_test(
            self,
            set(actual_books) == set(expected_books),
            "The `all_books` list contains all book titles.",
            f"Expected `all_books` to contain {expected_books}, but got {actual_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 Sets, und erfahren Sie, wie Sie diese effektiv zur Lösung praxisnaher Programmieraufgaben einsetzen können.

Was ist eine Liste? Eine Liste ist eine geordnete Sammlung, die verändert werden kann. Sie erlaubt außerdem doppelte Elemente.

Was ist ein Dictionary? Ein Dictionary ist eine geordnete, veränderbare Sammlung, die keine doppelten Einträge zulässt. Es besteht aus Schlüssel:Wert-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 ähnelt, können die Werte in einem Tupel beliebigen Typs sein und werden durch Ganzzahlen indiziert. Es ist zwar nicht zwingend erforderlich, aber es ist ü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 Menge eine ungeordnete Sammlung, die sowohl iterierbar als auch veränderbar ist und keine doppelten Elemente enthält. Obwohl die Reihenfolge der Elemente in einer Menge nicht festgelegt ist, kann sie verschiedene Elemente umfassen. Ein wesentlicher Vorteil der Verwendung von Mengen gegenüber Listen ist die äußerst effiziente Methode zur Überprüfung, ob ein Element in der Menge vorhanden ist.

Zugriff auf Dictionary-Schlüssel

Durchlaufen von Schlüsseln

Überprüfen auf das Vorhandensein eines Schlüssels

Lösung