Conjuntos

1. Un conjunto es una colección desordenada de elementos únicos. Sus principales usos son:

• Eliminar duplicados: al convertir una lista en conjunto, se eliminan automáticamente los duplicados.
• Pruebas de relaciones: permite probar relaciones como intersección, diferencia, unión, etc. entre dos grupos de datos.

2. Tipos de conjuntos

• Matemáticamente, un conjunto se define como una colección de elementos distintos. A los miembros del conjunto se les suele llamar elementos del conjunto.
• Un objeto conjunto es un grupo de valores hasheables dispuestos de forma desordenada.
• Hay dos tipos de conjuntos: conjuntos mutables (set) y conjuntos inmutables (frozenset).

>>> c1 = set('hola')
>>> c2 = frozenset('hola')
>>> c1
{'h', 'o', 'l', 'a'}
>>> c2
frozenset({'h', 'o', 'l', 'a'})

3. Operadores de conjuntos

• Se pueden usar los operadores in y not in para comprobar membresía.
• Se puede obtener el tamaño con len().
• Se puede iterar sobre los miembros con for.
• No se puede hacer slicing ni acceder por clave.

>>> len(c2)
4
>>> for ch in c1:
...    print(ch)
h
o
l
a

• |: Unión
• &: Intersección
• -: Diferencia

>>> c1 = set('abc')
>>> c2 = set('cde')
>>> c1 | c2
{'a', 'c', 'b', 'e', 'd'}
>>> c1 & c2
{'c'}
>>> c1 - c2
{'a', 'b'}

4. Métodos incorporados de conjuntos

• set.add(elemento): Agrega un elemanto como un todo. Solo uno a la vez.
• set.update(iterable): Agrega los elementos del iterable de forma dispersa. Se pueden agregar varios.
• set.remove(elemento): Elimina un elemento. Lanza KeyError si no existe.

>>> print(c1)
{'h', 'e', 'l', 'o'}
>>> c1.add('nuevo')
>>> print(c1)
{'h', 'e', 'l', 'o', 'nuevo'}
>>> c1.update('nuevo')
>>> print(c1)
{'e', 'h', 'l', 'o', 'n', 'w', 'nuevo'}
>>> c1.remove('n')
>>> print(c1)
{'e', 'h', 'l', 'o', 'w', 'nuevo'}

• s.issubset(t): Devuelve True si s es subconjunto de t.
• s.issuperset(t): Devuelve True si s es superconjunto de t.
• s.union(t): Devuelve un nuevo conjunto con la unión de s y t.
• s.intersection(t): Devuelve un nuevo conjunto con la intersección de s y t.
• s.difference(t): Devuelve un nuevo conjunto con los elementos de s que no están en t.

Métodos de conjuntos:

1. Definir un conjunto

# Primera forma
numeros = [1,2,3,4,5,6,7]
conjunto_numeros = set(numeros)
print(conjunto_numeros)
# Resultado: {1, 2, 3, 4, 5, 6, 7}

# Segunda forma
conjunto_numeros = {1,2,3,4,5,6,7}
print(conjunto_numeros)
# Resultado: {1, 2, 3, 4, 5, 6, 7}

2. Agregar (actualizar)

numeros = {1,2,3,4,5,6,7}
# set.add() solo agrega un elemento, no varios
# numeros.add(8)
# print(numeros)

# set.update() puede agregar una cadena o varios valores
# numeros.update([8])
# print(numeros)
# numeros.update('8')
# print(numeros)

numeros.update([8,9,10])
print(numeros)
# Resultado: {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

3. Eliminar

numeros = {1,2,3,4,5,6,7}
numeros.remove(7)
print(numeros)
# Resultado: {1, 2, 3, 4, 5, 6}

4. Consultar: no se puede indexar por posición.

5. Modificar: los conjuntos son mutables, pero no se pueden modificar elementos individuales; se pueden agregar o eliminar.

6. Intersección (&)

conj1 = {1, 2, 3, 4, 5, 6}
conj2 = {1, 2, 3, 4, 5, 10, 7, 8, 9}
# Forma 1 con &
interseccion = conj1 & conj2
print(interseccion)
# Forma 2 con intersection()
interseccion2 = conj1.intersection(conj2)
print(interseccion2)
# Resultado: {1, 2, 3, 4, 5}

7. Unión (|)

conj1 = {1, 2, 3, 4, 5, 6}
conj2 = {1, 2, 3, 4, 5, 10, 7, 8, 9}
# Forma 1 con |
union = conj1 | conj2
print(union)
# Forma 2 con union()
union2 = conj1.union(conj2)
print(union2)
# Resultado: {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

