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

For å få tilgang til nøklene i et dictionary i Python, kan du bruke metoden `keys()`. Denne returnerer et view-objekt som viser alle nøklene 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'])

### Iterere gjennom nøkler
Du kan iterere gjennom nøklene i et dictionary ved å bruke en `for`-løkke:

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

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

### Sjekke om en nøkkel finnes
Bruk nøkkelordet in for å sjekke om en bestemt nøkkel finnes i ordboken:

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

Utforsk de grunnleggende datastrukturene i programmeringsspråket Python, inkludert lister, ordbøker, tupler og mengder, og lær hvordan de kan brukes effektivt for å løse virkelige programmeringsutfordringer.

Hva er en liste? En liste er en ordnet samling som kan endres. Den tillater også dupliserte elementer.

Hva er en ordbok? En ordbok er en ordnet samling som kan endres, men den tillater ikke dupliserte oppføringer. Den består av `key:value`-par, som brukes til å optimalisere strukturen.

Hva er en tuple? En tuple er en ordnet samling som ikke kan endres. Den kan ha dupliserte elementer. Selv om den ligner på en liste, kan verdiene i en tuple være av hvilken som helst type og er indeksert med heltall. Selv om det ikke er obligatorisk, er det vanlig å omslutte verdiene i en tuple med parenteser, noe som gjør dem lettere å forstå i Python.

Hva er et sett? I Python er et `set` en uordnet samling som er både `iterable` og `mutable`, uten gjentatte elementer. Selv om rekkefølgen av elementer i et sett ikke er fast, kan det inkludere en rekke elementer. En viktig fordel med å bruke sett over lister er deres svært effektive metode for å avgjøre om et element eksisterer innenfor settet.

Tilgang til nøklene i ordbøker

Iterere gjennom nøkler

Sjekke om en nøkkel finnes

Løsning