Tutorial Python: Conjuntos

Elementos únicos

Los conjuntos (o sets) en Python representan una colección desordenada de elementos donde cada elemento aparece exactamente una vez. Esta característica de unicidad es fundamental y constituye la principal diferencia respecto a otras estructuras de datos como las listas o tuplas.

Imagina una fiesta donde cada invitado debe registrarse al entrar. La lista de asistentes sería similar a un conjunto: no importa cuántas veces intente registrarse una persona, su nombre aparecerá una sola vez en la lista final. Esta analogía ilustra perfectamente el comportamiento de los conjuntos en Python.

Creación de conjuntos

Existen dos formas principales de crear conjuntos en Python:

• Usando llaves {}:

colores = {"rojo", "verde", "azul", "rojo"}
print(colores)  # {'verde', 'azul', 'rojo'}

• Usando la función set():

numeros = set([1, 2, 3, 2, 1])
print(numeros)  # {1, 2, 3}

Observa cómo en ambos ejemplos, los elementos duplicados ("rojo" y los números 1 y 2) aparecen una sola vez en el resultado final. Python automáticamente elimina los duplicados al crear el conjunto.

Características de los elementos únicos

Los conjuntos en Python tienen varias propiedades importantes relacionadas con la unicidad:

• Eliminación automática de duplicados: Como ya vimos, al crear un conjunto, los elementos duplicados se eliminan automáticamente.

usuarios = set(["ana", "carlos", "ana", "elena", "carlos"])
print(usuarios)  # {'ana', 'elena', 'carlos'}

• Verificación de pertenencia eficiente: Comprobar si un elemento está en un conjunto es muy rápido, incluso con conjuntos grandes.

frutas = {"manzana", "naranja", "plátano"}
print("manzana" in frutas)  # True
print("uva" in frutas)      # False

• Inmutabilidad de los elementos: Los elementos de un conjunto deben ser inmutables (no modificables). Esto significa que puedes incluir números, cadenas o tuplas, pero no listas o diccionarios.

# Esto funciona (todos los elementos son inmutables)
conjunto_valido = {1, "hola", (1, 2)}

# Esto produce un error (las listas son mutables)
# conjunto_invalido = {1, [2, 3]}  # TypeError: unhashable type: 'list'

Casos de uso prácticos

La unicidad de los conjuntos los hace ideales para ciertas tareas:

• Eliminar duplicados de una secuencia:

# Eliminar duplicados de una lista manteniendo el orden original
def eliminar_duplicados(secuencia):
    return list(dict.fromkeys(secuencia))

lista_con_duplicados = [3, 1, 4, 1, 5, 9, 2, 6, 5]
print(eliminar_duplicados(lista_con_duplicados))  # [3, 1, 4, 5, 9, 2, 6]

• Encontrar elementos únicos entre colecciones:

grupo_a = {"Ana", "Carlos", "Elena", "David"}
grupo_b = {"Elena", "Fernando", "Gabriela", "Carlos"}

# Personas que están solo en el grupo A
solo_en_a = grupo_a - grupo_b
print(solo_en_a)  # {'Ana', 'David'}

• Verificar si todos los elementos son únicos:

def todos_unicos(items):
    return len(items) == len(set(items))

print(todos_unicos([1, 2, 3, 4]))     # True
print(todos_unicos([1, 2, 3, 1, 4]))  # False

Restricciones de los conjuntos

Debido a su implementación interna, los conjuntos tienen algunas limitaciones importantes:

• No mantienen un orden: A diferencia de las listas, los conjuntos no garantizan que los elementos mantengan el orden en que fueron insertados.

numeros = {3, 1, 4, 1, 5, 9}
print(numeros)  # El orden puede variar: {1, 3, 4, 5, 9}

• No permiten indexación: No puedes acceder a elementos por su posición.

colores = {"rojo", "verde", "azul"}
# Esto produce un error
# print(colores[0])  # TypeError: 'set' object is not subscriptable

• Solo aceptan elementos hashables: Como mencionamos antes, solo puedes incluir elementos inmutables en un conjunto.

