Saltar al contenido
Editor

Conjuntos (sets) en Python: operaciones, métodos y casos de uso

Intermedio20 min6 ejercicios85 XP

Esta lección es una traducción del original en inglés.Read in EnglishAvisar de un error de traducción

0/6 ejercicios

Imagina que eres docente y estás pasando lista. Un estudiante firma la hoja de asistencia dos veces sin querer. ¿Significa eso que está dos veces en clase? Claro que no. Solo te importa quién vino, no cuántas veces escribió su nombre.

Un conjunto de Python (en inglés, set) funciona igual. Es una colección que elimina los duplicados automáticamente. Cada elemento de un conjunto es único. A los conjuntos tampoco les importa el orden: solo les importa la pertenencia, es decir, si un elemento está o no.

En esta lección aprenderás a crear conjuntos, a hacer operaciones potentes como la unión y la intersección, a modificarlos con métodos y a reconocer cuándo un conjunto es la herramienta perfecta.

Cómo crear un conjunto en Python

Para crear un conjunto, escribe los elementos entre llaves {}, separados por comas. Si añades valores duplicados, Python los ignora sin decir nada.

Crear conjuntos con llaves
# A basic set of fruits
fruits = {'apple', 'banana', 'cherry'}
print(fruits)
# Duplicates are automatically removed
colors = {'red', 'blue', 'red', 'green', 'blue'}
print(colors) # Only 3 unique colors
Salida
{'apple', 'banana', 'cherry'}
{'red', 'green', 'blue'}

Fíjate en que el orden de la salida puede ser distinto del que escribiste. Los conjuntos no tienen orden, así que Python puede guardar los elementos internamente en cualquier disposición. No cuentes con que un conjunto mantenga un orden concreto.

También puedes crear un conjunto a partir de una lista con el constructor set(). Es una forma muy popular de eliminar los duplicados de una lista.

Crear conjuntos con el constructor set()
# Convert a list with duplicates into a set
names_list = ['Alice', 'Bob', 'Alice', 'Charlie', 'Bob']
names_set = set(names_list)
print(names_set) # Only unique names
# Create a set from a string (each character becomes an item)
letters = set('hello')
print(letters) # {'h', 'e', 'l', 'o'} - only one 'l'
Salida
{'Bob', 'Alice', 'Charlie'}
{'o', 'l', 'e', 'h'}

Operaciones con conjuntos: unión, intersección y diferencia

La verdadera potencia de los conjuntos está en las operaciones de conjuntos. Te permiten combinar conjuntos, compararlos y encontrar sus diferencias. Piensa en ellas como los diagramas de Venn de la clase de matemáticas.

Unión: combinarlo todo

La unión te da todos los elementos de ambos conjuntos, sin duplicados. Puedes usar el operador | o el método .union().

La unión combina todos los elementos únicos
math_students = {'Alice', 'Bob', 'Charlie'}
science_students = {'Bob', 'Diana', 'Charlie'}
# Union - everyone in either class
all_students = math_students | science_students
print(all_students)
# Same thing using the method
all_students = math_students.union(science_students)
print(all_students)
Salida
{'Charlie', 'Bob', 'Alice', 'Diana'}
{'Charlie', 'Bob', 'Alice', 'Diana'}

Intersección: encontrar lo que tienen en común

La intersección te da solo los elementos que aparecen en ambos conjuntos. Usa el operador & o .intersection().

La intersección encuentra los elementos comunes
math_students = {'Alice', 'Bob', 'Charlie'}
science_students = {'Bob', 'Diana', 'Charlie'}
# Intersection - students in BOTH classes
both_classes = math_students & science_students
print(both_classes) # {'Bob', 'Charlie'}
Salida
{'Bob', 'Charlie'}

Diferencia: lo que solo está en un conjunto

La diferencia te da los elementos que están en el primer conjunto pero no en el segundo. Usa el operador - o .difference(). Aquí el orden importa.

La diferencia encuentra lo que solo está en un conjunto
math_students = {'Alice', 'Bob', 'Charlie'}
science_students = {'Bob', 'Diana', 'Charlie'}
# Who is ONLY in math?
math_only = math_students - science_students
print(math_only) # {'Alice'}
# Who is ONLY in science?
science_only = science_students - math_students
print(science_only) # {'Diana'}
Salida
{'Alice'}
{'Diana'}

Diferencia simétrica: en uno de los dos, pero no en ambos

La diferencia simétrica te da los elementos que están en uno u otro conjunto, pero no en ambos. Piensa en ella como lo contrario de la intersección. Usa el operador ^ o .symmetric_difference().

La diferencia simétrica excluye los elementos compartidos
math_students = {'Alice', 'Bob', 'Charlie'}
science_students = {'Bob', 'Diana', 'Charlie'}
# Students in only ONE class (not both)
exclusive = math_students ^ science_students
print(exclusive) # {'Alice', 'Diana'}
Salida
{'Alice', 'Diana'}

Cómo añadir y eliminar elementos de un conjunto

Los conjuntos son mutables: puedes añadir y eliminar elementos después de crearlos. Estos son los métodos clave que vas a usar.

Añadir y eliminar elementos de un conjunto
fruits = {'apple', 'banana'}
# Add a single item
fruits.add('cherry')
print(fruits)
# Add multiple items at once
fruits.update(['date', 'elderberry'])
print(fruits)
# Remove an item (raises error if not found)
fruits.remove('banana')
print(fruits)
# Discard an item (no error if not found)
fruits.discard('mango') # No crash!
print(fruits)
Salida
{'apple', 'banana', 'cherry'}
{'date', 'elderberry', 'apple', 'banana', 'cherry'}
{'date', 'elderberry', 'apple', 'cherry'}
{'date', 'elderberry', 'apple', 'cherry'}

