Summary  
This chapter covers creating dictionaries in Python, including key/value syntax, the requirement that keys be immutable, and how duplicate keys overwrite previous entries.  

General domain of usage  
Library management

A **Python dictionary** is an **ordered**, **mutable** collection of unique, immutable keys mapped to values of any type, preserving insertion order and allowing efficient access, addition, update, and removal of items by key.

Definition

The basic syntax for creating a dictionary is as follows:

``` python
dictionary_name = {
    key1: value1,
    key2: value2,
    key3: value3
}
```

- **Keys**: must be **immutable** (e.g., strings, numbers, tuples). A list or another dictionary cannot be the key;
- **Values**: can be any data type (e.g., strings, numbers, lists, other dictionaries).

Imagine you are managing a library and want to store information about a book. Here's how you can create a dictionary to represent the book's details:

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

This dictionary uses strings as keys to store information about the book.

Dictionaries allow keys to be any **immutable** data type. For instance, you can use numbers as keys to create an index of library shelves:

shelves = {1: "Classics", 2: "Science Fiction", 3: "Mystery", 4: "Non-fiction"}
print(shelves)

In this example, numbers are keys to map genres to specific library shelves.

An **immutable data type** is a type of data that cannot be changed after creation. Examples include **strings**, **numbers**, and **tuples**.

Note

### What happens if keys are duplicated in a dictionary?

In Python, dictionary keys must be **unique**. If duplicate keys are provided when creating or updating a dictionary, the last occurrence of the key will overwrite the previous one. This means the dictionary will only retain the most recent value associated with that key.

book = {"title": "1984", "author": "George Orwell", "title": "Animal Farm"}
print(book)  # Output: {'title': 'Animal Farm', 'author': 'George Orwell'}

In this case, the second `"title"` key with the value `"Animal Farm"` overwrites the first `"title"` key.

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

    def test_library_is_a_dict(self):
        import user_code
        _dynamic_test(
            self,
            isinstance(user_code.library, dict),
            "The `library` is of type `dict`.",
            "Expected `library` to be of type `dict`."
        )

    def test_library_contains_at_least_three_entries(self):
        import user_code
        _dynamic_test(
            self,
            len(user_code.library) >= 3,
            "The `library` contains at least three books.",
            f"Expected `library` to contain at least 3 books, but got {len(user_code.library)}."
        )

    def test_library_keys_are_strings(self):
        import user_code
        _dynamic_test(
            self,
            all(isinstance(key, str) for key in user_code.library.keys()),
            "All book titles (keys) in `library` are strings.",
            "Expected all book titles (keys) in `library` to be of type `str`."
        )

    def test_library_values_are_strings(self):
        import user_code
        _dynamic_test(
            self,
            all(isinstance(value, str) for value in user_code.library.values()),
            "All authors (values) in `library` are strings.",
            "Expected all authors (values) in `library` to be of type `str`."
        )

    def test_library_created_using_curly_braces(self):
        with open('user_code.py', 'r') as file:
            user_code_source = file.read()

        _dynamic_test(
            self,
            '{' in user_code_source and '}' in user_code_source,
            "The `library` dictionary was created using curly braces `{}`.",
            "Expected `library` to be created using `{}` (curly braces)."
        )

if __name__ == '__main__':
    unittest.main()

test_main.py

Explore the fundamental data structures of the Python programming language, including lists, dictionaries, tuples, and sets, and learn how to apply them effectively to solve real-world programming challenges.

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

Creating a Dictionary in Python

What happens if keys are duplicated in a dictionary?

解答