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.

For at få adgang til nøglerne i et dictionary i Python, kan du bruge metoden `keys()`. Denne metode returnerer et view-objekt, der viser alle nøglerne i dictionaryen.

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

### Gennemløb af nøgler
Du kan gennemløbe nøglerne i et dictionary ved hjælp af en `for`-løkke:

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

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

### Kontrol af om en nøgle findes
Brug `in`-nøgleordet for at kontrollere, om en bestemt nøgle findes i ordbogen:

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

Udforsk de grundlæggende datastrukturer i programmeringssproget Python, herunder lister, ordbøger, tupler og mængder, og lær hvordan de anvendes effektivt til at løse virkelige programmeringsudfordringer.

Hvad er en liste? En liste er en ordnet samling, der kan ændres. Den tillader også duplikerede elementer.

Hvad er et dictionary? Et dictionary er en ordnet samling, der kan ændres, men ikke tillader dublerede elementer. Det består af nøgle:værdi-par, som bruges til at optimere dets struktur.

Hvad er et tuple? Et tuple er en ordnet samling, der ikke kan ændres. Det kan indeholde duplikerede elementer. Selvom det ligner en liste, kan værdierne i et tuple være af enhver type og er indekseret med heltal. Selvom det ikke er obligatorisk, er det almindeligt at omslutte værdierne i et tuple med parenteser, hvilket gør dem lettere at forstå i Python.

Hvad er et set? I Python er et set en uordnet samling, der både er itererbar og muterbar, uden gentagne elementer. Selvom rækkefølgen af elementer i et set ikke er fastlagt, kan det indeholde forskellige typer elementer. En vigtig fordel ved at bruge sets frem for lister er deres meget effektive metode til at afgøre, om et element findes i settet.

Adgang til Dictionary-nøgler

Gennemløb af nøgler

Kontrol af om en nøgle findes

Adgang til Dictionary-nøgler

Gennemløb af nøgler

Kontrol af om en nøgle findes

Løsning