Cómo comprobar si un conjunto contiene solo números en Python

Introducción

En este laboratorio, aprenderás cómo verificar si un conjunto contiene solo números en Python. El laboratorio se centra en definir conjuntos numéricos, incluyendo conjuntos vacíos, conjuntos de enteros, conjuntos de números de punto flotante y conjuntos mixtos que contienen tanto enteros como números de punto flotante. También explorarás cómo los conjuntos manejan los valores duplicados, garantizando la unicidad.

El laboratorio te guía a través de la creación de un archivo de Python llamado numeric_sets.py, agregando código para definir e imprimir varios conjuntos y ejecutando el script para observar la salida. Aprenderás cómo usar el constructor set() y cómo los conjuntos eliminan automáticamente los valores duplicados, demostrando las propiedades fundamentales de los conjuntos en Python.

Skills Graph

Definir conjuntos numéricos

En este paso, aprenderás cómo definir conjuntos que contengan números en Python. Los conjuntos son colecciones desordenadas de elementos únicos. Esto significa que un conjunto no puede contener valores duplicados. Nos centraremos en crear conjuntos de enteros y números de punto flotante.

Primero, creemos un archivo de Python llamado numeric_sets.py en tu directorio ~/project utilizando el editor VS Code.

## Create an empty set
empty_set = set()
print("Empty Set:", empty_set)

## Create a set of integers
integer_set = {1, 2, 3, 4, 5}
print("Integer Set:", integer_set)

## Create a set of floats
float_set = {1.0, 2.5, 3.7, 4.2, 5.9}
print("Float Set:", float_set)

## Create a mixed set (integers and floats)
mixed_set = {1, 2.0, 3, 4.5, 5}
print("Mixed Set:", mixed_set)

Guarda el archivo como numeric_sets.py en tu directorio ~/project. Ahora, ejecuta el script utilizando el siguiente comando en la terminal:

python numeric_sets.py

Deberías ver la siguiente salida:

Empty Set: set()
Integer Set: {1, 2, 3, 4, 5}
Float Set: {1.0, 2.5, 3.7, 4.2, 5.9}
Mixed Set: {1, 2.0, 3, 4.5, 5}

Observa que el orden de los elementos en el conjunto puede no ser el mismo que el orden en el que se definieron. Esto se debe a que los conjuntos son colecciones desordenadas. Además, los conjuntos eliminan automáticamente los valores duplicados.

Ahora, agreguemos algunos ejemplos más a tu archivo numeric_sets.py para demostrar la unicidad de los conjuntos:

## Create a set with duplicate values
duplicate_set = {1, 2, 2, 3, 4, 4, 5}
print("Duplicate Set:", duplicate_set)

## Create a set from a list with duplicate values
duplicate_list = [1, 2, 2, 3, 4, 4, 5]
unique_set = set(duplicate_list)
print("Unique Set from List:", unique_set)

Guarda los cambios y ejecuta el script nuevamente:

python numeric_sets.py

Deberías ver la siguiente salida:

Empty Set: set()
Integer Set: {1, 2, 3, 4, 5}
Float Set: {1.0, 2.5, 3.7, 4.2, 5.9}
Mixed Set: {1, 2.0, 3, 4.5, 5}
Duplicate Set: {1, 2, 3, 4, 5}
Unique Set from List: {1, 2, 3, 4, 5}

Como puedes ver, tanto duplicate_set como unique_set contienen solo valores únicos, incluso aunque intentamos crearlos con valores duplicados.

Usar all() con isinstance()

En este paso, aprenderás cómo usar la función all() en combinación con la función isinstance() para verificar si todos los elementos de un conjunto son de un tipo numérico específico. Esto es útil para validar el contenido de un conjunto antes de realizar operaciones en él.

La función all() devuelve True si todos los elementos de un iterable (como un conjunto) son verdaderos. La función isinstance() comprueba si un objeto es una instancia de una clase o tipo especificado.

Modifiquemos el archivo numeric_sets.py que creaste en el paso anterior para incluir estas comprobaciones. Abre numeric_sets.py en el editor VS Code y agrega el siguiente código:

def check_if_all_are_integers(input_set):
  """Checks if all elements in the set are integers."""
  return all(isinstance(x, int) for x in input_set)

def check_if_all_are_floats(input_set):
  """Checks if all elements in the set are floats."""
  return all(isinstance(x, float) for x in input_set)

## Example usage:
integer_set = {1, 2, 3, 4, 5}
float_set = {1.0, 2.5, 3.7, 4.2, 5.9}
mixed_set = {1, 2.0, 3, 4.5, 5}

print("Are all elements in integer_set integers?", check_if_all_are_integers(integer_set))
print("Are all elements in float_set floats?", check_if_all_are_floats(float_set))
print("Are all elements in mixed_set integers?", check_if_all_are_integers(mixed_set))
print("Are all elements in mixed_set floats?", check_if_all_are_floats(mixed_set))

