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

Let's build a dictionary to represent a book in a library:

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

This dictionary includes three key-value pairs:

In a dictionary, you can retrieve an item by referencing its key. Here's an example of accessing the publication year of the book:

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

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

In the code provided:

- Python searches for the key `"year"` in the book dictionary;
- It retrieves the value associated with the key (`1813`) and assigns it to the variable `publication_year`.

The value is then printed, demonstrating how keys allow quick and specific access to dictionary values.

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

In this course, you'll get to know the fundamental data structures of the Python programming language. We'll explore utilizing Python's native data structures like lists, dictionaries, tuples, and sets to tackle different challenges.

What is a list? A list is an ordered collection that can be modified. It also allows for duplicate elements.

What is a dictionary? A dictionary is an ordered collection that can be changed, but it doesn't allow duplicate entries. It consists of `key:value` pairs, which are used to optimize its structure.

What is a tuple? A tuple is an ordered collection that cannot be altered. It can have duplicate elements. While it's similar to a list, the values in a tuple can be of any type and are indexed by integers. Although not mandatory, it's common to enclose the values of a tuple in parentheses, making them easier to understand in Python.

What is a set? In Python, a `set` is an unordered collection that is both `iterable` and `mutable`, with no repeated elements. While the order of items in a set isn't fixed, it can include a variety of elements. A key benefit of using sets over lists is their highly efficient method for determining if an element exists within the set.

Accessing Dictionary Values

Solution

Awesome!

Accessing Dictionary Values

Solution

Awesome!