Acordeón de los Índices

Índice de los temas

Python Sets
Acess Sets Item
Remove Set Items
Loops Sets
Join Sets
Set Methods

Lección: 15 - Python Sets

Python Sets

🔥 Sets en Python: Colecciones Únicas y Desordenadas

Un set en Python es una colección de elementos que tiene dos características principales: es desordenado y contiene solo elementos únicos. Esto significa que los sets no mantienen un orden específico de los elementos y automáticamente eliminan cualquier duplicado.

Los sets se escriben con llaves `{}`.

Características Principales de los Sets:

Desordenados: Los elementos en un set no tienen un orden específico. No puedes acceder a los elementos por índice como en las listas o tuplas.
Únicos: Un set solo puede contener elementos únicos. Si intentas agregar un elemento que ya existe, no se agregará nuevamente al set.
Mutables: Los sets son mutables, lo que significa que puedes agregar o eliminar elementos después de que el set ha sido creado.
No indexados: Debido a que los sets no están ordenados, no tienen índices.

Creación de Sets:

Para crear un set, coloca los elementos entre llaves, separados por comas.

# Set con diferentes tipos de datos
    mi_set = {"manzana", 3.14, True}
    print(mi_set) # Output: {True, 3.14, 'manzana'} (el orden puede variar)

    # Set con elementos duplicados (solo se guarda uno)
    set_duplicados = {1, 5, 2, 5, 3}
    print(set_duplicados) # Output: {1, 2, 3, 5} (el orden puede variar)

    # Set vacío (¡ojo! no se crea con {}, eso crea un diccionario vacío)
    set_vacio = set()
    print(set_vacio) # Output: set()
    print(type(set_vacio)) # Output: <class 'set'>

    # También se puede crear un set a partir de una lista
    lista_para_set = ["a", "b", "c", "b", "a"]
    mi_set_desde_lista = set(lista_para_set)
    print(mi_set_desde_lista) # Output: {'a', 'b', 'c'} (el orden puede variar)

¿Por qué usar Sets?

Eliminar duplicados: Una de las principales utilidades de los sets es eliminar automáticamente los elementos duplicados de una colección.
Operaciones de conjuntos: Los sets son ideales para realizar operaciones matemáticas de conjuntos como unión, intersección, diferencia, etc.
Verificación de pertenencia eficiente: Comprobar si un elemento está presente en un set es muy rápido, especialmente para grandes colecciones.

Los sets son una estructura de datos poderosa en Python cuando necesitas trabajar con colecciones de elementos únicos sin importar el orden.

Acess Sets Item

🔑 Acceder a Elementos de un Set

Debido a que los sets son desordenados y no indexados, no puedes acceder a sus elementos utilizando un índice como lo harías con listas o tuplas.

Formas de Verificar la Existencia de un Elemento:

La forma principal de comprobar si un elemento específico está presente en un set es utilizando la palabra clave `in`.

frutas_set = {"manzana", "plátano", "cereza"}

    if "manzana" in frutas_set:
        print("La manzana está en el set.") # Output: La manzana está en el set.
    else:
        print("La manzana no está en el set.")

    if "pera" in frutas_set:
        print("La pera está en el set.")
    else:
        print("La pera no está en el set.") # Output: La pera no está en el set.

Iterar a Través de un Set:

Puedes recorrer los elementos de un set utilizando un bucle `for`.

colores_set = {"rojo", "verde", "azul"}

    for color in colores_set:
        print(color)
    # Output: (el orden puede variar)
    # azul
    # rojo
    # verde

Consideraciones al Acceder a Sets:

No intentes acceder a elementos de un set utilizando índices (por ejemplo, `frutas_set[0]`). Esto generará un error `TypeError` porque los sets no admiten la indexación.
El orden en que se imprimen o se iteran los elementos de un set no está garantizado y puede variar.

Aunque no puedes acceder directamente a un elemento por su posición, el operador `in` y los bucles `for` te permiten trabajar con los elementos de un set de manera efectiva.

Remove Set Items

🗑️ Eliminar Elementos de un Set

Python proporciona varios métodos para eliminar elementos de un set:

`remove()`: Elimina el elemento especificado. Si el elemento no existe en el set, generará un error `KeyError`.
`discard()`: Elimina el elemento especificado si está presente en el set. Si el elemento no existe, el set permanecerá sin cambios (no genera error).
`pop()`: Elimina y devuelve un elemento arbitrario del set. Dado que los sets son desordenados, no se puede predecir qué elemento se eliminará. Si el set está vacío, generará un error `KeyError`.
`clear()`: Elimina todos los elementos del set, dejándolo vacío.
`del` palabra clave: Elimina el set por completo (la variable que referencia el set).

Ejemplos de Eliminación de Elementos:

frutas_set_remove = {"manzana", "plátano", "cereza"}

    # Usando remove()
    frutas_set_remove.remove("plátano")
    print(f"Set después de remove('plátano'): {frutas_set_remove}") # Output: {'manzana', 'cereza'}

    # Intentar remover un elemento que no existe causa KeyError
    # frutas_set_remove.remove("pera") # Esto generará un error

    frutas_set_discard = {"manzana", "plátano", "cereza"}

    # Usando discard()
    frutas_set_discard.discard("plátano")
    print(f"Set después de discard('plátano'): {frutas_set_discard}") # Output: {'manzana', 'cereza'}

    # Discard de un elemento que no existe no hace nada
    frutas_set_discard.discard("pera")
    print(f"Set después de discard('pera'): {frutas_set_discard}") # Output: {'manzana', 'cereza'}

    colores_set_pop = {"rojo", "verde", "azul"}

    # Usando pop()
    elemento_eliminado = colores_set_pop.pop()
    print(f"Elemento eliminado con pop(): {elemento_eliminado}") # Output: (un elemento aleatorio)
    print(f"Set después de pop(): {colores_set_pop}") # Output: (set con un elemento menos)

    numeros_set_clear = {1, 2, 3, 4, 5}

    # Usando clear()
    numeros_set_clear.clear()
    print(f"Set después de clear(): {numeros_set_clear}") # Output: set()

    mi_set_del = {"a", "b", "c"}

    # Usando del
    del mi_set_del
    # Intentar acceder a mi_set_del aquí generará un NameError
    # print(mi_set_del)

Consideraciones al Eliminar Elementos:

Elige `remove()` si quieres asegurarte de que el elemento existe y deseas que se genere un error si no está.
Usa `discard()` si quieres eliminar un elemento sin preocuparte si existe o no.
`pop()` es útil si necesitas obtener un elemento del set y eliminarlo, pero no tienes control sobre cuál se elimina.
`clear()` vacía el set, mientras que `del` elimina la variable que referencia el set.

Estos métodos proporcionan flexibilidad para gestionar los elementos dentro de un set en Python.

Loops Sets

🔄 Bucles en Sets: Iterando a Través de los Elementos

Puedes recorrer los elementos de un set utilizando un bucle `for`. Dado que los sets son desordenados, el orden en que se acceden a los elementos durante la iteración no está garantizado.

Bucle `for` Simple:

La forma más común de iterar sobre un set es utilizando un bucle `for` que recorre cada elemento del set.

frutas_set_loop = {"manzana", "plátano", "cereza"}

    for fruta in frutas_set_loop:
        print(fruta)
    # Output: (el orden puede variar)
    # cereza
    # plátano
    # manzana

Consideraciones al Iterar sobre Sets:

Orden no garantizado: No confíes en un orden específico al iterar sobre los elementos de un set. Si el orden es importante, considera usar una lista o una tupla.
No acceso por índice directo: Dentro del bucle `for` simple, accedes directamente al valor del elemento, no a su índice. Si necesitas el índice, tendrías que convertir el set a una lista y luego iterar sobre la lista con índices.

Ejemplo (si el orden fuera necesario):

colores_set_ordenado = {"rojo", "verde", "azul"}
    colores_lista = list(colores_set_ordenado)
    colores_lista.sort() # Ordenar la lista

    for indice, color in enumerate(colores_lista):
        print(f"Índice {indice}: {color}")
    # Output:
    # Índice 0: azul
    # Índice 1: rojo
    # Índice 2: verde

El bucle `for` es la herramienta principal para procesar los elementos contenidos en un set en Python.

Join Sets

🔗 Unir Sets: Combinando Conjuntos

En Python, existen varias formas de unir dos o más sets para crear un nuevo set que contenga todos los elementos de los sets originales:

`union()`: Devuelve un nuevo set que contiene todos los elementos de los sets originales.
`update()`: Actualiza el set al que se llama insertando todos los elementos de otro set (o cualquier otro iterable).

El Método `union()`:

Este método crea y devuelve un nuevo set que contiene la unión de los dos sets (todos los elementos de ambos sets, eliminando duplicados).

set1_union = {"a", "b", "c"}
    set2_union = {1, 2, 3}

    set3_union = set1_union.union(set2_union)
    print(f"Unión de set1 y set2: {set3_union}") # Output: {'a', 'b', 'c', 1, 2, 3} (el orden puede variar)

    set4_union = {True, False}
    set5_union = set3_union.union(set4_union)
    print(f"Unión con booleanos: {set5_union}") # Output: {False, 1, 2, 3, 'a', 'b', 'c', True} (el orden puede variar)

El Método `update()`:

Este método añade todos los elementos de otro set (o cualquier iterable como listas, tuplas, etc.) al set existente. A diferencia de `union()`, `update()` modifica el set original.