Conjuntos vacíos

Un detalle importante a tener en cuenta es la creación de conjuntos vacíos. A diferencia de listas o diccionarios, no puedes usar llaves vacías para crear un conjunto vacío:

# Esto NO crea un conjunto vacío, sino un diccionario vacío
no_es_conjunto = {}
print(type(no_es_conjunto))  # <class 'dict'>

# Forma correcta de crear un conjunto vacío
conjunto_vacio = set()
print(type(conjunto_vacio))  # <class 'set'>

La unicidad de elementos en los conjuntos de Python proporciona una herramienta poderosa para muchas situaciones de programación donde necesitamos eliminar duplicados o realizar operaciones matemáticas de conjuntos, como veremos en las siguientes secciones.

Operaciones básicas

Una vez que hemos creado nuestros conjuntos, Python nos ofrece una serie de operaciones básicas que nos permiten manipularlos de forma eficiente. Estas operaciones nos ayudan a añadir, eliminar y modificar elementos, así como a realizar consultas sobre el conjunto.

Añadir elementos

Para añadir elementos a un conjunto existente, disponemos de dos métodos principales:

• add(): Añade un único elemento al conjunto.

tecnologias = {"Python", "JavaScript", "SQL"}
tecnologias.add("Java")
print(tecnologias)  # {'Python', 'JavaScript', 'SQL', 'Java'}

• update(): Añade múltiples elementos de una vez. Puede recibir cualquier iterable (lista, tupla, otro conjunto, etc.).

lenguajes = {"Python", "Java"}
nuevos_lenguajes = ["Go", "Rust", "TypeScript"]
lenguajes.update(nuevos_lenguajes)
print(lenguajes)  # {'Python', 'Java', 'Go', 'Rust', 'TypeScript'}

Recuerda que, debido a la propiedad de unicidad, si intentas añadir un elemento que ya existe en el conjunto, no se producirá ningún cambio:

numeros = {1, 2, 3}
numeros.add(2)  # Intentamos añadir un elemento que ya existe
print(numeros)  # {1, 2, 3} - No hay cambios

Eliminar elementos

Para eliminar elementos de un conjunto, tenemos varias opciones:

• remove(): Elimina un elemento específico. Lanza un error si el elemento no existe.

frutas = {"manzana", "naranja", "plátano"}
frutas.remove("naranja")
print(frutas)  # {'manzana', 'plátano'}

# Si intentamos eliminar un elemento que no existe:
# frutas.remove("uva")  # KeyError: 'uva'

• discard(): Similar a remove(), pero no lanza error si el elemento no existe.

animales = {"perro", "gato", "conejo"}
animales.discard("pájaro")  # No existe, pero no genera error
print(animales)  # {'perro', 'gato', 'conejo'}

• pop(): Elimina y devuelve un elemento aleatorio del conjunto. Útil cuando no importa qué elemento se elimine.

colores = {"rojo", "verde", "azul"}
color_eliminado = colores.pop()
print(f"Se eliminó: {color_eliminado}")
print(f"Conjunto resultante: {colores}")

• clear(): Elimina todos los elementos del conjunto, dejándolo vacío.

numeros = {1, 2, 3, 4, 5}
numeros.clear()
print(numeros)  # set()

Consultas básicas

Los conjuntos también ofrecen métodos para realizar consultas sobre su contenido:

• len(): Devuelve el número de elementos en el conjunto.

planetas = {"Mercurio", "Venus", "Tierra", "Marte"}
print(len(planetas))  # 4

• in: Comprueba si un elemento está en el conjunto (operación muy eficiente).

dias = {"lunes", "martes", "miércoles", "jueves", "viernes"}
print("sábado" in dias)  # False
print("lunes" in dias)   # True

• copy(): Crea una copia independiente del conjunto.

original = {1, 2, 3}
copia = original.copy()
copia.add(4)
print(original)  # {1, 2, 3} - No se modifica
print(copia)     # {1, 2, 3, 4}

Iteración sobre conjuntos

Podemos recorrer todos los elementos de un conjunto utilizando un bucle for:

