Os dicionários também têm um método `popitem()` que remove e retorna o último par chave-valor.

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

# Removing the last key-value pair using popitem()
popped_item = book.popitem()

# Printing the updated dictionary and the removed pair
print("Removed item:", popped_item)
print("Updated dictionary:", book)

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

    def test_removed_element_was_last(self):
        import user_code
        expected_last_key = 'Agatha Christie'
        _dynamic_test(
            self,
            isinstance(user_code.removed_element, tuple) and user_code.removed_element[0] == expected_last_key,
            "The last element was correctly removed using `popitem()`.",
            "Expected only the last element to be removed using `popitem()`"
        )

    def test_mark_twain_is_added(self):
        import user_code
        expected_books = [
            'The Adventures of Tom Sawyer',
            'Adventures of Huckleberry Finn',
            'The Prince and the Pauper'
        ]
        _dynamic_test(
            self,
            'Mark Twain' in user_code.authors_books and user_code.authors_books['Mark Twain'] == expected_books,
            "The `Mark Twain` entry was added correctly.",
            "Expected `Mark Twain` to be in `authors_books` with the correct book list."
        )

    def test_other_authors_exist(self):
        import user_code
        expected_authors = {
            'William Shakespeare', 'J.K. Rowling', 'George Orwell', 'Stephen King'
        }
        _dynamic_test(
            self,
            expected_authors.issubset(set(user_code.authors_books.keys())),
            "Other authors are still present in `authors_books`.",
            "Some expected authors are missing from `authors_books`."
        )

    def test_popitem_method_used(self):
        with open('user_code.py', 'r') as file:
            user_code_source = file.read()
        _dynamic_test(
            self,
            "popitem()" in user_code_source,
            "The `popitem()` method is used to remove the last element.",
            "Expected the `popitem()` method to be used to remove the last element."
        )

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

test_main.py

Neste curso, você conhecerá as estruturas de dados fundamentais da linguagem de programação Python. Exploraremos a utilização das estruturas de dados nativas do Python, como listas, dicionários, tuplas e conjuntos, para enfrentar diferentes desafios.

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 alterada, mas não permite entradas duplicadas. Consiste em pares `chave:valor`, que são usados para otimizar sua estrutura.

O que é uma tupla? Uma tupla é uma coleção ordenada que não pode ser alterada. Ela pode ter 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 colocar os valores de uma tupla entre parênteses, tornando-os mais fáceis de entender em Python.

O que é um conjunto? Em Python, um `set` é uma coleção não ordenada que é tanto `iterável` quanto `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 chave de usar conjuntos em vez de listas é seu método altamente eficiente para determinar se um elemento existe dentro do conjunto.

Usando o Método popitem(): Removendo o Último Item Inserido

Solução

Usando o Método popitem(): Removendo o Último Item Inserido

Solução