8. Diferencia (-)

conj1 = {1, 2, 3, 4, 5, 6}
conj2 = {1, 2, 3, 4, 5, 10, 7, 8, 9}
# Forma 1 con -
dif1 = conj1 - conj2
print(dif1)  # {6}
dif2 = conj2 - conj1
print(dif2)  # {8, 9, 10, 7}
# Forma 2 con difference()
dif3 = conj1.difference(conj2)
print(dif3)  # {6}
dif4 = conj2.difference(conj1)
print(dif4)  # {8, 9, 10, 7}

9. Diferencia simétrica (^)

conj1 = {1, 2, 3, 4, 5, 6}
conj2 = {1, 2, 3, 4, 5, 10, 7, 8, 9}
# Forma 1 con ^
sim1 = conj1 ^ conj2
print(sim1)  # {6, 7, 8, 9, 10}
# Forma 2 con symmetric_difference()
sim2 = conj2.symmetric_difference(conj1)
print(sim2)  # {6, 7, 8, 9, 10}

10. Conversión de conjuntos

conjunto = set(range(4))
lista = list(conjunto)
tupla = tuple(conjunto)
cadena = str(conjunto)
print(lista, type(lista))  # [0, 1, 2, 3] <class 'list'>
print(tupla, type(tupla))  # (0, 1, 2, 3) <class 'tuple'>
print(cadena, type(cadena))  # {0, 1, 2, 3} <class 'str'>

Complemento: frozenset

Un conjunto inmutable. Es como un conjunto (set) pero no se puede modificar.

# Crear un frozenset con datos
info = frozenset(('estudiar', 'trabajar', 'examen', 'descansar'))
print(info, type(info))

# Comprobación de membresía
resultado = 'trabajar' in info
print(resultado)

# Iteración sobre el frozenset
for i in info:
    print(i)

# Comprensión de conjuntos (no produce frozenset, sino set)
resultado_comp = {i for i in info}
print(resultado_comp, type(resultado_comp))

# Funciones que no modifican el conjunto
info_copia = info.copy()
print(info_copia)

# Operaciones entre conjuntos: unión, intersección, etc.
info2 = {'estudiar', 'trabajar', 'examen', 'descansar'}
resultado_union = info.union(info2)
print(resultado_union)  # frozenset

resultado_union2 = info2.union(info)
print(resultado_union2)  # set

Ejemplos de operaciones con conjuntos

>>> s = set(["hola mundo"])
>>> s.add('python')   # agregar
>>> s
{'python', 'hola mundo'}

>>> s.clear()
>>> s
set()

>>> s = set(["hola mundo"])
>>> s2 = s.copy()
>>> s2
{'hola mundo'}

>>> a = set([1,2,3,4,5])
>>> b = set([1,3,5,7,9])
>>> a.difference(b)  # elementos en a que no están en b
{2, 4}

>>> b.difference(a)
{9, 7}

>>> a.difference_update(b)  # actualiza a con la diferencia
>>> a
{2, 4}

>>> a = set([1,2,3,4,5])
>>> b = set([1,3,5,7,9])
>>> b.difference_update(a)
>>> b
{7, 9}

>>> a = set([1,2,3,4,5])
>>> b = set([1,3,5,7,9])
>>> a.discard(3)  # elimina 3 si existe
>>> a
{1, 2, 4, 5}
>>> a.discard(6)  # no hace nada
>>> a
{1, 2, 4, 5}

>>> a.intersection(b)  # intersección
{1, 5}
>>> b.intersection(a)
{1, 5}

>>> a.intersection_update(b)  # actualiza a con intersección
>>> a
{1, 5}

>>> a = set([1,2,3,4,5])
>>> b = set([1,3,5,7,9])
>>> a.isdisjoint(b)  # ¿disjuntos?
False

>>> a.issubset(b)  # ¿a subconjunto de b?
False

>>> a.issuperset(b)  # ¿a superconjunto de b?
False

>>> a.pop()
1
>>> a
{2, 3, 4, 5}

>>> a.remove(3)
>>> a
{2, 4, 5}

>>> a.symmetric_difference(b)  # diferencia simétrica
{2, 4, 7, 9}

>>> a.symmetric_difference_update(b)
>>> a
{2, 4, 7, 9}

>>> a.union(b)  # unión
{1, 2, 3, 4, 5, 7, 9}

>>> a.update("10")  # agrega elementos de la cadena
>>> a
{2, 4, 7, 9, '1', '0'}
>>> a.update(b)
>>> a
{1, 2, 3, 4, 5, 7, 9, '1', '0'}