Summary  
This chapter explains how to define and manipulate Python sets—unordered, mutable collections that automatically enforce element uniqueness—by using curly-brace literals or the set() constructor and highlights rules for handling duplicates and required input types.

General domain of usage  
Data deduplication

Un **set** en Python es una **colección desordenada de elementos únicos**. A diferencia de las listas o tuplas, los sets **no permiten elementos duplicados**, lo que los hace ideales para operaciones como eliminar duplicados o realizar operaciones matemáticas de conjuntos. Los sets son **mutables**, lo que significa que se pueden agregar o eliminar elementos, pero los **datos dentro del set deben ser inmutables** (por ejemplo, números, cadenas o tuplas).

Un set no puede contener diccionarios ni listas porque ambos son tipos de datos mutables.

Nota

Existen dos formas principales de crear un set en Python:
1. Usando llaves `{}` con elementos separados por **comas**;
2. Usando la función `set()`.

Algunos puntos clave sobre los sets:
 - **Son mutables:** se pueden agregar o eliminar elementos de un set, pero el set en sí debe contener elementos inmutables;
 - **Elementos duplicados:**
si se agregan elementos duplicados a un set, se eliminan automáticamente;
 - **Desordenados:**
el orden de los elementos en un set no está garantizado y puede variar;
 - **Diversos tipos de datos:**
los sets pueden contener elementos de diferentes tipos de datos, como **cadenas**, **enteros** o **tuplas**.

Definición de un set usando la función `set()`: 

# Creating a set which contains strings
movie_set = set("Interstellar")
print(movie_set)

A continuación, definición de un conjunto de películas populares utilizando llaves:

# Creating a set of movies using curly braces
movies = {"Inception", "Interstellar", "Tenet", "Dunkirk", "Tenet"}
print(movies)

Las entradas duplicadas como `"Tenet"` se eliminan automáticamente cuando se crea el conjunto.

### Limitaciones al crear conjuntos
La sintaxis para crear un conjunto usando la función `set()` tiene requisitos específicos. Si intentas pasar varios argumentos directamente, como:
``` python
set("Tenet", "Dunkirk", "Inception")
```
Aparecerá un `TypeError`, porque la función `set()` espera un **único iterable** como argumento, no varios valores separados.

Para crear un conjunto con varios elementos, debes proporcionarlos como un solo iterable:

# Using a list `[]`
movies = set(["Tenet", "Dunkirk", "Inception"])
print(movies)

# Using a tuple `(,)`
movies = set(("Tenet", "Dunkirk", "Inception"))
print(movies)

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

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

    def test_nolan_movies_contains_correct_values(self):
        import user_code
        expected_movies = {"Inception", "The Dark Knight", "Interstellar", "Tenet"}
        _dynamic_test(
            self,
            user_code.nolan_movies == expected_movies,
            f"The `nolan_movies` contains `{expected_movies}`.",
            f"Expected `nolan_movies` to contain `{expected_movies}`, but got `{user_code.nolan_movies}`."
        )

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

test_main.py

Explora las estructuras de datos fundamentales del lenguaje de programación Python, incluyendo listas, diccionarios, tuplas y conjuntos, y aprende cómo aplicarlas de manera efectiva para resolver desafíos de programación del mundo real.

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

¿Qué es un diccionario? Un diccionario es una colección ordenada que puede modificarse, 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 modificada. Puede contener 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 facilita su comprensión en Python.

¿Qué es un conjunto? En Python, un conjunto 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á definido, puede incluir una variedad de elementos. Un beneficio clave de usar conjuntos en lugar de listas es su método altamente eficiente para determinar si un elemento existe dentro del conjunto.

Creación de un Conjunto en Python: Definición de Colecciones Desordenadas

Limitaciones al crear conjuntos

Solución