Just like in other data structures, the `clear()` method completely wipes out all the elements.

Let's say you have a set of favorite movies, but you decide to start fresh and clear the collection:

# Define a set of favorite movies
movies = {"Inception", "Interstellar", "Tenet"}
print("Original set:", movies)

# Clear the set
movies.clear()
print("After clearing:", movies)

import unittest

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

    def test_worst_movies_is_set(self):
        import user_code
        _dynamic_test(
            self,
            isinstance(user_code.worst_movies, set),
            "The `worst_movies` is of type `set`.",
            "Expected `worst_movies` to be of type `set`."
        )

    def test_worst_movies_is_empty(self):
        import user_code
        _dynamic_test(
            self,
            len(user_code.worst_movies) == 0,
            "The `worst_movies` set is cleared.",
            f"Expected `worst_movies` to be empty, but got {user_code.worst_movies}."
        )

    def test_clear_method_used(self):
        """
        Test to ensure `clear()` method is used in the solution.
        """
        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 clear the set.",
            "Expected the `clear()` method to be used to clear the set."
        )

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.

Using the clear() Method: Removing All Elements from a Set

Solution

Using the clear() Method: Removing All Elements from a Set

Solution