Cómo verificar si una tupla contiene solo números en Python

Introducción

En este laboratorio, aprenderás cómo verificar si una tupla contiene solo números (enteros y flotantes) en Python. Comenzarás definiendo tuplas numéricas, explorando cómo crear tuplas que contengan enteros, flotantes o una mezcla de ambos. Esto implica crear un archivo numeric_tuple.py, agregar definiciones de tuplas y ejecutar el script para observar la salida.

Luego, el laboratorio te guiará en el uso de la función all() en conjunto con isinstance() para verificar que todos los elementos dentro de una tupla son realmente numéricos. Finalmente, aprenderás cómo manejar adecuadamente las tuplas vacías al realizar esta comprobación.

Definir tuplas numéricas

En este paso, aprenderás cómo definir tuplas que contengan solo datos numéricos (enteros y flotantes) en Python. Las tuplas son una estructura de datos fundamental en Python, similares a las listas, pero con una diferencia clave: son inmutables, lo que significa que sus elementos no se pueden cambiar después de su creación. Esta inmutabilidad las hace útiles para representar colecciones fijas de datos.

Comencemos creando una tupla simple que contenga enteros:

Abre tu editor de VS Code.

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

## ~/project/numeric_tuple.py
my_tuple = (1, 2, 3, 4, 5)
print(my_tuple)

Guarda el archivo.
Abre tu terminal.
Ejecuta el script utilizando el comando python:
```
python ~/project/numeric_tuple.py
```
Deberías ver la siguiente salida:
```
(1, 2, 3, 4, 5)
```

Ahora, creemos una tupla que contenga flotantes:

Modifica el archivo numeric_tuple.py para incluir valores flotantes:

## ~/project/numeric_tuple.py
my_tuple = (1.0, 2.5, 3.7, 4.2, 5.9)
print(my_tuple)

Guarda el archivo.

Vuelve a ejecutar el script:

python ~/project/numeric_tuple.py

Deberías ver la siguiente salida:

(1.0, 2.5, 3.7, 4.2, 5.9)

Las tuplas también pueden contener una mezcla de enteros y flotantes:

Modifica el archivo numeric_tuple.py para incluir tanto valores enteros como flotantes:
```
## ~/project/numeric_tuple.py
my_tuple = (1, 2.5, 3, 4.2, 5)
print(my_tuple)
```
Guarda el archivo.

Ejecuta el script:

python ~/project/numeric_tuple.py

Deberías ver la siguiente salida:

(1, 2.5, 3, 4.2, 5)

En resumen, puedes definir tuplas que contengan datos numéricos encerrando los números (enteros y flotantes) entre paréntesis () y separándolos con comas.

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 una tupla son numéricos. Esta es una técnica útil para validar datos y asegurarte de que tu código opere con los tipos de valores correctos.

Primero, entendamos qué hacen all() y isinstance():

all(iterable): Esta función devuelve True si todos los elementos del iterable (por ejemplo, una tupla) son verdaderos (o si el iterable está vacío). Devuelve False si algún elemento es falso.
isinstance(object, classinfo): Esta función devuelve True si el object es una instancia de classinfo (por ejemplo, int, float). De lo contrario, devuelve False.

Ahora, creemos un script de Python para verificar si todos los elementos de una tupla son enteros o flotantes:

