"""
    Los sets son un tipo de dato para almacenar colecciones de datos
    (collection data types: List, Tuple, Set, Dictionary)

    set: desordenado, mutable, sin duplicados
"""

# crear set con funcion set()
mi_set = set()
mi_set = set([1, 2, 3])
mi_set = set('hello')    # {'l', 'o', 'h', 'e'}

# añadir elmento add()
mi_set.add(16)

# remover elemento remove()
mi_set.remove(16)
# arroja excepcion KeyError si no existe

# remover elemento discard()
mi_set.discard(16)
# devuelve None si no existe

# vaciar set clear()
mi_set.clear()

mi_set = {1, 2, 3, 4}

# extraer un elemento con pop()
mi_set.pop()
# extracción arbitraria

# iterar set
for i in mi_set:
    pass

# verificar existencia
if 2 in mi_set:
    print('si')

# # # # # # # # # # # # # # # # # # # # # # # # #
#                                               #
#       Nota: Números Primos                    #
#                                               #
#  son impares a excepción del primer primo '2' #
#  no terminan en '0' o numero par              #
#  no terminan en '5' a excepción del '5'       #
#  regla general; todo número divisible         #
#  solo por 1 y por si mismo.                   #
#                                               #
# # # # # # # # # # # # # # # # # # # # # # # # #

# set() por comprensión 
impares = set([x for x in range(1, 10, 2)])
pares = set([x for x in range(0, 10, 2)])
# impares: {1, 3, 5, 7, 9}
# pares: {0, 2, 4, 6, 8}

# comprension de set condicional
frase = "hola a todas las personas"

vocales_unicas = {i for i in frase if i in 'aeiou'}
# {'e', 'a', 'o'}

primos = set([2, 3, 5, 7])

# union, intersección, y diferenecia de sets
# estos no modifican los sets originales, si no q retornan un nuevo set

# union: combina elementos entre 2 sets sin duplicados
u = impares.union(pares)    # u = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}

# intersección: contempla solo los elementos encontrados en ambos sets
i = primos.intersection(pares)  # i = {2}

# diferencia: contempla solo los elementos del primer set,
#             que no se encuentran el el segundo
dif = u.difference(primos)  # dif = {0, 1, 4, 6, 8, 9}
dif = u.difference(impares) # dif = {0, 2, 4, 6, 8}
dif = u.difference(pares)   # dif = {1, 3, 5, 7, 9}

# diferencia simetrica: combina los elementos únicos entre ambos sets
dif_s = primos.symmetric_difference(pares)      # dif = {0, 3, 4, 5, 6, 7, 8}
dif_s = primos.symmetric_difference(impares)    # dif = {1, 2, 9}
dif_s = u.symmetric_difference(primos)          # dif = {0, 1, 4, 6, 8, 9}

# update(), intersection_update(), difference_update() y symmetric_difference_update()
# escriben los cambios en el set

# update set
impares.update(primos)      # impares = {1, 2, 3, 5, 7, 9}

# intersection_update()
u.intersection_update(pares)    # u = {0, 2, 4, 6, 8}

# difference_update()
u.difference_update(impares)    # u = {0, 4, 6, 8}

# symmetric_difference_update()
u.symmetric_difference_update(dif_s)    # u = {1, 9}

# issubset(), retorna True si el set que llama al metodo
# es un sub-set del set pasado como argumento
u.issubset(impares)     # True

# issuperset(), retorna True si el set pasado como argumento
# es un sub-set del set que llama al metodo
impares.issuperset(u)   # True

# isdisjoint(), retorna True si el set que llama al metodo no tiene
# ningun elemento que coincida con los del set pasado como argumento
u.isdisjoint(pares) # True

# esta asignación hace referencia al mismo punto en memoria
copia_set = pares
# cualquier cambio en copia_set modfica el set pares.

# copiar con copy()
copia_set = pares.copy()

# copiar con set()
copia_set = set(pares)

# frozenset(), es otro 'collection data type',
# es identico al set, salvo que es inmutable
mi_frozenset = frozenset([x for x in range(1, 101)])

try:
    msg = mi_frozenset.add(101)
except AttributeError as AE:
    # msg = AE.__str__()
    msg = str(AE)
    try:
        msg = mi_frozenset.remove(1)
    except AttributeError as AE:
        msg += '\n' + AE.__str__()
finally:
    print(f'frozenset es inmutable\n{msg}')