ciudades = {"Madrid", "Barcelona", "Valencia", "Sevilla"}
for ciudad in ciudades:
    print(f"Visitando {ciudad}")

Es importante recordar que, al ser los conjuntos colecciones desordenadas, el orden en que se recorren los elementos puede variar entre ejecuciones.

Conversión entre tipos de datos

Es común necesitar convertir entre conjuntos y otros tipos de datos:

• De lista a conjunto (elimina duplicados):

lista_con_duplicados = [1, 2, 2, 3, 4, 4, 5]
conjunto_sin_duplicados = set(lista_con_duplicados)
print(conjunto_sin_duplicados)  # {1, 2, 3, 4, 5}

• De conjunto a lista (cuando necesitamos indexación):

conjunto = {"a", "b", "c", "d"}
lista = list(conjunto)
print(lista)  # ['a', 'b', 'c', 'd'] (el orden puede variar)

Comprobación de subconjuntos y superconjuntos

Python proporciona métodos para verificar relaciones entre conjuntos:

• issubset(): Comprueba si un conjunto es subconjunto de otro (todos sus elementos están en el otro).

numeros_pares = {2, 4, 6, 8}
numeros = {1, 2, 3, 4, 5, 6, 7, 8, 9}
print(numeros_pares.issubset(numeros))  # True

• issuperset(): Comprueba si un conjunto es superconjunto de otro (contiene todos los elementos del otro).

frutas = {"manzana", "naranja", "plátano", "fresa", "kiwi"}
frutas_tropicales = {"plátano", "kiwi"}
print(frutas.issuperset(frutas_tropicales))  # True

Ejemplo práctico: Gestión de asistencia

Veamos un ejemplo práctico donde utilizamos varias operaciones básicas de conjuntos para gestionar la asistencia a un evento:

# Registro inicial de asistentes
asistentes_dia1 = {"Ana", "Carlos", "Elena", "David", "Beatriz"}
asistentes_dia2 = {"Carlos", "Elena", "Fernando", "Gabriela"}

# Añadir nuevos asistentes al día 1
asistentes_dia1.add("Héctor")
print(f"Asistentes día 1: {asistentes_dia1}")

# Personas que asistieron ambos días
asistentes_ambos_dias = asistentes_dia1.intersection(asistentes_dia2)
print(f"Asistieron ambos días: {asistentes_ambos_dias}")

# Eliminar a alguien que canceló su asistencia
asistentes_dia1.discard("David")
print(f"Asistentes día 1 actualizado: {asistentes_dia1}")

# Comprobar si todos los del día 2 asistieron también el día 1
todos_repiten = asistentes_dia2.issubset(asistentes_dia1)
print(f"¿Todos los del día 2 asistieron el día 1?: {todos_repiten}")

# Total de asistentes únicos en ambos días
total_asistentes = len(asistentes_dia1.union(asistentes_dia2))
print(f"Total de asistentes únicos: {total_asistentes}")

Estas operaciones básicas nos permiten manipular conjuntos de forma eficiente y son la base para operaciones más complejas que veremos en las siguientes secciones. La combinación de estas operaciones nos proporciona una herramienta potente para trabajar con colecciones de elementos únicos en nuestros programas Python.

Métodos set

Los conjuntos en Python no solo ofrecen las operaciones básicas que hemos visto anteriormente, sino que también proporcionan una serie de métodos específicos que amplían su funcionalidad. Estos métodos nos permiten realizar operaciones más complejas y especializadas sobre nuestros conjuntos.

Métodos para operaciones de conjuntos

Python implementa los métodos clásicos de la teoría de conjuntos matemáticos, permitiéndonos realizar operaciones como intersección, unión y diferencia:

• intersection(): Devuelve un nuevo conjunto con los elementos comunes a ambos conjuntos.

grupo_a = {"Ana", "Carlos", "Elena", "David"}
grupo_b = {"Carlos", "Elena", "Fernando"}
comunes = grupo_a.intersection(grupo_b)
print(comunes)  # {'Carlos', 'Elena'}

• union(): Crea un nuevo conjunto con todos los elementos de ambos conjuntos.

