Obteniendo un subconjunto

4.1 Obteniendo un subconjunto por regla

Un subconjunto es un conjunto cuyos elementos pertenecen a otro conjunto más grande. En Python hay varios métodos y operadores integrados para trabajar con subconjuntos. A continuación, te contaré cómo obtener subconjuntos, cómo verificar si un conjunto es un subconjunto de otro, y cómo usar este conocimiento en diferentes escenarios.

Usando el ciclo for

Puedes crear un conjunto vacío y agregarle elementos que cumplan una condición usando un ciclo for.

my_set = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
even_set = set()
            
for x in my_set:
    if x % 2 == 0:
        even_set.add(x)
            
print(even_set)  # Salida: {2, 4, 6, 8, 10}
        

Este es el método más sencillo y obvio para crear un subconjunto. Pero hay otros métodos más compactos.

Usando la función filter()

La función filter() aplica una función a cada elemento y devuelve solo aquellos para los cuales la función devolvió True. Luego, necesitas convertir el resultado de nuevo a un conjunto.

my_set = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
even_set = set(filter(lambda x: x % 2 == 0, my_set))
print(even_set)  # Salida: {2, 4, 6, 8, 10}
        

Dentro de la función filter(), se usa una expresión lambda, que es una forma corta de definir una función auxiliar o regla de filtrado. Te hablaré más sobre lambdas en unas lecturas más adelante.

4.2 Uso de generadores de conjuntos

¿Recuerdas List Comprehension? Cuando usábamos corchetes para definir rápidamente una lista y sus elementos. Esta herramienta sintáctica tenía la siguiente apariencia:

[expresión for variable in secuencia]

Donde:

• variable — identificador de alguna variable,
• secuencia — secuencia de valores que la variable puede tomar (puede ser una lista, cadena o un objeto obtenido con la función range),
• expresión — una expresión que generalmente depende de la variable usada en el generador, que rellenará los elementos de la lista.

Para conjuntos existe una función análoga, solo que debes usar llaves:

{expresión for variable in secuencia}

Los generadores de conjuntos permiten crear nuevos conjuntos de manera fácil y concisa basándose en conjuntos existentes, aplicando condiciones de filtrado.

Así es como puedes seleccionar solo los elementos pares de un conjunto:

my_set = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
even_set = {x for x in my_set if x % 2 == 0} 
print(even_set)  # Salida: {2, 4, 6, 8, 10} 

Y así solo las cadenas:

my_set = {1, 2, 3, 4, 5, 6, 7, 8, 9, "apple", "banana"}
even_set = {x for x in my_set if type(x) == str}
print(even_set)  # Salida: {"apple", "banana"}

4.3 Comprobación de la presencia de un elemento

Una de las operaciones principales que puedes realizar con conjuntos es comprobar la presencia de un elemento en el conjunto. En Python hay varias formas de hacerlo. Vamos a ver diferentes métodos para verificar si un elemento está presente en un conjunto.

Uso del operador in

La manera más común y conveniente de verificar la presencia de un elemento en un conjunto es usando el operador in. Este método devuelve True si el elemento está presente en el conjunto y False en caso contrario.

my_set = {1, 2, 3, 4, 5}
print(3 in my_set)  # Salida: True
print(6 in my_set)  # Salida: False
            

Uso del operador not in

El operador not in es lo opuesto al operador in y se usa para verificar que un elemento no está en el conjunto. Devuelve True si el elemento no está presente y False en caso contrario.

my_set = {1, 2, 3, 4, 5}
print(6 not in my_set)  # Salida: True
print(3 not in my_set)  # Salida: False

Usando bucles

Aunque usar bucles para comprobar la presencia de un elemento en un conjunto no es el método más eficiente, puede ser útil en situaciones en las que estás trabajando con estructuras de datos más complejas o realizando operaciones adicionales.

my_set = {1, 2, 3, 4, 5}
element = 3
found = False
            
for item in my_set:
    if item == element:
        found = True
        break
            
print(found)  # Salida: True
        

4.4 Comprobación de la inclusión de conjuntos

Python ofrece el operador <= y el método issubset() para verificar si un conjunto es subconjunto de otro.

Uso del operador <=

El operador <= te permite verificar fácilmente si un conjunto es subconjunto de otro.

set_a = {1, 2, 3}
set_b = {1, 2, 3, 4, 5}
            
print(set_a <= set_b)  # Salida: True
print(set_b <= set_a)  # Salida: False
            
        

Uso del método issubset()

El método issubset() realiza la misma función que el operador <= y devuelve True si todos los elementos de un conjunto están contenidos en otro.

set_a = {1, 2, 3}
set_b = {1, 2, 3, 4, 5}
            
print(set_a.issubset(set_b))  # Salida: True
print(set_b.issubset(set_a))  # Salida: False
        

Comprobación de superconjunto

De manera similar a los subconjuntos, puedes verificar si un conjunto es superconjunto de otro, usando el operador >= y el método issuperset().

Uso del operador >=

set_a = {1, 2, 3, 4, 5}
set_b = {1, 2, 3}
            
print(set_a >= set_b)  # Salida: True
print(set_b >= set_a)  # Salida: False
            
        

Uso del método issuperset()

set_a = {1, 2, 3, 4, 5}
set_b = {1, 2, 3}
            
print(set_a.issuperset(set_b))  # Salida: True
print(set_b.issuperset(set_a))  # Salida: False