Summary  
This chapter covers accessing values in a dictionary by using key-based indexing, assigning the result to a variable, and printing it—while noting that attempting to access a non-existent key raises a KeyError.  

General domain of usage  
Library catalog management

In this video, you will learn how to access values in a Python dictionary. You'll start by building a dictionary to represent a book, understanding how key-value pairs are structured. The video explains how to retrieve information from the dictionary by referencing a key—demonstrated by accessing the publication year of the book. You'll see how Python searches for the specified key and returns the associated value, making it easy to quickly find and use specific data in your programs.

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

Wir erstellen ein Dictionary, das ein Buch in einer Bibliothek repräsentiert:

book = {"title": "Pride and Prejudice", "author": "Jane Austen", "year": 1813}
print(book)

Dieses Dictionary enthält drei Schlüssel-Wert-Paare:

In einem Dictionary kann ein Element durch Angabe seines Schlüssels abgerufen werden. Beispiel für den Zugriff auf das Veröffentlichungsjahr eines Buches:

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

publication_year = book["year"]
print(publication_year)  # Output: 1813

Im bereitgestellten Code:

- Python sucht nach dem Schlüssel `"year"` im Buch-Dictionary;
- Der mit dem Schlüssel verknüpfte Wert (`1813`) wird abgerufen und der Variablen `publication_year` zugewiesen.

Anschließend wird der Wert ausgegeben, was zeigt, wie Schlüssel einen schnellen und gezielten Zugriff auf Dictionary-Werte ermöglichen.

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` dictionary 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_kings_books_is_declared(self):
        import user_code
        _dynamic_test(
            self,
            hasattr(user_code, 'kings_books'),
            "The `kings_books` list is declared.",
            "Expected `kings_books` to be declared."
        )

    def test_shakespeares_books_is_declared(self):
        import user_code
        _dynamic_test(
            self,
            hasattr(user_code, 'shakespeares_books'),
            "The `shakespeares_books` list is declared.",
            "Expected `shakespeares_books` to be declared."
        )

    def test_kings_books_is_list(self):
        import user_code
        _dynamic_test(
            self,
            isinstance(user_code.kings_books, list),
            "The `kings_books` is of type `list`.",
            "Expected `kings_books` to be of type `list`."
        )

    def test_shakespeares_books_is_list(self):
        import user_code
        _dynamic_test(
            self,
            isinstance(user_code.shakespeares_books, list),
            "The `shakespeares_books` is of type `list`.",
            "Expected `shakespeares_books` to be of type `list`."
        )

    def test_kings_books_correct_values(self):
        import user_code
        expected_books = ['It', 'The Shining', 'Carrie', 'Misery']
        _dynamic_test(
            self,
            user_code.kings_books == expected_books,
            "The `kings_books` list contains the correct books.",
            f"Expected `kings_books` to be {expected_books}, but got {user_code.kings_books}."
        )

    def test_shakespeares_books_correct_values(self):
        import user_code
        expected_books = ['Hamlet', 'Macbeth', 'Romeo and Juliet', 'Othello']
        _dynamic_test(
            self,
            user_code.shakespeares_books == expected_books,
            "The `shakespeares_books` list contains the correct books.",
            f"Expected `shakespeares_books` to be {expected_books}, but got {user_code.shakespeares_books}."
        )

    def test_books_are_retrieved_using_dict_indexing(self):
        with open('user_code.py', 'r') as file:
            user_code_source = file.read()
        
        _dynamic_test(
            self,
            "'Stephen King'" in user_code_source and "'William Shakespeare'" in user_code_source,
            "The books are retrieved using dictionary indexing.",
            "Expected the books to be retrieved using dictionary indexing."
        )

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.