equipo1 = {"Juan", "María", "Pedro"}
equipo2 = {"Ana", "Pedro", "Luis"}
todos = equipo1.union(equipo2)
print(todos)  # {'Juan', 'María', 'Pedro', 'Ana', 'Luis'}

• difference(): Devuelve un nuevo conjunto con elementos que están en el primer conjunto pero no en el segundo.

inventario = {"laptop", "teléfono", "tablet", "auriculares"}
vendidos = {"laptop", "auriculares"}
disponibles = inventario.difference(vendidos)
print(disponibles)  # {'teléfono', 'tablet'}

• symmetric_difference(): Crea un nuevo conjunto con elementos que están en cualquiera de los conjuntos, pero no en ambos.

ciencias = {"física", "química", "biología", "matemáticas"}
artes = {"literatura", "música", "pintura", "matemáticas"}
exclusivos = ciencias.symmetric_difference(artes)
print(exclusivos)  # {'física', 'química', 'biología', 'literatura', 'música', 'pintura'}

Métodos que modifican el conjunto original

A diferencia de los métodos anteriores que devuelven nuevos conjuntos, los siguientes métodos modifican el conjunto original:

• intersection_update(): Actualiza el conjunto manteniendo solo los elementos comunes con otro conjunto.

usuarios_activos = {"user1", "user2", "user3", "user4"}
usuarios_premium = {"user2", "user4", "user5"}
# Actualiza usuarios_activos para contener solo usuarios activos que también son premium
usuarios_activos.intersection_update(usuarios_premium)
print(usuarios_activos)  # {'user2', 'user4'}

• update(): Añade elementos de otro conjunto (equivalente a la unión).

frutas_locales = {"manzana", "pera", "naranja"}
frutas_importadas = {"piña", "mango", "kiwi"}
# Añade todas las frutas importadas a las locales
frutas_locales.update(frutas_importadas)
print(frutas_locales)  # {'manzana', 'pera', 'naranja', 'piña', 'mango', 'kiwi'}

• difference_update(): Elimina del conjunto original los elementos que están en otro conjunto.

todos_cursos = {"Python", "Java", "SQL", "JavaScript", "C++"}
cursos_completados = {"Python", "SQL"}
# Elimina los cursos completados de la lista total
todos_cursos.difference_update(cursos_completados)
print(todos_cursos)  # {'Java', 'JavaScript', 'C++'}

• symmetric_difference_update(): Actualiza el conjunto para contener elementos que están en cualquiera de los conjuntos, pero no en ambos.

grupo1 = {"Ana", "Carlos", "David"}
grupo2 = {"Carlos", "Elena", "Fernando"}
# Actualiza grupo1 para contener solo personas que están en un grupo pero no en ambos
grupo1.symmetric_difference_update(grupo2)
print(grupo1)  # {'Ana', 'David', 'Elena', 'Fernando'}

Métodos para verificar relaciones entre conjuntos

Además de los métodos issubset() e issuperset() que vimos anteriormente, Python ofrece otros métodos para verificar relaciones:

• isdisjoint(): Comprueba si dos conjuntos no tienen elementos en común.

vegetales = {"zanahoria", "pepino", "lechuga"}
frutas = {"manzana", "plátano", "naranja"}
print(vegetales.isdisjoint(frutas))  # True - No tienen elementos en común

numeros_pares = {2, 4, 6, 8}
numeros_primos = {2, 3, 5, 7}
print(numeros_pares.isdisjoint(numeros_primos))  # False - Comparten el 2

Métodos para crear copias de conjuntos

• copy(): Crea una copia superficial del conjunto.

original = {1, 2, (3, 4)}
copia = original.copy()
original.add(5)
print(original)  # {1, 2, (3, 4), 5}
print(copia)     # {1, 2, (3, 4)} - No se ve afectado por cambios en el original

Ejemplo práctico: Análisis de datos de ventas

Veamos un ejemplo práctico donde utilizamos varios métodos de conjuntos para analizar datos de ventas:

