Trabajar con Conjuntos (Sets) en Python

PythonBeginner
Practicar Ahora

Introducción

En este laboratorio, obtendrá experiencia práctica con los conjuntos (sets) en Python. Los conjuntos son una estructura de datos fundamental utilizada para almacenar elementos únicos y no ordenados. Son muy eficientes para tareas como verificar si un elemento está presente en una colección y para realizar operaciones matemáticas de conjuntos.

Aprenderá a crear conjuntos, añadir y eliminar elementos, y a realizar operaciones comunes como unión (union), intersección (intersection) y diferencia (difference). Finalmente, verá una aplicación práctica de los conjuntos al utilizarlos para eliminar fácilmente elementos duplicados de una lista.

Este es un Guided Lab, que proporciona instrucciones paso a paso para ayudarte a aprender y practicar. Sigue las instrucciones cuidadosamente para completar cada paso y obtener experiencia práctica. Los datos históricos muestran que este es un laboratorio de nivel principiante con una tasa de finalización del 100%. Ha recibido una tasa de reseñas positivas del 100% por parte de los estudiantes.

Crear y Añadir Elementos a un Conjunto

En este primer paso, aprenderá a crear conjuntos y a añadirles nuevos elementos. Los conjuntos son colecciones de elementos únicos, lo que significa que descartan automáticamente cualquier duplicado.

Su entorno incluye un archivo vacío llamado set_basics.py. Utilizando el explorador de archivos en el lado izquierdo del editor, busque y abra ~/project/set_basics.py.

Añada el siguiente código Python al archivo. Este código demuestra varias formas de crear un conjunto.

## Método 1: Usando llaves {}
## Esto crea un conjunto con elementos iniciales.
my_set = {'apple', 'banana', 'cherry'}
print("Set created with braces:", my_set)
print("Type of my_set:", type(my_set))

## Nota: Los conjuntos eliminan automáticamente los elementos duplicados.
duplicate_set = {'apple', 'banana', 'apple'}
print("Set with duplicates:", duplicate_set)

## Método 2: Usando el constructor set() en un iterable (como una cadena)
## Esto crea un conjunto a partir de los caracteres únicos de la cadena.
char_set = set('hello world')
print("Set from a string:", char_set)

## Método 3: Creando un conjunto vacío
## Debe usar set() para crear un conjunto vacío. {} crea un diccionario vacío.
empty_set = set()
print("An empty set:", empty_set)
print("Type of empty_set:", type(empty_set))

Guarde el archivo. Ahora, abra una terminal en su editor (puede usar el menú: Terminal -> New Terminal) y ejecute su script con el siguiente comando.

python ~/project/set_basics.py

Verá una salida similar a la siguiente. Observe que el orden de los elementos en un conjunto no está garantizado y que los duplicados se eliminan.

Set created with braces: {'cherry', 'apple', 'banana'}
Type of my_set: <class 'set'>
Set with duplicates: {'banana', 'apple'}
Set from a string: {'d', 'l', 'o', 'r', 'w', ' ', 'h', 'e'}
An empty set: set()
Type of empty_set: <class 'set'>

A continuación, añadiremos nuevos elementos a un conjunto existente. Puede añadir un único elemento con el método add() o múltiples elementos con el método update().

Añada el siguiente código al final de su archivo set_basics.py.

## --- Adding elements ---
fruits = {'apple', 'banana'}
print("\nOriginal fruits set:", fruits)

## Use add() to add a single element
fruits.add('orange')
print("After adding 'orange':", fruits)

## add() has no effect if the element is already present
fruits.add('apple')
print("After adding 'apple' again:", fruits)

## Use update() to add multiple elements from an iterable (like a list)
fruits.update(['mango', 'grape'])
print("After updating with a list:", fruits)

Guarde el archivo de nuevo y ejecute el script actualizado desde la terminal.

python ~/project/set_basics.py

La salida ahora incluirá los resultados de la adición de elementos.

Set created with braces: {'cherry', 'apple', 'banana'}
Type of my_set: <class 'set'>
Set with duplicates: {'banana', 'apple'}
Set from a string: {'d', 'l', 'o', 'r', 'w', ' ', 'h', 'e'}
An empty set: set()
Type of empty_set: <class 'set'>

