Cómo comprobar si un conjunto (set) contiene elementos únicos en Python

Introducción

En este laboratorio, aprenderás cómo comprobar si un conjunto (set) contiene elementos únicos en Python. Los conjuntos son un tipo de dato incorporado que almacena colecciones desordenadas de elementos únicos, eliminando automáticamente los duplicados. Comenzarás creando e imprimiendo conjuntos, observando cómo se manejan los valores duplicados.

A continuación, el laboratorio profundizará en las propiedades de los conjuntos, explorando cómo aprovechar sus características únicas para tareas como eliminar entradas duplicadas o comprobar la presencia de elementos. Aprenderás a verificar la unicidad utilizando los métodos len() y el recuento de elementos.

Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL python(("Python")) -.-> python/DataStructuresGroup(["Data Structures"]) python(("Python")) -.-> python/FunctionsGroup(["Functions"]) python(("Python")) -.-> python/PythonStandardLibraryGroup(["Python Standard Library"]) python/DataStructuresGroup -.-> python/sets("Sets") python/FunctionsGroup -.-> python/build_in_functions("Build-in Functions") python/PythonStandardLibraryGroup -.-> python/data_collections("Data Collections") subgraph Lab Skills python/sets -.-> lab-559561{{"Cómo comprobar si un conjunto (set) contiene elementos únicos en Python"}} python/build_in_functions -.-> lab-559561{{"Cómo comprobar si un conjunto (set) contiene elementos únicos en Python"}} python/data_collections -.-> lab-559561{{"Cómo comprobar si un conjunto (set) contiene elementos únicos en Python"}} end

Aprende sobre la unicidad de los conjuntos (sets)

En este paso, aprenderás sobre el concepto fundamental de la unicidad de los conjuntos (sets) en Python. Los conjuntos son un tipo de dato incorporado en Python que almacena una colección desordenada de elementos únicos. Esto significa que un conjunto no puede contener valores duplicados. Comprender esta propiedad es crucial para gestionar y manipular datos de manera eficiente cuando la unicidad es importante.

Comencemos creando un conjunto simple:

Abre el editor de VS Code en el entorno de LabEx.

Crea un nuevo archivo llamado set_example.py en el directorio ~/project.

## Create a set of numbers
my_set = {1, 2, 3, 4, 5}

## Print the set
print(my_set)

Guarda el archivo.
Ejecuta el script utilizando el comando python en la terminal:
```
python set_example.py
```
Deberías ver la siguiente salida:
```
{1, 2, 3, 4, 5}
```

Ahora, veamos qué sucede cuando intentamos agregar elementos duplicados a un conjunto:

Modifica el archivo set_example.py para incluir valores duplicados:

## Create a set with duplicate numbers
my_set = {1, 2, 2, 3, 4, 4, 5}

## Print the set
print(my_set)

Guarda el archivo.
Vuelve a ejecutar el script:
```
python set_example.py
```
Deberías ver la siguiente salida:
```
{1, 2, 3, 4, 5}
```

Observa que, aunque intentamos agregar valores duplicados (2 y 4), el conjunto solo contiene elementos únicos. Esto demuestra la propiedad central de los conjuntos: eliminan automáticamente los duplicados.

Esta propiedad de unicidad hace que los conjuntos sean muy útiles para tareas como eliminar entradas duplicadas de una lista o comprobar si un elemento ya está presente en una colección. En los siguientes pasos, exploraremos más aplicaciones de los conjuntos y cómo aprovechar sus características únicas.

Entender las propiedades de los conjuntos (sets)

En este paso, profundizaremos en las propiedades de los conjuntos (sets) en Python. Los conjuntos no son solo colecciones de elementos únicos; también admiten diversas operaciones que los convierten en una herramienta poderosa para la manipulación de datos. Exploraremos cómo agregar elementos, eliminar elementos y realizar operaciones comunes de conjuntos como unión, intersección y diferencia.

Comencemos agregando elementos a un conjunto:

Abre el archivo set_example.py en el directorio ~/project utilizando el editor de VS Code.

Modifica el archivo para agregar elementos al conjunto utilizando el método add():

## Create a set
my_set = {1, 2, 3}

## Add elements to the set
my_set.add(4)
my_set.add(5)

## Print the set
print(my_set)

Guarda el archivo.
Ejecuta el script utilizando el comando python en la terminal:
```
python set_example.py
```
Deberías ver la siguiente salida:
```
{1, 2, 3, 4, 5}
```

