Conjuntos en Python: qué son y cómo usarlos

Contenido del curso

Primeros Pasos con Python

Lógica de Programación y Control de Flujo

Estructuras de Datos Fundamentales

Modularización del Código

Manejo de Errores y Archivos

Trabajo Práctico Final

Tomar examen

Cursos Empresas Blog Live Conf Eventos Precios

0:0014:01

Conjuntos en Python: qué son y cómo usarlos

Curso de Fundamentos de Python

Clase 24 de 32

Clase 24 / 32

Recursos

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í:

python frutas = {"manzana", "naranja", "mandarina"} print(type(frutas)) # <class 'set'>

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].

python frutas.add("pera") frutas_tropicales = {"piña", "mango"} frutas.update(frutas_tropicales)

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:

python set1 = {"a", "b", "c"} set2 = {"c", "d", "e"}

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:

python lista = [1, 2, 2, 3, 3, 4] lista_limpia = list(set(lista))

El resultado es una lista sin valores repetidos. Ten en cuenta que el orden original puede perderse, ya que el set no lo conserva.

¿Has usado conjuntos para limpiar datos en algún proyecto? Cuéntame en los comentarios qué problema resolviste con ellos.

Cristian Oswaldo Sacta Martos

Hace 6 meses

#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)

#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)

Comentarios (29)29 comentarios

Samuel Steven Bernal Martínez

Hace un año

Sergie Code

Profesor

Gustavo Garcia Adame

David Behar

Gabriel Londoño

Hace 8 meses

Argenis Daniel Nieves Berroeta

Hace 9 meses•editado

Eduardo Jose Franco Rivera

Dilean Shadai García Alvarez

Hace un mes

Adrian Andres Landazuri Rivas

Sara María Mejia Sánchez

Hace 5 meses

Sergio Daniel Flamenco

Hace 7 meses

Jackssuriss Tatiana Herrera Florez

Pablo Luna

Hace 2 meses

Daniel Rodriguez

Hace 3 meses

Carlos Alfredo Portillo Posada

Melkin Linares

Ana Marina Perez Aguilera

JULIO CÉSAR VILLALTA MIRANDA

Francisco Giuliano Forciniti

Jarod Fernando Fernandez Morales

Ana Belen Chamba Mera

Primeros Pasos con Python

Por qué Instagram y NASA eligieron Python

Instalación de Python, VS Code y Git

Variables de entorno de Python en Windows

Comandos básicos de Python en la terminal de Windows

Sintaxis e indentación básica en Python con Visual Studio Code

Comentarios en Python: una y multilínea

Variables en Python: reglas y convenciones

Asignación múltiple de variables en Python

Tipos de datos en Python explicados

Manipulación y conversión de tipos numéricos en Python

Métodos esenciales para strings en Python

Slicing, replace y split para manipular strings en Python

Booleanos en Python: True, False y casting

None en Python no es cero ni vacío

Lógica de Programación y Control de Flujo

Operadores aritméticos en Python explicados

Operadores de asignación y walrus en Python

Operadores lógicos y de comparación en Python

Condicionales en Python: if, else, and, or y pass

Sentencia match en Python 3.10 para control de flujo

Bucles while en Python: condiciones, break y continue

Bucle for en Python para recorrer listas

Estructuras de Datos Fundamentales

Métodos esenciales de listas en Python

Tuplas en Python: ordenadas e inmutables

Conjuntos en Python: qué son y cómo usarlos

Diccionarios en Python: claves y valores

Modularización del Código

Funciones en Python para reutilizar código

Funciones lambda y fábrica de funciones en Python

Cómo usar módulos en Python

Manejo de Errores y Archivos

Manejo de errores con try, except y finally en Python

Leer y escribir archivos de texto en Python

Trabajo Práctico Final

Máquina de café en Python paso a paso

Escritura y lectura de archivos en Python

Conjuntos en Python: qué son y cómo usarlos