Original fruits set: {'banana', 'apple'}
After adding 'orange': {'banana', 'orange', 'apple'}
After adding 'apple' again: {'banana', 'orange', 'apple'}
After updating with a list: {'grape', 'mango', 'banana', 'orange', 'apple'}

Ahora ha aprendido a crear conjuntos y a modificarlos añadiendo nuevos elementos.

Eliminar Elementos de un Conjunto

En este paso, aprenderá varias formas de eliminar elementos de un conjunto. Dado que los conjuntos no están ordenados, no puede usar un índice para eliminar elementos. En su lugar, Python proporciona métodos específicos para este propósito.

Busque y abra el archivo set_removal.py en su directorio ~/project.

Añada el siguiente código al archivo. Demuestra los métodos remove(), discard(), pop() y clear().

## --- Removing elements ---
my_set = {'a', 'b', 'c', 'd', 'e'}
print("Original set:", my_set)

## Método 1: remove()
## Esto elimina un elemento especificado. Genera un KeyError si el elemento no se encuentra.
my_set.remove('b')
print("After removing 'b':", my_set)
## La siguiente línea causaría un error: my_set.remove('z')

## Método 2: discard()
## Esto también elimina un elemento especificado, pero NO genera un error si el elemento no se encuentra.
print("\nStarting set for discard:", my_set)
my_set.discard('c')
print("After discarding 'c':", my_set)
my_set.discard('z') ## 'z' no está en el conjunto, pero no ocurre ningún error.
print("After discarding 'z' (non-existent):", my_set)

## Método 3: pop()
## Esto elimina y devuelve un elemento arbitrario del conjunto.
## Dado que los conjuntos no están ordenados, no se sabe qué elemento será extraído.
print("\nStarting set for pop:", my_set)
popped_item = my_set.pop()
print("Popped item:", popped_item)
print("Set after pop():", my_set)

## Método 4: clear()
## Esto elimina todos los elementos del conjunto, dejando un conjunto vacío.
print("\nStarting set for clear:", my_set)
my_set.clear()
print("Set after clear():", my_set)

Guarde el archivo. Ahora, ejecute el script desde su terminal.

python ~/project/set_removal.py

Su salida debería ser similar a esta. El elemento eliminado por pop() puede ser diferente cada vez que ejecute el script porque los conjuntos no están ordenados.

Original set: {'d', 'c', 'e', 'a', 'b'}
After removing 'b': {'d', 'c', 'e', 'a'}

Starting set for discard: {'d', 'c', 'e', 'a'}
After discarding 'c': {'d', 'e', 'a'}
After discarding 'z' (non-existent): {'d', 'e', 'a'}

Starting set for pop: {'d', 'e', 'a'}
Popped item: d
Set after pop(): {'e', 'a'}

Starting set for clear: {'e', 'a'}
Set after clear(): set()

Ahora conoce los métodos clave para eliminar elementos de un conjunto y comprende la diferencia importante entre remove() y discard().

Realizar Operaciones de Conjuntos

Los conjuntos son particularmente potentes para realizar operaciones matemáticas como la unión, la intersección y la diferencia. En este paso, aprenderá a realizar estas operaciones en Python.

Busque y abra el archivo set_operations.py en su directorio ~/project.

Añada el siguiente código al archivo. Este código define dos conjuntos y luego realiza las tres operaciones principales de conjuntos sobre ellos.

set_a = {'a', 'b', 'c', 'd'}
set_b = {'c', 'd', 'e', 'f'}

print("Set A:", set_a)
print("Set B:", set_b)

## --- Unión (Union) ---
## La unión contiene todos los elementos únicos de ambos conjuntos.
## Puede usar el operador | o el método .union().
union_set_op = set_a | set_b
union_set_method = set_a.union(set_b)
print("\nUnion with | operator:", union_set_op)
print("Union with .union() method:", union_set_method)

