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.

La oss lage et dictionary som representerer en bok i et bibliotek:

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

Dette dictionary-et inneholder tre nøkkel-verdi-par:

I et dictionary kan du hente et element ved å referere til nøkkelen. Her er et eksempel på hvordan du får tak i publiseringsåret til boken:

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

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

I den gitte koden:

- Python søker etter nøkkelen `"year"` i bok-ordboken;
- Den henter verdien som er tilknyttet nøkkelen (`1813`) og tildeler den til variabelen `publication_year`.

Verdien skrives deretter ut, noe som viser hvordan nøkler gir rask og presis tilgang til verdier i ordboken.

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

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

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

Hva er et dictionary? Et dictionary er en ordnet samling som kan endres, men tillater ikke dupliserte oppføringer. Det består av nøkkel:verdi-par, som brukes for å optimalisere strukturen.

Hva er en tuple? En tuple er en ordnet samling som ikke kan endres. Den kan inneholde 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 påkrevd, 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 sett en uordnet samling som både er itererbar og muterbar, uten gjentatte elementer. Selv om rekkefølgen på elementene i et sett ikke er fast, kan det inneholde ulike typer elementer. En viktig fordel med å bruke sett fremfor lister er den svært effektive metoden for å avgjøre om et element finnes i settet.

Tilgang til Ordbokverdier

Tilgang til Ordbokverdier

Løsning