set1_update = {"a", "b", "c"}
    set2_update = {1, 2, 3}

    set1_update.update(set2_update)
    print(f"set1 después de update(set2): {set1_update}") # Output: {'a', 'b', 'c', 1, 2, 3} (el orden puede variar)

    lista_update = [4, 5, 6]
    set1_update.update(lista_update)
    print(f"set1 después de update(lista): {set1_update}") # Output: {1, 2, 3, 4, 5, 6, 'a', 'b', 'c'} (el orden puede variar)

Consideraciones al Unir Sets:

Ambos métodos (`union()` y `update()`) aseguran que el set resultante contenga solo elementos únicos. Cualquier duplicado se elimina automáticamente.
`union()` crea un nuevo set, mientras que `update()` modifica el set original. Elige el método según si necesitas mantener los sets originales intactos.
`update()` puede tomar como argumento cualquier iterable, lo que lo hace más flexible en algunos casos.

Unir sets es una operación fundamental para combinar colecciones de elementos únicos en Python.

Set Methods

🛠️ Métodos de Sets en Python

Python ofrece una variedad de métodos para manipular y realizar operaciones con sets. Aquí tienes algunos de los métodos más comunes:

Métodos para Añadir Elementos:

`add(elemento)`: Añade un elemento al set. Si el elemento ya existe, el set no se modifica.
`update(iterable)`: Añade todos los elementos de un iterable (como otra lista, tupla o set) al set. Los duplicados se ignoran.

mi_set_add = {"manzana", "banana"}
    mi_set_add.add("cereza")
    print(f"Set después de add('cereza'): {mi_set_add}") # Output: {'manzana', 'banana', 'cereza'} (el orden puede variar)

    otro_set_update = {"naranja", "mango"}
    mi_set_add.update(otro_set_update)
    print(f"Set después de update({otro_set_update}): {mi_set_add}") # Output: {'manzana', 'banana', 'cereza', 'naranja', 'mango'} (el orden puede variar)

    lista_update_set = ["fresa", "uva", "fresa"]
    mi_set_add.update(lista_update_set)
    print(f"Set después de update(lista): {mi_set_add}") # Output: {'manzana', 'banana', 'cereza', 'naranja', 'mango', 'fresa', 'uva'} (el orden puede variar)

Métodos para Eliminar Elementos:

`remove(elemento)`: Elimina el elemento especificado. Genera `KeyError` si el elemento no existe.
`discard(elemento)`: Elimina el elemento especificado si está presente. No genera error si el elemento no existe.
`pop()`: Elimina y devuelve un elemento arbitrario del set. Genera `KeyError` si el set está vacío.
`clear()`: Elimina todos los elementos del set.

# (Ejemplos ya mostrados en el tema "Remove Set Items")

Métodos de Operaciones de Conjuntos:

`union(otro_set)` o `|` operador: Devuelve un nuevo set con todos los elementos de ambos sets.
`intersection(otro_set)` o `&` operador: Devuelve un nuevo set con los elementos comunes a ambos sets.
`difference(otro_set)` o `-` operador: Devuelve un nuevo set con los elementos que están en el primer set pero no en el segundo.
`symmetric_difference(otro_set)` o `^` operador: Devuelve un nuevo set con los elementos que están en uno de los sets pero no en ambos.
`isdisjoint(otro_set)`: Devuelve `True` si los dos sets no tienen elementos en común.
`issubset(otro_set)` o `<=` operador: Devuelve `True` si todos los elementos del primer set están presentes en el segundo set.
`issuperset(otro_set)` o `>=` operador: Devuelve `True` si todos los elementos del segundo set están presentes en el primer set.

set_a = {1, 2, 3, 4}
    set_b = {3, 4, 5, 6}

    print(f"Unión: {set_a.union(set_b)}") # Output: {1, 2, 3, 4, 5, 6}
    print(f"Intersección: {set_a.intersection(set_b)}") # Output: {3, 4}
    print(f"Diferencia (a - b): {set_a.difference(set_b)}") # Output: {1, 2}
    print(f"Diferencia simétrica: {set_a.symmetric_difference(set_b)}") # Output: {1, 2, 5, 6}
    print(f"¿Son disjuntos?: {set_a.isdisjoint({7, 8})}") # Output: True
    print(f"¿Es subconjunto?: {set({1, 2}).issubset(set_a)}") # Output: True
    print(f"¿Es superconjunto?: {set_a.issuperset({3, 4})}") # Output: True

Estos métodos proporcionan una funcionalidad completa para trabajar con conjuntos en Python, desde la manipulación de elementos individuales hasta la realización de operaciones complejas entre conjuntos.

Ir al indice

15- 📌 Conjuntos en Python explicados con ejemplos