# Productos vendidos en diferentes tiendas
tienda_centro = {"laptop", "teléfono", "tablet", "auriculares", "cámara"}
tienda_norte = {"laptop", "teléfono", "smartwatch", "altavoces"}
tienda_sur = {"tablet", "auriculares", "smartwatch", "monitor"}

# Productos que se venden en todas las tiendas
productos_comunes = tienda_centro.intersection(tienda_norte, tienda_sur)
print(f"Productos vendidos en todas las tiendas: {productos_comunes}")

# Productos únicos de la tienda centro (que no se venden en las otras)
productos_exclusivos_centro = tienda_centro.difference(tienda_norte.union(tienda_sur))
print(f"Productos exclusivos de tienda centro: {productos_exclusivos_centro}")

# Productos que se venden en al menos una tienda
catalogo_completo = tienda_centro.union(tienda_norte, tienda_sur)
print(f"Catálogo completo: {catalogo_completo}")

# Comprobar si todas las tiendas venden productos distintos
son_disjuntos = tienda_centro.isdisjoint(tienda_norte) and tienda_centro.isdisjoint(tienda_sur) and tienda_norte.isdisjoint(tienda_sur)
print(f"¿Todas las tiendas venden productos distintos? {son_disjuntos}")

# Productos que se venden en exactamente una tienda
solo_centro = tienda_centro - (tienda_norte | tienda_sur)
solo_norte = tienda_norte - (tienda_centro | tienda_sur)
solo_sur = tienda_sur - (tienda_centro | tienda_norte)
productos_exclusivos = solo_centro | solo_norte | solo_sur
print(f"Productos que se venden en una sola tienda: {productos_exclusivos}")

Encadenamiento de métodos

Una característica interesante es que podemos encadenar varios métodos para realizar operaciones complejas en una sola línea:

grupo_a = {1, 2, 3, 4, 5}
grupo_b = {4, 5, 6, 7}
grupo_c = {1, 5, 7, 9}

# Elementos que están en grupo_a y grupo_b, pero no en grupo_c
resultado = grupo_a.intersection(grupo_b).difference(grupo_c)
print(resultado)  # {4}

Rendimiento de los métodos de conjuntos

Los métodos de conjuntos en Python están optimizados para ser muy eficientes, incluso con grandes cantidades de datos. Esto se debe a que los conjuntos utilizan tablas hash internamente, lo que permite operaciones como la verificación de pertenencia (in) o la intersección en tiempo casi constante.

# Ejemplo de rendimiento con conjuntos grandes
import time

# Crear dos conjuntos grandes
conjunto_a = set(range(10000))
conjunto_b = set(range(5000, 15000))

# Medir tiempo para operación de intersección
inicio = time.time()
interseccion = conjunto_a.intersection(conjunto_b)
fin = time.time()

print(f"Elementos en la intersección: {len(interseccion)}")
print(f"Tiempo para calcular intersección: {(fin - inicio)*1000:.2f} ms")

Los métodos de conjuntos en Python nos proporcionan herramientas potentes para manipular datos de forma eficiente, especialmente cuando necesitamos trabajar con colecciones de elementos únicos y realizar operaciones matemáticas de conjuntos. Dominar estos métodos nos permite escribir código más limpio y eficiente para resolver problemas complejos de procesamiento de datos.

Operadores matemáticos

Los conjuntos en Python no solo disponen de métodos específicos para realizar operaciones matemáticas, sino que también ofrecen una sintaxis más concisa y elegante mediante operadores matemáticos. Estos operadores permiten expresar operaciones de teoría de conjuntos de manera intuitiva, similar a como se escribirían en notación matemática.

Operador de unión (|)

El operador | (barra vertical) representa la unión de dos conjuntos, creando un nuevo conjunto que contiene todos los elementos de ambos conjuntos.

ciudades_europa = {"Madrid", "París", "Roma", "Berlín"}
ciudades_asia = {"Tokio", "Pekín", "Seúl", "Bangkok"}

todas_ciudades = ciudades_europa | ciudades_asia
print(todas_ciudades)  # {'Madrid', 'París', 'Roma', 'Berlín', 'Tokio', 'Pekín', 'Seúl', 'Bangkok'}