También puedes vaciar el conjunto por completo o sacar de él un elemento cualquiera.

Los métodos pop y clear
numbers = {10, 20, 30, 40, 50}
# Pop removes and returns an arbitrary item
removed = numbers.pop()
print(f'Removed: {removed}')
print(f'Remaining: {numbers}')
# Clear removes everything
numbers.clear()
print(numbers) # set()
Salida
Removed: 50
Remaining: {20, 40, 10, 30}
set()

Por qué los conjuntos son rapidísimos para buscar elementos

Una de las mejores razones para usar un conjunto es comprobar si algo existe. La palabra clave in funciona tanto con listas como con conjuntos, pero los conjuntos son muchísimo más rápidos.

Búsquedas rápidas con in
allowed_users = {'alice', 'bob', 'charlie', 'diana'}
user = 'bob'
if user in allowed_users:
print(f'{user} is allowed!')
else:
print(f'{user} is not allowed.')
# Checking who is NOT in the set
user2 = 'eve'
if user2 not in allowed_users:
print(f'{user2} is not on the list.')
Salida
bob is allowed!
eve is not on the list.

¿Qué son los frozensets?

Un frozenset es una versión inmutable de un conjunto. Una vez creado, no puedes añadir ni eliminar elementos. Esto hace que los frozensets sean hashables, es decir, que se pueden usar como claves de diccionario o guardar dentro de otros conjuntos.

Los frozensets son conjuntos inmutables
# Create a frozenset
vowels = frozenset(['a', 'e', 'i', 'o', 'u'])
print(vowels)
# You can still do set operations
consonants = frozenset(['b', 'c', 'd', 'f', 'g'])
all_letters = vowels | consonants
print(all_letters)
# But you CANNOT modify it
# vowels.add('y') # AttributeError!
Salida
frozenset({'u', 'o', 'i', 'e', 'a'})
frozenset({'u', 'o', 'i', 'f', 'g', 'd', 'e', 'b', 'c', 'a'})

¿Cuándo usar un conjunto en lugar de una lista?

Los conjuntos y las listas resuelven problemas distintos. Una regla sencilla: si te importa el orden o los duplicados, usa una lista. Si te importa que los elementos sean únicos o que las búsquedas sean rápidas, usa un conjunto.

Usa una lista cuando...
# Order matters
playlist = ['song1', 'song2', 'song3']

# Duplicates are meaningful
die_rolls = [3, 5, 3, 2, 5, 6]

# You need index access
first = playlist[0]
Usa un conjunto cuando...
# Only unique items matter
tags = {'python', 'coding', 'tutorial'}

# Fast membership checks
if 'python' in tags:
    print('Found!')

# Removing duplicates
unique = set([1, 2, 2, 3, 3])

Ejercicios de práctica

Elimina los duplicados de una lista
Escribe el código

Tienes una lista de direcciones de correo electrónico en la que algunas aparecen más de una vez. Crea un conjunto llamado unique_emails a partir de la lista emails e imprímelo ordenado alfabéticamente con sorted().

emails = ['alice@mail.com', 'bob@mail.com', 'alice@mail.com', 'charlie@mail.com', 'bob@mail.com']
# Create a set of unique emails and print them sorted
Predice la salida del conjunto
Predice la salida

¿Qué imprime este código? Piensa bien en cómo tratan los conjuntos los duplicados y en qué devuelve la función len().

data = [1, 2, 2, 3, 3, 3, 4, 4, 4, 4]
unique = set(data)
print(len(unique))

Escribe una instrucción print() con la salida exacta.

# What does this code print?
data = [1, 2, 2, 3, 3, 3, 4, 4, 4, 4]
unique = set(data)
print(len(unique))
Encuentra a los estudiantes que están en ambas clases
Escribe el código

Tienes dos conjuntos: math y english. Encuentra e imprime los estudiantes inscritos en ambas clases. Imprime el resultado como una lista ordenada.

math = {'Alice', 'Bob', 'Charlie', 'Diana'}
english = {'Bob', 'Diana', 'Eve', 'Frank'}
# Find students in both classes and print sorted
Corrige el error del conjunto vacío
Corrige el error

Este código intenta crear un conjunto vacío, añadirle elementos e imprimir el resultado. Pero tiene un error: quien lo escribió usó {} para crear un conjunto vacío. Corrige el error para que el código funcione bien.

# Bug: this creates a dictionary, not a set!
my_set = {}
my_set.add('python')
my_set.add('java')
my_set.add('python') # duplicate
print(sorted(my_set))
Encuentra los ingredientes que faltan
Escribe el código

Tienes un conjunto recipe con todos los ingredientes necesarios y un conjunto pantry con lo que ya tienes en la despensa. Encuentra los ingredientes que todavía tienes que comprar e imprímelos como una lista ordenada.

recipe = {'flour', 'sugar', 'eggs', 'butter', 'vanilla'}
pantry = {'flour', 'eggs', 'salt', 'pepper'}
# Find and print what you need to buy (sorted)
Elimina duplicados sin perder el orden
Escribe el código

Escribe una función llamada dedupe(items) que elimine los duplicados de una lista sin perder el orden original. Usa un conjunto para llevar la cuenta de los elementos que ya has visto. Devuelve la lista sin duplicados.

Pruébala llamando a print(dedupe([3, 1, 4, 1, 5, 9, 2, 6, 5, 3])).

def dedupe(items):
# Use a set to track seen items
# Build a new list with only first occurrences
pass
print(dedupe([3, 1, 4, 1, 5, 9, 2, 6, 5, 3]))

Tutoriales relacionados

¿Te sirvió este tutorial?

Sugerir una mejora