Introducción
¡Bienvenidos a este laboratorio sobre Conjuntos (Sets) en Python! Python proporciona varios tipos de datos incorporados para organizar la información, incluyendo listas, diccionarios, tuplas y conjuntos (sets).
Según la documentación oficial de Python, un conjunto es una colección desordenada sin elementos duplicados. Sus usos principales son para la prueba de pertenencia (membership testing) y la eliminación de entradas duplicadas.
En este laboratorio, explorará cómo crear, manipular y utilizar conjuntos de manera efectiva a través de una serie de ejercicios prácticos.
Inicialización de un Conjunto
En este paso, aprenderás las dos formas principales de crear conjuntos (sets) en Python: usando llaves {} y la función incorporada set(). Es crucial entender que usar llaves vacías {} crea un diccionario vacío, no un conjunto vacío.
Nota: Si no estás familiarizado con el uso de WebIDE (similar a VS Code), por favor, apréndelo primero en este laboratorio.
Primero, abre el archivo step1.py desde el explorador de archivos a la izquierda.
Ahora, copia y pega el siguiente código en step1.py. Este código demuestra cómo crear conjuntos y resalta el caso especial de la creación de un conjunto vacío.
## Create set using curly braces or set() function
s_braces = {1, 2, 3}
print(f"Set with braces: {s_braces}, type: {type(s_braces)}")
s_func = set([1, 2, 3])
print(f"Set with function: {s_func}, type: {type(s_func)}")
## Warning: empty {} creates a dictionary, not a set
s_dict = {}
print(f"Empty braces create a: {type(s_dict)}")
## To create an empty set, you must use set()
s_empty = set()
print(f"To create an empty set use set(): {type(s_empty)}")
Guarda el archivo y luego ejecútalo desde la terminal ejecutando el siguiente comando:
python3 step1.py
Deberías ver la siguiente salida, que confirma los tipos de los objetos creados. Observa que {} resulta en <class 'dict'>.
Set with braces: {1, 2, 3}, type: <class 'set'>
Set with function: {1, 2, 3}, type: <class 'set'>
Empty braces create a: <class 'dict'>
To create an empty set use set(): <class 'set'>
Comprensión de las Propiedades de los Conjuntos
En este paso, explorará las propiedades fundamentales de los conjuntos (sets). Los conjuntos son potentes porque imponen automáticamente la unicidad y no están ordenados. Esto significa que un conjunto eliminará automáticamente cualquier valor duplicado, y no se puede acceder a sus elementos mediante un índice.
Abra el archivo step2.py.
Copie y pegue el siguiente código en step2.py. La primera parte del código demuestra cómo se manejan los duplicados, y la segunda parte muestra lo que sucede cuando intenta indexar un conjunto.
## Sets automatically remove duplicates
s_duplicates = {1, 2, 3, 2, 3, 4}
print(f"Original with duplicates: {{1, 2, 3, 2, 3, 4}}")
print(f"Set with duplicates removed: {s_duplicates}")
## Sets are unordered and cannot be indexed
print("\nAttempting to access a set by index...")
try:
s = {1, 2, 3}
s[0]
except TypeError as e:
print(f"Error when indexing: {e}")
Ahora, ejecute el script desde la terminal:
python3 step2.py
La salida será:
Original with duplicates: {1, 2, 3, 2, 3, 4}
Set with duplicates removed: {1, 2, 3, 4}
Attempting to access a set by index...
Error when indexing: 'set' object is not subscriptable
Como puede observar, los duplicados 2 y 3 se eliminaron automáticamente. El intento de acceder a s[0] resultó en un TypeError, lo que confirma que los conjuntos no admiten la indexación (subscripting).
Añadir y Actualizar Elementos
En este paso, aprenderá cómo añadir nuevos elementos a un conjunto existente. Python proporciona dos métodos principales para esto: add() para añadir un único elemento y update() para añadir múltiples elementos desde un iterable (como una lista u otro conjunto).
Abra el archivo step3.py.
Copie y pegue el siguiente código en step3.py. Este código primero creará un conjunto, luego añadirá un único elemento y finalmente lo actualizará con múltiples elementos.
## Start with a set
s = {1, 2, 3}
print(f"Original set: {s}")
## add() method: add a single element
s.add(4)
print(f"After adding 4: {s}")
## update() method: add multiple elements from an iterable
s.update([2, 3, 4, 5, 6]) ## Duplicates like 2, 3, 4 are ignored
print(f"After updating with [2, 3, 4, 5, 6]: {s}")
Ejecute el script desde la terminal:
python3 step3.py
Su salida debería ser la siguiente. Tenga en cuenta que al usar update(), cualquier elemento que ya esté en el conjunto simplemente se ignora.
Original set: {1, 2, 3}
After adding 4: {1, 2, 3, 4}
After updating with [2, 3, 4, 5, 6]: {1, 2, 3, 4, 5, 6}
Eliminar y Descartar Elementos
En este paso, aprenderá dos formas de eliminar elementos de un conjunto: remove() y discard(). Aunque ambos métodos eliminan un elemento, se comportan de manera diferente cuando el elemento no se encuentra. remove() generará un KeyError, lo que puede hacer que su programa falle si no se maneja, mientras que discard() no hará nada y continuará silenciosamente.
Abra el archivo step4.py.
Copie y pegue el siguiente código, que demuestra el comportamiento de ambos métodos.
## remove() method: raises KeyError if element is not found
s = {1, 2, 3}
print(f"Original set: {s}")
s.remove(3)
print(f"After removing 3: {s}")
## Trying to remove an element that doesn't exist with remove()
try:
s.remove(3)
except KeyError as e:
print(f"Error when removing 3 again: KeyError: {e}")
## discard() method: does not raise an error if element is not found
s = {1, 2, 3}
print(f"\nNew original set: {s}")
s.discard(3)
print(f"After discarding 3: {s}")
s.discard(3) ## No error is raised
print(f"After discarding 3 again (no error): {s}")
Ejecute el script desde la terminal:
python3 step4.py
La salida muestra claramente la diferencia:
Original set: {1, 2, 3}
After removing 3: {1, 2}
Error when removing 3 again: KeyError: 3
New original set: {1, 2, 3}
After discarding 3: {1, 2}
After discarding 3 again (no error): {1, 2}
Elegir entre remove() y discard() depende de si desea que su programa falle explícitamente cuando falta un elemento o si desea manejar su ausencia de forma segura (gracefully).
Operaciones de Conjuntos
En este paso final, practicará las operaciones de conjuntos más comunes. Estas operaciones le permiten combinar y comparar conjuntos de maneras potentes. Utilizará tanto la sintaxis de método (ej. s1.union(s2)) como la sintaxis de operador (ej. s1 | s2).
- Unión (
union()o|): Crea un nuevo conjunto con todos los elementos de los conjuntos proporcionados. - Intersección (
intersection()o&): Devuelve un nuevo conjunto solo con los elementos que son comunes a todos los conjuntos. - Diferencia (
difference()o-): Devuelve un nuevo conjunto con los elementos que están en el primer conjunto pero no en el segundo. - Diferencia Simétrica (
symmetric_difference()o^): Devuelve un nuevo conjunto con los elementos que están en uno u otro conjunto, pero no en ambos.
Abra el archivo step5.py.
Copie y pegue el siguiente código para realizar estas cuatro operaciones en dos conjuntos de ejemplo.
s1 = {1, 2, 3}
s2 = {2, 3, 4}
print(f"s1 = {s1}")
print(f"s2 = {s2}\n")
## union() or |
## Returns a new set containing all items from both sets.
print(f"Union (s1 | s2): {s1.union(s2)}")
## intersection() or &
## Returns a new set containing items common to both sets.
s3 = {3, 4, 5}
print(f"Intersection (s1 & s2): {s1.intersection(s2)}")
## difference() or -
## Returns a new set containing items in the first set but not in the second.
print(f"Difference (s1 - s2): {s1.difference(s2)}")
print(f"Difference (s2 - s1): {s2.difference(s1)}")
## symmetric_difference() or ^
## Returns a new set with elements in either set, but not both.
print(f"Symmetric Difference (s1 ^ s2): {s1.symmetric_difference(s2)}")
Ejecute el script desde la terminal:
python3 step5.py
Examine la salida para comprender el resultado de cada operación:
s1 = {1, 2, 3}
s2 = {2, 3, 4}
Union (s1 | s2): {1, 2, 3, 4}
Intersection (s1 & s2): {2, 3}
Difference (s1 - s2): {1}
Difference (s2 - s1): {4}
Symmetric Difference (s1 ^ s2): {1, 4}
Resumen
En este laboratorio, ha aprendido los fundamentos de los conjuntos (sets) en Python. Comenzó inicializando conjuntos usando tanto llaves {} como la función set(), notando la distinción importante para crear conjuntos vacíos. Exploró las propiedades centrales de los conjuntos: no están ordenados y solo almacenan elementos únicos. Practicó la modificación de conjuntos añadiendo elementos con add() y update(), y eliminándolos con los métodos remove() y discard(), entendiendo la diferencia clave entre ellos. Finalmente, realizó operaciones esenciales de conjuntos, incluyendo unión (|), intersección (&), diferencia (-) y diferencia simétrica (^). Ahora tiene una base sólida para utilizar conjuntos para manejar colecciones de elementos únicos en sus programas Python.
