Summary  
This chapter covers how to create and use Python dictionaries, including the syntax for defining key–value pairs, the requirement that keys be immutable, and the behavior when duplicate keys are provided.  

General domain of usage  
Library cataloging

This video summarizes the key concepts from the 'Creating a Dictionary' chapter in the 'Mastering Python Dictionaries' section. You will learn what a Python dictionary is—an ordered, mutable collection that maps unique, immutable keys to values of any type. The video explains the basic syntax for creating dictionaries using curly braces `{}` and demonstrates how to use both strings and numbers as keys. You'll see why only immutable types like strings, numbers, and tuples can be used as keys, and what happens when you use duplicate keys—the last value provided for a key will overwrite any previous value. The video walks through real examples, such as representing book details and mapping library shelves, and discusses the code samples shown in the chapter. Finally, it reviews the interactive task where you create a `library` dictionary to store book titles and authors, reinforcing how to properly construct and use dictionaries in Python.

-- 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.

Um **dicionário Python** é uma coleção **ordenada** e **mutável** de chaves únicas e imutáveis mapeadas para valores de qualquer tipo, preservando a ordem de inserção e permitindo acesso, adição, atualização e remoção eficientes de itens pela chave.

Definição

A sintaxe básica para criar um dicionário é a seguinte:
``` python
dictionary_name = {
    key1: value1,
    key2: value2,
    key3: value3
}
```
- **Chaves**: devem ser **imutáveis** (por exemplo, strings, números, tuplas). Uma lista ou outro dicionário não pode ser uma chave;
- **Valores**: podem ser de qualquer tipo de dado (por exemplo, strings, números, listas, outros dicionários).

Imagine que você está gerenciando uma biblioteca e deseja armazenar informações sobre um livro. Veja como criar um dicionário para representar os detalhes do livro:

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

Este dicionário utiliza strings como chaves para armazenar informações sobre o livro.

Dicionários permitem que as chaves sejam de qualquer tipo de dado **imutável**. Por exemplo, é possível usar números como chaves para criar um índice das prateleiras da biblioteca:

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

Neste exemplo, números são usados como chaves para mapear gêneros a prateleiras específicas da biblioteca.

Um **tipo de dado imutável** é um tipo de dado que não pode ser alterado após a criação. Exemplos incluem **strings**, **números** e **tuplas**.

Nota

### O que acontece se as chaves forem duplicadas em um dicionário?
Em Python, as chaves do dicionário devem ser **únicas**. Se chaves duplicadas forem fornecidas ao criar ou atualizar um dicionário, a última ocorrência da chave irá sobrescrever a anterior. Isso significa que o dicionário manterá apenas o valor mais recente associado a essa chave.

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

Neste caso, a segunda chave `"title"` com o valor `"Animal Farm"` sobrescreve a primeira chave `"title"`.

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_exactly_three_entries(self):
        import user_code
        _dynamic_test(
            self,
            len(user_code.library) == 3,
            "The `library` contains exactly three books.",
            f"Expected `library` to contain exactly 3 books, but got {len(user_code.library)}."
        )

    def test_library_keys_are_unique(self):
        import user_code
        keys = list(user_code.library.keys())
        unique_keys = set(keys)
        _dynamic_test(
            self,
            len(keys) == len(unique_keys),
            "All book titles (keys) in `library` are unique.",
            "Duplicate keys detected in the `library` dictionary. Each book title must appear only once as a key."
        )

    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 as estruturas de dados fundamentais da linguagem de programação Python, incluindo listas, dicionários, tuplas e conjuntos, e aprenda como aplicá-las de forma eficaz para resolver desafios de programação do mundo real.

O que é uma lista? Uma lista é uma coleção ordenada que pode ser modificada. Ela também permite elementos duplicados.

O que é um dicionário? Um dicionário é uma coleção ordenada que pode ser modificada, mas não permite entradas duplicadas. Ele consiste em pares chave:valor, que são utilizados para otimizar sua estrutura.

O que é uma tupla? Uma tupla é uma coleção ordenada que não pode ser alterada. Ela pode conter elementos duplicados. Embora seja semelhante a uma lista, os valores em uma tupla podem ser de qualquer tipo e são indexados por inteiros. Embora não seja obrigatório, é comum envolver os valores de uma tupla entre parênteses, facilitando a compreensão em Python.

O que é um conjunto? Em Python, um conjunto é uma coleção não ordenada que é iterável e mutável, sem elementos repetidos. Embora a ordem dos itens em um conjunto não seja fixa, ele pode incluir uma variedade de elementos. Um benefício importante de usar conjuntos em vez de listas é o método altamente eficiente para determinar se um elemento existe dentro do conjunto.

Criando um Dicionário

O que acontece se as chaves forem duplicadas em um dicionário?

Solução