Summary  
This chapter demonstrates how to retrieve values from a Python dictionary by referencing their keys and assigning them to variables.

General domain of usage  
Library catalog management

La oss lage et oppslagsverk for å representere en bok i et bibliotek:

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

Dette oppslagsverket inneholder tre nøkkel-verdi-par:

I et ordbok kan du hente et element ved å referere til nøkkelen. Her er et eksempel på hvordan du får tilgang til utgivelsesåret for boken:

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

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

I den oppgitte koden:

- Python søker etter nøkkelen `"year"` i ordboken book;
- 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 spesifikk 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_shekspeares_books_is_declared(self):
        import user_code
        _dynamic_test(
            self,
            hasattr(user_code, 'shakspeares_books'),
            "The `shakspeares_books` list is declared.",
            "Expected `shakspeares_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_shekspeares_books_is_list(self):
        import user_code
        _dynamic_test(
            self,
            isinstance(user_code.shakspeares_books, list),
            "The `shakspeares_books` is of type `list`.",
            "Expected `shakspeares_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_shekspeares_books_correct_values(self):
        import user_code
        expected_books = ['Hamlet', 'Macbeth', 'Romeo and Juliet', 'Othello']
        _dynamic_test(
            self,
            user_code.shakspeares_books == expected_books,
            "The `shakspeares_books` list contains the correct books.",
            f"Expected `shekspeares_books` to be {expected_books}, but got {user_code.shakspeares_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 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 Ordbokverdier

Løsning