Summary  
The chapter demonstrates how to use Python’s set.update() method to merge multiple elements from iterables into an existing set without duplicates and prints the updated set.

General domain of usage  
Data processing

The `update()` method in Python allows you to **add multiple elements** to a set at once. This method takes an iterable (like a **list**, **tuple**, or another **set**) and adds its elements to the existing set.

The `update()` method can accept:
- **Lists:** `[movie1, movie2, ...]`;
- **Tuples:** `(movie1, movie2, ...)`;
- **Other Sets:** `{movie1, movie2, ...}`.

# Original set of favorite movies
favorite_movies = {"Inception", "Interstellar", "Tenet"}

# Adding multiple new movies
favorite_movies.update(["Tenet", "Memento", "The Prestige"])

# Print the updated set
print(favorite_movies)

> Note
>
> If any element being added already exists in the set, it will not be duplicated.
The order of elements in a set is not guaranteed and may vary.

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

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

    def test_movies_to_add_is_declared(self):
        import user_code
        _dynamic_test(
            self,
            hasattr(user_code, 'movies_to_add'),
            "The `movies_to_add` tuple is declared.",
            "Expected `movies_to_add` to be declared."
        )

    def test_movies_to_add_is_tuple(self):
        import user_code
        _dynamic_test(
            self,
            isinstance(user_code.movies_to_add, tuple),
            "The `movies_to_add` is of type `tuple`.",
            "Expected `movies_to_add` to be of type `tuple`."
        )

    def test_marvel_movies_contains_initial_movies(self):
        import user_code
        initial_movies = {
            'Avengers: Endgame',
            'Black Panther',
            'Iron Man'
        }
        _dynamic_test(
            self,
            initial_movies.issubset(user_code.marvel_movies),
            f"The `marvel_movies` contains the initial movies: {initial_movies}.",
            f"Expected `marvel_movies` to contain the initial movies: {initial_movies}, but got {user_code.marvel_movies}."
        )

    def test_marvel_movies_contains_new_movies(self):
        import user_code
        new_movies = {'Spider-Man: No Way Home', 'Guardians of the Galaxy'}
        _dynamic_test(
            self,
            new_movies.issubset(user_code.marvel_movies),
            f"The `marvel_movies` contains the newly added movies: {new_movies}.",
            f"Expected `marvel_movies` to contain the newly added movies: {new_movies}, but got {user_code.marvel_movies}."
        )

    def test_update_method_used(self):
        with open('user_code.py', 'r') as file:
            user_code_source = file.read()
        _dynamic_test(
            self,
            "update" in user_code_source,
            "The `update()` method is used to add movies.",
            "Expected the `update()` method to be used to add movies."
        )

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 update() Method: Merging Multiple Elements into a Set

Solution

Awesome!

Using the update() Method: Merging Multiple Elements into a Set

Solution

Awesome!