Abre tu editor de VS Code.
Crea un nuevo archivo llamado check_numeric_tuple.py en el directorio ~/project.
```
## ~/project/check_numeric_tuple.py
def is_numeric_tuple(my_tuple):
    return all(isinstance(item, (int, float)) for item in my_tuple)

tuple1 = (1, 2.5, 3, 4.2, 5)
tuple2 = (1, 2, 'a', 4, 5)
tuple3 = (1.0, 2.0, 3.0)

print(f"Tuple 1 is numeric: {is_numeric_tuple(tuple1)}")
print(f"Tuple 2 is numeric: {is_numeric_tuple(tuple2)}")
print(f"Tuple 3 is numeric: {is_numeric_tuple(tuple3)}")
```
En este script:
- Definimos una función is_numeric_tuple que toma una tupla como entrada.
- Dentro de la función, usamos all() con una expresión generadora (isinstance(item, (int, float)) for item in my_tuple) para verificar si cada item de la tupla es una instancia de int o float.
- Luego probamos la función con tres tuplas diferentes.
Guarda el archivo.
Abre tu terminal.
Ejecuta el script utilizando el comando python:
```
python ~/project/check_numeric_tuple.py
```
Deberías ver la siguiente salida:
```
Tuple 1 is numeric: True
Tuple 2 is numeric: False
Tuple 3 is numeric: True
```
Esta salida muestra que tuple1 y tuple3 contienen solo valores numéricos, mientras que tuple2 contiene una cadena, por lo que no se considera una tupla numérica.

Este ejemplo demuestra cómo usar efectivamente all() y isinstance() para validar el contenido de una tupla y asegurarse de que todos los elementos cumplan con un tipo de dato específico.

Manejar tuplas vacías

En este paso, aprenderás cómo manejar tuplas vacías cuando se verifiquen valores numéricos. Una tupla vacía es una tupla sin elementos, representada como (). Es importante considerar las tuplas vacías en tu código para evitar posibles errores y asegurarte de que tu programa se comporte como se espera.

Modifiquemos el script del paso anterior para manejar tuplas vacías:

Abre tu editor de VS Code.

Abre el archivo check_numeric_tuple.py en el directorio ~/project.

## ~/project/check_numeric_tuple.py
def is_numeric_tuple(my_tuple):
    if not my_tuple:
        return True  ## An empty tuple is considered numeric
    return all(isinstance(item, (int, float)) for item in my_tuple)

tuple1 = (1, 2.5, 3, 4.2, 5)
tuple2 = (1, 2, 'a', 4, 5)
tuple3 = (1.0, 2.0, 3.0)
tuple4 = () ## Empty tuple

print(f"Tuple 1 is numeric: {is_numeric_tuple(tuple1)}")
print(f"Tuple 2 is numeric: {is_numeric_tuple(tuple2)}")
print(f"Tuple 3 is numeric: {is_numeric_tuple(tuple3)}")
print(f"Tuple 4 is numeric: {is_numeric_tuple(tuple4)}")

En este script modificado:

Agregamos una comprobación al principio de la función is_numeric_tuple: if not my_tuple: return True. Esto verifica si la tupla está vacía. Si lo está, la función devuelve True, considerando una tupla vacía como numérica.
Agregamos una tupla vacía tuple4 = () para probar la función.

Guarda el archivo.
Abre tu terminal.
Ejecuta el script utilizando el comando python:
```
python ~/project/check_numeric_tuple.py
```
Deberías ver la siguiente salida:
```
Tuple 1 is numeric: True
Tuple 2 is numeric: False
Tuple 3 is numeric: True
Tuple 4 is numeric: True
```
Esta salida muestra que la tupla vacía tuple4 ahora se maneja correctamente y se considera una tupla numérica.

Manejar las tuplas vacías es una buena práctica para hacer que tu código sea más robusto y prevenir comportamientos inesperados. En este caso, decidimos considerar una tupla vacía como numérica, pero puedes ajustar la lógica según tus requisitos específicos.

Resumen

En este laboratorio, el primer paso se centra en definir tuplas numéricas en Python. Aprendiste que las tuplas son estructuras de datos inmutables, similares a las listas, y se definen utilizando paréntesis (). Puedes crear tuplas que contengan enteros, números de punto flotante o una mezcla de ambos, separando los elementos con comas.

Luego, el laboratorio demuestra cómo verificar si una tupla contiene solo números utilizando la función all() en conjunto con isinstance(). (El contenido se trunca en la descripción original del laboratorio.)