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.

Vi skapar ett dictionary för att representera en bok i ett bibliotek:

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

Detta dictionary innehåller tre nyckel-värdepar:

I en ordbok kan du hämta ett objekt genom att referera till dess nyckel. Här är ett exempel på hur du får tillgång till bokens publiceringsår:

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

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

I den angivna koden:

- Python söker efter nyckeln `"year"` i bokordlistan;
- Den hämtar värdet som är kopplat till nyckeln (`1813`) och tilldelar det till variabeln `publication_year`.

Värdet skrivs sedan ut, vilket visar hur nycklar möjliggör snabb och specifik åtkomst till värden i en ordlista.

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

Utforska de grundläggande datastrukturerna i programmeringsspråket Python, inklusive listor, ordböcker, tupler och mängder, och lär dig hur dessa kan tillämpas effektivt för att lösa verkliga programmeringsutmaningar.

Vad är en lista? En lista är en ordnad samling som kan modifieras. Den tillåter också dubbletter av element.

Vad är en dictionary? En dictionary är en ordnad samling som kan ändras, men den tillåter inte dubbletter. Den består av nyckel:värde-par, vilka används för att optimera dess struktur.

Vad är en tuple? En tuple är en ordnad samling som inte kan ändras. Den kan innehålla duplicerade element. Även om den liknar en lista kan värdena i en tuple vara av vilken typ som helst och indexeras med heltal. Det är vanligt, men inte obligatoriskt, att omsluta tuple-värden med parenteser, vilket gör dem lättare att förstå i Python.

Vad är en mängd? I Python är en mängd en oordnad samling som är både itererbar och muterbar, utan upprepade element. Även om ordningen på objekten i en mängd inte är fast, kan den innehålla olika typer av element. En viktig fördel med att använda mängder istället för listor är deras mycket effektiva metod för att avgöra om ett element finns i mängden.

Åtkomst till Ordboksvärden

Åtkomst till Ordboksvärden

Lösning