Este operador es equivalente al método union() que vimos anteriormente, pero con una sintaxis más compacta.

Operador de intersección (&)

El operador & (ampersand) representa la intersección de dos conjuntos, creando un nuevo conjunto que contiene solo los elementos comunes a ambos conjuntos.

estudiantes_matematicas = {"Ana", "Carlos", "Elena", "David"}
estudiantes_fisica = {"Carlos", "Elena", "Fernando", "Gabriela"}

estudiantes_ambas = estudiantes_matematicas & estudiantes_fisica
print(estudiantes_ambas)  # {'Carlos', 'Elena'}

Operador de diferencia (-)

El operador - (guion) representa la diferencia entre conjuntos, creando un nuevo conjunto con elementos que están en el primer conjunto pero no en el segundo.

ingredientes_disponibles = {"harina", "huevos", "azúcar", "leche", "mantequilla"}
ingredientes_usados = {"harina", "huevos", "azúcar"}

ingredientes_restantes = ingredientes_disponibles - ingredientes_usados
print(ingredientes_restantes)  # {'leche', 'mantequilla'}

Operador de diferencia simétrica (^)

El operador ^ (acento circunflejo) representa la diferencia simétrica entre conjuntos, creando un nuevo conjunto con elementos que están en cualquiera de los conjuntos, pero no en ambos.

equipo_a = {"Juan", "María", "Carlos", "Ana"}
equipo_b = {"Carlos", "Ana", "Pedro", "Lucía"}

miembros_exclusivos = equipo_a ^ equipo_b
print(miembros_exclusivos)  # {'Juan', 'María', 'Pedro', 'Lucía'}

Operadores de asignación combinados

Python también proporciona operadores de asignación combinados que modifican el conjunto original:

• |= (unión y asignación)

lenguajes = {"Python", "Java", "C++"}
nuevos_lenguajes = {"Go", "Rust", "TypeScript"}

# Equivalente a: lenguajes = lenguajes | nuevos_lenguajes
lenguajes |= nuevos_lenguajes
print(lenguajes)  # {'Python', 'Java', 'C++', 'Go', 'Rust', 'TypeScript'}

• &= (intersección y asignación)

productos_tienda_a = {"laptop", "teléfono", "tablet", "auriculares"}
productos_oferta = {"laptop", "auriculares", "cámara"}

# Mantiene solo los productos que están en oferta
productos_tienda_a &= productos_oferta
print(productos_tienda_a)  # {'laptop', 'auriculares'}

• -= (diferencia y asignación)

tareas_pendientes = {"informe", "reunión", "correos", "presentación"}
tareas_completadas = {"informe", "correos"}

# Elimina las tareas completadas
tareas_pendientes -= tareas_completadas
print(tareas_pendientes)  # {'reunión', 'presentación'}

• ^= (diferencia simétrica y asignación)

inventario_actual = {"mesa", "silla", "lámpara", "estantería"}
nueva_entrega = {"mesa", "sofá", "alfombra", "estantería"}

# Actualiza el inventario: elimina duplicados y añade nuevos
inventario_actual ^= nueva_entrega
print(inventario_actual)  # {'silla', 'lámpara', 'sofá', 'alfombra'}

Operadores de comparación

Los conjuntos también admiten operadores de comparación para verificar relaciones:

• == (igualdad): Comprueba si dos conjuntos contienen exactamente los mismos elementos.

conjunto_a = {1, 2, 3}
conjunto_b = {3, 1, 2}  # Mismo contenido, diferente orden
conjunto_c = {1, 2, 3, 4}

print(conjunto_a == conjunto_b)  # True
print(conjunto_a == conjunto_c)  # False

• <= (subconjunto): Comprueba si el primer conjunto es subconjunto del segundo.

numeros_pares = {2, 4, 6}
numeros = {1, 2, 3, 4, 5, 6, 7}

print(numeros_pares <= numeros)  # True - todos los elementos están en el segundo conjunto

• < (subconjunto propio): Comprueba si el primer conjunto es subconjunto propio del segundo (todos los elementos están en el segundo y los conjuntos son diferentes).