Guarda el archivo y ejecútalo utilizando el siguiente comando:

python numeric_sets.py

Deberías ver la siguiente salida:

Are all elements in integer_set integers? True
Are all elements in float_set floats? True
Are all elements in mixed_set integers? False
Are all elements in mixed_set floats? False

La salida muestra que integer_set contiene solo enteros, float_set contiene solo números de punto flotante y mixed_set contiene una mezcla de enteros y números de punto flotante, por lo que las comprobaciones devuelven False tanto para la comprobación de enteros como para la de números de punto flotante.

Ahora, agreguemos una función para verificar si todos los elementos son enteros o números de punto flotante (es decir, numéricos):

def check_if_all_are_numeric(input_set):
  """Checks if all elements in the set are either integers or floats."""
  return all(isinstance(x, (int, float)) for x in input_set)

print("Are all elements in mixed_set numeric?", check_if_all_are_numeric(mixed_set))

string_set = {"a", "b", "c"}
print("Are all elements in string_set numeric?", check_if_all_are_numeric(string_set))

Guarda el archivo y ejecútalo nuevamente:

python numeric_sets.py

Deberías ver la siguiente salida:

Are all elements in integer_set integers? True
Are all elements in float_set floats? True
Are all elements in mixed_set integers? False
Are all elements in mixed_set floats? False
Are all elements in mixed_set numeric? True
Are all elements in string_set numeric? False

Esto demuestra cómo usar all() y isinstance() para validar los tipos de elementos dentro de un conjunto.

Manejar conjuntos vacíos

En este paso, aprenderás cómo manejar conjuntos vacíos cuando uses las funciones all() y isinstance(). Los conjuntos vacíos son un caso especial porque no contienen elementos. Comprender cómo se comportan estas funciones con conjuntos vacíos es crucial para escribir código robusto.

Consideremos qué sucede cuando se usa all() con un conjunto vacío. La función all() devuelve True si todos los elementos del iterable son verdaderos. Dado que un conjunto vacío no tiene elementos, se puede argumentar que "todos" sus elementos son verdaderos, simplemente porque no hay elementos que sean falsos.

Modifiquemos el archivo numeric_sets.py para demostrar esto. Abre numeric_sets.py en el editor VS Code y agrega el siguiente código:

def check_if_all_are_integers(input_set):
  """Checks if all elements in the set are integers."""
  return all(isinstance(x, int) for x in input_set)

## Example with an empty set:
empty_set = set()
print("Is empty_set all integers?", check_if_all_are_integers(empty_set))

Guarda el archivo y ejecútalo utilizando el siguiente comando:

python numeric_sets.py

Deberías ver la siguiente salida:

Is empty_set all integers? True

Este resultado puede parecer contraintuitivo al principio. Sin embargo, es consistente con la definición de all().

Ahora, consideremos un escenario en el que quieres manejar explícitamente los conjuntos vacíos de manera diferente. Puedes agregar una comprobación para un conjunto vacío antes de usar all():

def check_if_all_are_integers_safe(input_set):
  """Checks if all elements in the set are integers, handling empty sets explicitly."""
  if not input_set:
    return False  ## Or True, depending on your desired behavior for empty sets
  return all(isinstance(x, int) for x in input_set)

empty_set = set()
print("Is empty_set all integers (safe)?", check_if_all_are_integers_safe(empty_set))

integer_set = {1, 2, 3}
print("Is integer_set all integers (safe)?", check_if_all_are_integers_safe(integer_set))

Guarda el archivo y ejecútalo nuevamente:

python numeric_sets.py

Deberías ver la siguiente salida:

Is empty_set all integers (safe)? False
Is integer_set all integers (safe)? True

En este ejemplo, la función check_if_all_are_integers_safe devuelve False para un conjunto vacío. Puedes modificar el valor de retorno en el bloque if not input_set: para adaptarlo a tus necesidades específicas. Manejar explícitamente los conjuntos vacíos puede prevenir comportamientos inesperados en tu código.

Resumen

En este laboratorio (lab), aprendiste cómo definir conjuntos que contienen números en Python, incluyendo conjuntos vacíos, conjuntos de enteros, conjuntos de números de punto flotante y conjuntos mixtos que contienen tanto enteros como números de punto flotante. También observaste que los conjuntos son colecciones desordenadas y eliminan automáticamente los valores duplicados.

El laboratorio demostró cómo crear conjuntos directamente y a partir de listas con valores duplicados, destacando la propiedad de los conjuntos de mantener solo elementos únicos. Los ejemplos proporcionaron una comprensión práctica de cómo los conjuntos manejan diferentes tipos numéricos y eliminan la redundancia.