Los diccionarios también ofrecen un útil método `clear()` que elimina todos los elementos, dejándote con un diccionario vacío. Así es como funciona.

# Creating a dictionary for book details
book = {
    "title": "Pride and Prejudice",
    "author": "Jane Austen",
    "year": 1813,
    "genre": "Romance"
}

# Printing the dictionary before clearing
print("Before clearing:", book)

# Clearing all items from the dictionary
book.clear()

# Printing the dictionary after clearing
print("After clearing:", 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_authors_books_is_empty(self):
        import user_code
        _dynamic_test(
            self,
            len(user_code.authors_books) == 0,
            "The `authors_books` dictionary is empty after using `clear()`.",
            "Expected `authors_books` to be empty after using `clear()`, but it is not."
        )

    def test_clear_method_used(self):
        with open('user_code.py', 'r') as file:
            user_code_source = file.read()
        _dynamic_test(
            self,
            ".clear(" in user_code_source,
            "The `clear()` method is used to empty the dictionary.",
            "Expected the `clear()` method to be used to empty the dictionary."
        )

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


test_main.py

En este curso, conocerás las estructuras de datos fundamentales del lenguaje de programación Python. Exploraremos el uso de las estructuras de datos nativas de Python como listas, diccionarios, tuplas y conjuntos para abordar diferentes desafíos.

¿Qué es una lista? Una lista es una colección ordenada que se puede modificar. También permite elementos duplicados.

¿Qué es un diccionario? Un diccionario es una colección ordenada que se puede cambiar, pero no permite entradas duplicadas. Consiste en pares `clave:valor`, que se utilizan para optimizar su estructura.

¿Qué es una tupla? Una tupla es una colección ordenada que no puede ser alterada. Puede tener elementos duplicados. Aunque es similar a una lista, los valores en una tupla pueden ser de cualquier tipo y están indexados por enteros. Aunque no es obligatorio, es común encerrar los valores de una tupla entre paréntesis, lo que los hace más fáciles de entender en Python.

¿Qué es un conjunto? En Python, un `set` es una colección desordenada que es tanto `iterable` como `mutable`, sin elementos repetidos. Aunque el orden de los elementos en un conjunto no está fijado, puede incluir una variedad de elementos. Un beneficio clave de usar conjuntos sobre listas es su método altamente eficiente para determinar si un elemento existe dentro del conjunto.

Usando el Método clear(): Vaciar un Diccionario Completamente

Solución

Usando el Método clear(): Vaciar un Diccionario Completamente

Solución