conjunto_a = {1, 2}
conjunto_b = {1, 2, 3}
conjunto_c = {1, 2}

print(conjunto_a < conjunto_b)  # True - subconjunto propio
print(conjunto_a < conjunto_c)  # False - son iguales

• >= (superconjunto): Comprueba si el primer conjunto es superconjunto del segundo.

frutas = {"manzana", "naranja", "plátano", "fresa"}
frutas_seleccionadas = {"manzana", "naranja"}

print(frutas >= frutas_seleccionadas)  # True - contiene todos los elementos del segundo

• > (superconjunto propio): Comprueba si el primer conjunto es superconjunto propio del segundo.

conjunto_a = {1, 2, 3, 4}
conjunto_b = {2, 3}
conjunto_c = {1, 2, 3, 4}

print(conjunto_a > conjunto_b)  # True - superconjunto propio
print(conjunto_a > conjunto_c)  # False - son iguales

Ejemplo práctico: Análisis de preferencias

Veamos un ejemplo práctico donde utilizamos operadores matemáticos de conjuntos para analizar preferencias de usuarios:

# Preferencias de usuarios sobre géneros de películas
usuario1 = {"acción", "comedia", "ciencia ficción", "aventura"}
usuario2 = {"drama", "comedia", "romance", "documental"}
usuario3 = {"acción", "aventura", "fantasía", "ciencia ficción"}

# Géneros comunes entre usuario1 y usuario3
generos_comunes_1_3 = usuario1 & usuario3
print(f"Géneros comunes entre usuario1 y usuario3: {generos_comunes_1_3}")

# Todos los géneros que le gustan al usuario1 o al usuario2
todos_generos_1_2 = usuario1 | usuario2
print(f"Todos los géneros de usuario1 y usuario2: {todos_generos_1_2}")

# Géneros que le gustan al usuario1 pero no al usuario2
solo_usuario1 = usuario1 - usuario2
print(f"Géneros exclusivos del usuario1: {solo_usuario1}")

# Géneros que le gustan a exactamente uno de usuario2 o usuario3
exclusivos_2_3 = usuario2 ^ usuario3
print(f"Géneros que gustan a usuario2 o usuario3, pero no a ambos: {exclusivos_2_3}")

# Verificar si usuario1 tiene más preferencias que usuario2
tiene_mas_preferencias = len(usuario1) > len(usuario2)
print(f"¿Usuario1 tiene más preferencias que usuario2? {tiene_mas_preferencias}")

# Verificar si todas las preferencias de usuario3 están incluidas en usuario1
todas_incluidas = usuario3 <= usuario1
print(f"¿Todas las preferencias de usuario3 están en usuario1? {todas_incluidas}")

Combinación de operadores

Una ventaja importante de los operadores matemáticos es que se pueden combinar en expresiones complejas, similar a las expresiones matemáticas:

A = {1, 2, 3, 4}
B = {3, 4, 5, 6}
C = {5, 6, 7, 8}

# Elementos que están en A y B, pero no en C
resultado = (A & B) - C
print(resultado)  # {3, 4}

# Elementos que están en A o en C, pero no en B
resultado2 = (A | C) - B
print(resultado2)  # {1, 2, 7, 8}

Rendimiento de los operadores vs. métodos

En términos de rendimiento, los operadores y los métodos correspondientes son equivalentes, ya que internamente los operadores llaman a los métodos. La elección entre usar operadores o métodos es principalmente una cuestión de estilo y legibilidad:

# Estas dos expresiones son equivalentes en funcionalidad y rendimiento
resultado1 = conjunto_a.union(conjunto_b).difference(conjunto_c)
resultado2 = (conjunto_a | conjunto_b) - conjunto_c

Los operadores matemáticos para conjuntos en Python proporcionan una forma elegante y concisa de expresar operaciones de teoría de conjuntos, haciendo que el código sea más legible y más cercano a la notación matemática tradicional. Dominar estos operadores te permitirá escribir código más expresivo y eficiente cuando trabajes con conjuntos.