Ahora, veamos cómo eliminar elementos de un conjunto:

Modifica el archivo set_example.py para eliminar un elemento utilizando el método remove():

## Create a set
my_set = {1, 2, 3, 4, 5}

## Remove an element from the set
my_set.remove(3)

## Print the set
print(my_set)

Guarda el archivo.
Vuelve a ejecutar el script:
```
python set_example.py
```
Deberías ver la siguiente salida:
```
{1, 2, 4, 5}
```

Ten en cuenta que si intentas eliminar un elemento que no está en el conjunto, se generará un error KeyError. Para evitar esto, puedes utilizar el método discard(), que no genera un error si el elemento no está presente.

```python
## Create a set
my_set = {1, 2, 3, 4, 5}

## Discard an element from the set
my_set.discard(6) ## No error raised

## Print the set
print(my_set)
```

Finalmente, exploremos algunas operaciones comunes de conjuntos:

Modifica el archivo set_example.py para realizar operaciones de unión, intersección y diferencia:

## Create two sets
set1 = {1, 2, 3, 4, 5}
set2 = {3, 4, 5, 6, 7}

## Union of the sets
union_set = set1.union(set2)
print("Union:", union_set)

## Intersection of the sets
intersection_set = set1.intersection(set2)
print("Intersection:", intersection_set)

## Difference of the sets (elements in set1 but not in set2)
difference_set = set1.difference(set2)
print("Difference:", difference_set)

Guarda el archivo.

Vuelve a ejecutar el script:

python set_example.py

Deberías ver la siguiente salida:

Union: {1, 2, 3, 4, 5, 6, 7}
Intersection: {3, 4, 5}
Difference: {1, 2}

Comprender estas propiedades y operaciones de conjuntos te permitirá utilizar eficazmente los conjuntos para diversas tareas de manipulación de datos en Python.

Verificar con len() y el recuento de elementos

En este paso, aprenderemos cómo verificar las propiedades de un conjunto (set) utilizando la función len() y comprobando la presencia de elementos específicos. La función len() devuelve el número de elementos en un conjunto, y podemos utilizar el operador in para comprobar si un elemento está presente en un conjunto. Estas técnicas son útiles para validar el estado de un conjunto después de realizar operaciones.

Comencemos utilizando la función len() para determinar el tamaño de un conjunto:

Abre el archivo set_example.py en el directorio ~/project utilizando el editor de VS Code.

Modifica el archivo para utilizar la función len() y mostrar el número de elementos en el conjunto:

## Create a set
my_set = {1, 2, 3, 4, 5}

## Get the number of elements in the set
set_length = len(my_set)

## Print the length of the set
print("Length of the set:", set_length)

Guarda el archivo.
Ejecuta el script utilizando el comando python en la terminal:
```
python set_example.py
```
Deberías ver la siguiente salida:
```
Length of the set: 5
```

Ahora, veamos cómo comprobar si un elemento está presente en un conjunto utilizando el operador in:

Modifica el archivo set_example.py para comprobar la presencia de elementos específicos:

## Create a set
my_set = {1, 2, 3, 4, 5}

## Check if an element is in the set
if 3 in my_set:
    print("3 is in the set")
else:
    print("3 is not in the set")

## Check if an element is not in the set
if 6 in my_set:
    print("6 is in the set")
else:
    print("6 is not in the set")

Guarda el archivo.
Vuelve a ejecutar el script:
```
python set_example.py
```
Deberías ver la siguiente salida:
```
3 is in the set
6 is not in the set
```

Al combinar la función len() y el operador in, puedes verificar eficazmente las propiedades de un conjunto y asegurarte de que contiene los elementos esperados. Esto es especialmente útil cuando trabajas con conjuntos en programas más complejos donde necesitas validar el estado de tus datos.

Resumen

En este laboratorio (lab), comienzas aprendiendo sobre el concepto fundamental de la unicidad de los conjuntos (sets) en Python. Los conjuntos se presentan como un tipo de dato incorporado que almacena colecciones desordenadas de elementos únicos, eliminando automáticamente los duplicados. Creas un script de Python para demostrar esta propiedad y observas que agregar valores duplicados a un conjunto no hace que esos duplicados se almacenen.

Luego, el laboratorio profundiza en las propiedades de los conjuntos, destacando que son más que simplemente colecciones de elementos únicos. (El contenido proporcionado está truncado, por lo que esto se basa en la suposición de que el siguiente paso se basa en la comprensión inicial de la unicidad de los conjuntos.)