Trabajar con conjuntos en Python te permite manejar colecciones no ordenadas que eliminan duplicados de forma automática. Si necesitas limpiar datos repetidos o aplicar operaciones matemáticas como unión e intersección, los sets son la herramienta ideal dentro de las colecciones del lenguaje.
¿Qué es un conjunto en Python y cómo se define?
Un conjunto es una colección no ordenada de elementos únicos. Para crearlo usas llaves {} y separas los elementos con coma. Por ejemplo, puedes definir un grupo de frutas así:
Si intentas agregar "naranja" por segunda vez dentro de la definición, Python ignora ese duplicado. Por eso, aunque escribas cuatro elementos con uno repetido, len(frutas) devuelve 3 [01:20]. El elemento duplicado no forma parte del conjunto, simplemente se descarta al momento de asignarlo.
¿Los sets en Python permiten duplicados? No. Cualquier elemento repetido es ignorado automáticamente al crear o modificar el conjunto, lo que los hace ideales para eliminar valores redundantes.
Los conjuntos también admiten distintos tipos de datos mezclados: strings, números y booleanos pueden convivir sin problema. Eso sí, al recorrerlos con un bucle for, el orden de impresión no coincide con el orden de definición, justamente porque son colecciones no ordenadas [02:45].
¿Cómo verifico si un elemento está dentro de un conjunto?
La palabra clave in te permite comprobar la presencia de un valor en el set. Combinada con not in, puedes validar la ausencia de un elemento.
python
print("manzana" in frutas) # True
print("pera" not in frutas) # True
Esta verificación es directa y se lee como una pregunta lógica: ¿está o no está? Útil cuando necesitas filtrar antes de procesar.
¿Cómo agregar y eliminar elementos en un set?
Los conjuntos son mutables en su totalidad, aunque no puedes modificar un elemento puntual porque no existen índices. Lo que sí puedes hacer es sumar o restar elementos.
Métodos para agregar: add y update
Para incorporar un elemento individual usas add. Para sumar varios a la vez, update acepta otro conjunto, una lista o una tupla [05:30].
La flexibilidad de update es clave: no estás limitado a fusionar solo sets, sino que puedes traer datos desde otras estructuras de colección.
Métodos para eliminar: remove, discard, pop y clear
Aquí tienes cuatro formas de quitar elementos, cada una con un comportamiento distinto:
remove(elemento): elimina el elemento indicado. Si no existe, lanza un error.
discard(elemento): elimina el elemento indicado. Si no existe, ignora la instrucción sin error.
pop(): elimina un elemento aleatorio, ya que el set no tiene orden ni índice.
clear(): vacía el conjunto por completo y lo deja como set().
La diferencia entre remove y discard es la que más confusión genera. Si tu código no debe romperse cuando intentas borrar algo que quizá no exista, discard es la opción segura.
¿Cuándo usar discard en vez de remove? Usa discard si no estás seguro de que el elemento exista en el conjunto. remove lanza un error si el valor no está; discard simplemente no hace nada.
Con pop debes tener cuidado: como elimina al azar, ejecutarlo dos veces seguidas dará resultados distintos [08:15]. No es predecible.
¿Qué operaciones matemáticas puedo hacer entre conjuntos?
Los sets en Python replican las operaciones clásicas de teoría de conjuntos: unión, intersección y diferencia. Imagina dos grupos:
El único elemento en común es "c". A partir de ahí puedes aplicar tres operaciones:
Unión con set1.union(set2): junta todos los elementos sin repetir. Resultado: {a, b, c, d, e}.
Intersección con set1.intersection(set2): devuelve solo los elementos comunes. Resultado: {c}.
Diferencia con set1.difference(set2): devuelve los elementos de set1 que no están en set2. Resultado: {a, b}.
Estas operaciones reflejan exactamente lo que verías en un diagrama de Venn, y son útiles para comparar conjuntos de datos sin escribir lógica condicional manual [10:50].
¿Cómo elimino duplicados de una lista usando sets?
Uno de los usos prácticos más potentes de los conjuntos es limpiar duplicados de otras colecciones. Si tienes una lista o tupla con valores repetidos, puedes convertirla a set y luego volver a list:
La diferencia entre remove() y discard(): clave para evitar errores cuando no estás seguro si un elemento existe
El "truco mágico" para eliminar duplicados es: list(set(mi_lista)) 🚀
Muchas gracias por comentarios que suman al contenido!
El método .update() no se utiliza para listas en Python. Este método se aplica a conjuntos (sets) para agregar múltiples elementos de otro conjunto o iterable. Para listas, se utiliza el método .extend() para añadir varios elementos a la lista existente.
Por ejemplo:
lista =[1,2,3]lista.extend([4,5])print(lista)# Salida: [1, 2, 3, 4, 5]
Esto es clave para entender cómo funcionan las diferentes colecciones en Python.
Otra cosa que no se mencionó es que los sets solo aceptan elementos con Hashability (primitivos, tuples, frozensets, etc).
¿Qué es ser "Hashable"?
Significa que el objeto tiene un valor fijo que nunca cambia durante su vida (identificado por un hash en memoria). Este valor es necesario para que el set pueda identificar y organizar sus elementos internamente de forma eficiente.
La Regla Simple: Solo los objetos Inmutables son Hashables.
✅ Aceptados (Inmutables): Primitivos (str, numericos, bool), Tuplas (si sus contenidos lo son) y frozensets.
❌ Rechazados (Mutables):Listas (list), Sets y Diccionarios (dict), Classes, Objects.
Usar mutables provocará un TypeError. Por ejemplo, para guardar una lista en un set, primero debes convertirla a una tupla inmutable.
Muchas gracias por tu comentario
Dato curioso, si en el conjunto colocas 0 y False, o 1 y True, solo se imprimira uno de ellos.
conjuntos ={True,False,1,0}print(conjuntos)
Devolverá
True
False
Esto por que en el contexto de conjuntos 1 es igual a True y 0 es igual a False.
# Operations between setsset_a ={1,2,3,4}set_b ={3,4,5,6}# Symmetric difference of setssym_diff_set = set_a.symmetric_difference(set_b)print(sym_diff_set)# Output: {1, 2, 5, 6}
set_a ={1,2,3,4}set_b ={3,4,5,6}# Subset and Supersetset_c ={1,2}print(set_c.issubset(set_a))# Output: True (set_c is a subset of set_a)print(set_a.issuperset(set_c))# Output: True (set_a is a superset of set_c)print(set_a.issubset(set_b))# Output: False (set_a is not a subset of set_b)print(set_b.issuperset(set_a))# Output: False (set_b is not a superset of set_a)
#Sets are unordered collections of unique elements. They are defined using curly braces {} or thefruits ={"apple","banana","cherry","apple"}#A set can contain duplicate elements, but they will be ignoredprint(fruits)#Output: {'apple', 'banana', 'cherry'} (the duplicate "apple" is ignored)print(type(fruits))#Output: <class 'set'>print(len(fruits))#Output: 3 (length of the set), the duplicate "apple" is not countedset1 ={"Python",156,True,3.14}#A set can contain elements of different data typesprint(set1)#Output: {True, 3.14, 'Python', 156} (the order of the elements in the set is not guaranteed)print(type(set1))#Output: <class 'set'>for item in set1:print(item)#Output: True, 3.14, 'Python', 156 (the order of the elements in the set is *not guaranteed*)#checking if an element is in the setprint("banana"in fruits)#Output: True (checking if an element is in the set)print("grape"in fruits)#Output: False (checking if an element is in the set)#adding elements to the setfruits.add("orange")#This will add "orange" to the setprint(fruits)#Output: {'apple', 'banana', 'cherry', 'orange'} (the set after adding "orange")fruits.update(["grape","melon"])#This will add "grape" and "melon" to the set, the update() method is used in lists, tuples, and sets to add multiple elements to the collection#removing elements from the setfruits.remove("banana")#This will remove "banana" from the set, if the element is not found, it will raise a KeyErrorprint(fruits)#Output: {'apple', 'cherry', 'orange', 'grape', 'melon'} (the set after removing "banana")fruits.discard("grape")#This will remove "grape" from the set, if the element is not found, it will do nothingprint(fruits)#Output: {'apple', 'cherry', 'orange', 'melon'} (the set after discarding "grape")#the diference between remove() and discard() is that remove() will raise a KeyError if the element is not found, while discard() will do nothing if the element is not foundfruits.pop()#This will remove and return an arbitrary element from the set, since sets are unordered, you cannot predict which element will be removedprint(fruits)#Output: {'apple', 'cherry', 'orange'} (the set after popping an element, the popped element is not guaranteed)fruits.clear()#This will remove all elements from the setprint(fruits)#Output: set() (the set after clearing all elements)print("----------------------")#Set operationssetA ={"a","b","c"}setB ={"b","c","d"}print(setA.union(setB))#Output: {'a', 'b', 'c', 'd'} (the union of setA and setB, it will contain all unique elements from both sets)print(setA.intersection(setB))#Output: {'b', 'c'} (the intersection of setA and setB, it will contain only the elements that are present in both sets)print(setA.difference(setB))#Output: {'a'} (the difference of setA and setB, it will contain only the elements that are present in setA but not in setB)
#Sets are unordered collections of unique elements. They are defined using curly braces {} or the
fruits = {"apple", "banana", "cherry", "apple"} #A set can contain duplicate elements, but they will be ignored
print(fruits) #Output: {'apple', 'banana', 'cherry'} (the duplicate "apple" is ignored)
print(type(fruits)) #Output: <class 'set'>
print(len(fruits)) #Output: 3 (length of the set), the duplicate "apple" is not counted
set1 = {"Python", 156, True, 3.14} #A set can contain elements of different data types
print(set1) #Output: {True, 3.14, 'Python', 156} (the order of the elements in the set is not guaranteed)
print(type(set1)) #Output: <class 'set'>
for item in set1:
print(item) #Output: True, 3.14, 'Python', 156 (the order of the elements in the set is *not guaranteed*)
#checking if an element is in the set
print("banana" in fruits) #Output: True (checking if an element is in the set)
print("grape" in fruits) #Output: False (checking if an element is in the set)
#adding elements to the set
fruits.add("orange") #This will add "orange" to the set
print(fruits) #Output: {'apple', 'banana', 'cherry', 'orange'} (the set after adding "orange")
fruits.update(["grape", "melon"]) #This will add "grape" and "melon" to the set, the update() method is used in lists, tuples, and sets to add multiple elements to the collection
#removing elements from the set
fruits.remove("banana") #This will remove "banana" from the set, if the element is not found, it will raise a KeyError
print(fruits) #Output: {'apple', 'cherry', 'orange', 'grape', 'melon'} (the set after removing "banana")
fruits.discard("grape") #This will remove "grape" from the set, if the element is not found, it will do nothing
print(fruits) #Output: {'apple', 'cherry', 'orange', 'melon'} (the set after discarding "grape")
#the diference between remove() and discard() is that remove() will raise a KeyError if the element is not found, while discard() will do nothing if the element is not found
fruits.pop() #This will remove and return an arbitrary element from the set, since sets are unordered, you cannot predict which element will be removed
print(fruits) #Output: {'apple', 'cherry', 'orange'} (the set after popping an element, the popped element is not guaranteed)
fruits.clear() #This will remove all elements from the set
print(fruits) #Output: set() (the set after clearing all elements)
print("----------------------")
#Set operations
setA = {"a", "b", "c"}
setB = {"b", "c", "d"}
print(setA.union(setB)) #Output: {'a', 'b', 'c', 'd'} (the union of setA and setB, it will contain all unique elements from both sets)
print(setA.intersection(setB)) #Output: {'b', 'c'} (the intersection of setA and setB, it will contain only the elements that are present in both sets)
print(setA.difference(setB)) #Output: {'a'} (the difference of setA and setB, it will contain only the elements that are present in setA but not in setB)
Un conjunto (set) es una colección no ordenada, sin elementos duplicados y mutable (puede cambiar después de crearse).
Se usa para operaciones matemáticas como uniones, intersecciones, diferencias, etc.
Propiedades importantes
No tiene índice → no se accede por posición.
No permite duplicados.
Sus elementos deben ser inmutables (por ejemplo: no puedes tener listas dentro de un set, pero sí tuplas).
Me di cuenta que el .update funciona aunque tengas tuplas, listas y conjuntos, al final los agrega siempre:
idiomas = {"Ingles", "Frances", "Español"}
idiomas2 = ("Koreano", "Mandarin", "Salvadoreño")
idiomas3 = ["Griego", "Japones", "Nahuat"]
print (type(idiomas))
print (type(idiomas2))
print (type(idiomas3))
print(idiomas,idiomas2,idiomas3)
print(idiomas)
print(idiomas2)
print(idiomas3)
print(len(idiomas))
print(len(idiomas2))
print(len(idiomas3))
print(idiomas)
print(idiomas2)
print ("Ingles" in idiomas3)
idiomas.add("Latin")
print(idiomas)
idiomas.update(idiomas2)
print(idiomas)
idiomas.update(idiomas2,idiomas3)
print(idiomas)
A={1,2,3}
B={3,4,5}
#union
C=A.union(B)
print(C)
#diferencia
D=A.difference(B)
print(D)
#Intercepcion
E=A.intersection(B)
print(E)
Si ejecutan el método symmetric_difference, pueden obtener un nuevo conjunto conteniendo solo los elementos únicos que no son comunes en ambos conjuntos.
numero =[1,2,2,3,3,3]unicos =list(set(numero))print(unicos)abc=["a","v","s","f","e","a","s","f","g","a","s","e","a","s","a","e"]abcUnico =list(set(abc))abcUnico.sort()print(abcUnico)
# Conjuntos en Python: creacion, metodos y Operaciones basicas
"""Conjuntos/set coleciones no ordenadas que no permiten duplicados"""
Lo que hay que tener en cuenta y que alguien me corrija si no es así que la funcionalidad de pop es eliminar siempre el primer elemento, sea aleatorio o no
Buenas tardes,
Pop es un metodo que pertenece a las listas y te elimina el ultimo elemento de la lista o el de un elemento especifico siempre y cuando pases el indice del elemento a eliminar
me rectifico (desestima lo que mencione), pop para conjuntos elimina elemento aleatorio asi tal cual se explica en esta clase.
Puede ser el primer elemento como el ultimo, en mi caso, me borro el ultimo elemento
conjuntos = { "Apple" , 1 , True, 3.14} # asume 1 y True como iguales
print(conjuntos)
print(type(conjuntos))
print(len(conjuntos))
for item in conjuntos:
print(item)
¿Por qué son diferentes los métodos de los conjuntos y las listas?, creo que sería más práctico tener los mismos métodos en ambos, ya que sus funciones son prácticamente iguales.
Hay un caso interesante que me surgió al crear un conjunto con tipos de datos mixtos, por ejemplo hice el siguiente:
conjuntos = {"Python",1,True}
Al imprimir la variable conjuntos, el resultado solo me muestra
{1, 'Python'}
Por lo que entiendo que probablemente el conjunto esté tomando el 1 y el True como los mismos valores, recordemos que se puede usar el 1 y el 0 como True o False en booleano respectivamente.
Hay que tener cuidado al usar conjuntos con Booleanos y enteros