## --- Intersección (Intersection) ---
## La intersección contiene solo los elementos que son comunes a ambos conjuntos.
## Puede usar el operador & o el método .intersection().
intersection_set_op = set_a & set_b
intersection_set_method = set_a.intersection(set_b)
print("\nIntersection with & operator:", intersection_set_op)
print("Intersection with .intersection() method:", intersection_set_method)

## --- Diferencia (Difference) ---
## La diferencia contiene los elementos que están en el primer conjunto pero NO en el segundo conjunto.
## Puede usar el operador - o el método .difference().
difference_set_op = set_a - set_b
difference_set_method = set_a.difference(set_b)
print("\nDifference (A - B) with - operator:", difference_set_op)
print("Difference (A - B) with .difference() method:", difference_set_method)

## Nótese que el orden importa para la diferencia
difference_b_a = set_b - set_a
print("Difference (B - A):", difference_b_a)

Guarde el archivo y ejecútelo desde la terminal.

python ~/project/set_operations.py

La salida mostrará claramente los resultados de cada operación.

Set A: {'d', 'c', 'a', 'b'}
Set B: {'d', 'c', 'f', 'e'}

Union with | operator: {'d', 'c', 'f', 'e', 'a', 'b'}
Union with .union() method: {'d', 'c', 'f', 'e', 'a', 'b'}

Intersection with & operator: {'d', 'c'}
Intersection with .intersection() method: {'d', 'c'}

Difference (A - B) with - operator: {'a', 'b'}
Difference (A - B) with .difference() method: {'a', 'b'}
Difference (B - A): {'f', 'e'}

Ha utilizado con éxito tanto los símbolos de operador como los métodos para realizar operaciones de unión, intersección y diferencia en conjuntos.

Usar un Conjunto para Eliminar Duplicados de una Lista

Uno de los usos más comunes y prácticos de los conjuntos es eliminar rápidamente elementos duplicados de una lista. Debido a que los conjuntos solo pueden contener elementos únicos, convertir una lista a un conjunto y luego de vuelta a una lista es una forma sencilla y eficiente de lograr esto.

Busque y abra el archivo final para este laboratorio, remove_duplicates.py, en su directorio ~/project.

Añada el siguiente código al archivo.

## A list containing several duplicate numbers
numbers_list = [1, 5, 2, 3, 5, 1, 4, 2, 2, 5]
print("Original list with duplicates:", numbers_list)

## Step 1: Convert the list to a set.
## This automatically removes all duplicate elements.
unique_numbers_set = set(numbers_list)
print("Set created from list (duplicates gone):", unique_numbers_set)

## Step 2: Convert the set back to a list.
## The new list will only contain the unique elements.
unique_numbers_list = list(unique_numbers_set)
print("Final list with duplicates removed:", unique_numbers_list)

## Note: This process does not preserve the original order of the elements
## because sets are an unordered data structure.

Guarde el archivo y ejecútelo desde la terminal.

python ~/project/remove_duplicates.py

La salida demuestra todo el proceso, mostrando la lista original, el conjunto intermedio y la lista final sin duplicados.

Original list with duplicates: [1, 5, 2, 3, 5, 1, 4, 2, 2, 5]
Set created from list (duplicates gone): {1, 2, 3, 4, 5}
Final list with duplicates removed: [1, 2, 3, 4, 5]

Ha aplicado con éxito su conocimiento de los conjuntos para resolver un problema común de programación: eliminar duplicados de una lista.

Resumen

En este laboratorio, ha aprendido las habilidades esenciales para trabajar con conjuntos (sets) en Python. Comenzó creando conjuntos utilizando diferentes sintaxis y aprendió cómo estos imponen inherentemente la unicidad. Practicó la modificación de conjuntos añadiendo elementos con add() y update(), y eliminándolos con remove(), discard(), pop() y clear(), observando las diferencias clave entre estos métodos.

Además, exploró las operaciones fundamentales de conjuntos matemáticos: unión (|), intersección (&) y diferencia (-), que son cruciales para el análisis de datos y el diseño de algoritmos. Finalmente, puso este conocimiento en práctica implementando una técnica elegante para eliminar elementos duplicados de una lista, una tarea común en la limpieza y preparación de datos. Ahora está equipado para utilizar conjuntos de manera efectiva en sus programas de Python.