Summary  
This chapter explains how to use Python’s set.update() method to merge multiple iterables into an existing set.

General domain of usage  
Managing a user’s favorite movie collection.

El método `update()` en Python te permite **agregar múltiples elementos** a un conjunto a la vez. Este método toma un iterable (como una **lista**, **tupla** u otro **conjunto**) y agrega sus elementos al conjunto existente.

El método `update()` puede aceptar:
- **Listas:** `[movie1, movie2, ...]`;
- **Tuplas:** `(movie1, movie2, ...)`;
- **Otros Conjuntos:** `{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)

> Nota
>
> Si algún elemento que se está agregando ya existe en el conjunto, no se duplicará.
El orden de los elementos en un conjunto no está garantizado y puede variar.

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

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 update(): Fusionando Múltiples Elementos en un Conjunto

Solución

Awesome!

Usando el Método update(): Fusionando Múltiples Elementos en un Conjunto

Solución