Cómo comprobar si un número es un entero (no un número de punto flotante) en Python

Introducción

En este laboratorio, aprenderás cómo determinar si un número en Python es un entero (integer) o un número de punto flotante (float). El laboratorio comienza diferenciando entre enteros y números de punto flotante, destacando sus características clave y proporcionando ejemplos.

Luego, explorarás dos métodos para verificar el tipo de datos de un número: utilizando la función isinstance() con int y utilizando la función type() para mayor precisión. A través de ejercicios prácticos, crearás un script de Python para identificar y distinguir entre los tipos de datos entero y de punto flotante, consolidando tu comprensión de la verificación de tipos de datos en Python.

Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL python(("Python")) -.-> python/BasicConceptsGroup(["Basic Concepts"]) python(("Python")) -.-> python/FunctionsGroup(["Functions"]) python/BasicConceptsGroup -.-> python/variables_data_types("Variables and Data Types") python/BasicConceptsGroup -.-> python/numeric_types("Numeric Types") python/BasicConceptsGroup -.-> python/type_conversion("Type Conversion") python/FunctionsGroup -.-> python/build_in_functions("Build-in Functions") subgraph Lab Skills python/variables_data_types -.-> lab-559545{{"Cómo comprobar si un número es un entero (no un número de punto flotante) en Python"}} python/numeric_types -.-> lab-559545{{"Cómo comprobar si un número es un entero (no un número de punto flotante) en Python"}} python/type_conversion -.-> lab-559545{{"Cómo comprobar si un número es un entero (no un número de punto flotante) en Python"}} python/build_in_functions -.-> lab-559545{{"Cómo comprobar si un número es un entero (no un número de punto flotante) en Python"}} end

Diferenciar entre Enteros y Números de Punto Flotante

En este paso, aprenderás a diferenciar entre dos tipos de datos fundamentales en Python: enteros (integers) y números de punto flotante (floats). Comprender la diferencia es crucial para realizar cálculos precisos y manipular datos adecuadamente.

Enteros (int)

Los enteros son números enteros, positivos o negativos, sin ningún punto decimal. Ejemplos incluyen -3, 0, 5, 100.

Números de Punto Flotante (float)

Los números de punto flotante, o simplemente floats, son números que contienen un punto decimal. También pueden representar números en notación científica. Ejemplos incluyen -2.5, 0.0, 3.14, 1.0e5 (que es 100000.0).

Comencemos creando un script de Python para explorar estos tipos de datos.

Abre el editor de VS Code en el entorno de LabEx.
Crea un nuevo archivo llamado datatypes.py en el directorio ~/project.
```
touch ~/project/datatypes.py
```

Abre el archivo datatypes.py en el editor y agrega el siguiente código de Python:

## Assign an integer to the variable 'integer_number'
integer_number = 10

## Assign a float to the variable 'float_number'
float_number = 10.0

## Print the values and their types
print("Integer:", integer_number, "Type:", type(integer_number))
print("Float:", float_number, "Type:", type(float_number))

Guarda el archivo datatypes.py.
Ejecuta el script utilizando el comando python en la terminal:
```
python ~/project/datatypes.py
```
Deberías ver la siguiente salida:
```
Integer: 10 Type: <class 'int'>
Float: 10.0 Type: <class 'float'>
```
Esta salida muestra claramente que integer_number es de tipo int y float_number es de tipo float.

Ahora, realicemos una operación aritmética simple para ver cómo Python maneja estos tipos:

Modifica el archivo datatypes.py para incluir lo siguiente:

## Assign an integer to the variable 'integer_number'
integer_number = 10

## Assign a float to the variable 'float_number'
float_number = 10.0

## Print the values and their types
print("Integer:", integer_number, "Type:", type(integer_number))
print("Float:", float_number, "Type:", type(float_number))

## Add an integer and a float
sum_result = integer_number + float_number

## Print the result and its type
print("Sum:", sum_result, "Type:", type(sum_result))

Guarda el archivo datatypes.py.
Ejecuta el script nuevamente:
```
python ~/project/datatypes.py
```
Deberías ver la siguiente salida:
```
Integer: 10 Type: <class 'int'>
Float: 10.0 Type: <class 'float'>
Sum: 20.0 Type: <class 'float'>
```
Observa que cuando sumas un entero y un número de punto flotante, el resultado es un número de punto flotante. Esto se debe a que Python convierte automáticamente el entero en un número de punto flotante para mantener la precisión.

Usar `isinstance()` con `int`

En este paso, aprenderás cómo usar la función isinstance() para verificar si una variable es un entero (integer). Esta función es una herramienta poderosa para verificar tipos de datos en Python.

La función isinstance() toma dos argumentos:

La variable que deseas verificar.
El tipo de datos contra el que deseas verificar (por ejemplo, int, float, str).

Devuelve True si la variable es del tipo especificado y False en caso contrario.

Modifiquemos el archivo datatypes.py del paso anterior para incluir la función isinstance().

Abre el archivo datatypes.py en el editor de VS Code.

Agrega el siguiente código al archivo:

## Assign an integer to the variable 'integer_number'
integer_number = 10

## Assign a float to the variable 'float_number'
float_number = 10.0

## Print the values and their types
print("Integer:", integer_number, "Type:", type(integer_number))
print("Float:", float_number, "Type:", type(float_number))

## Add an integer and a float
sum_result = integer_number + float_number

## Print the result and its type
print("Sum:", sum_result, "Type:", type(sum_result))

## Check if integer_number is an integer
is_integer = isinstance(integer_number, int)
print("Is integer_number an integer?", is_integer)

## Check if float_number is an integer
is_integer = isinstance(float_number, int)
print("Is float_number an integer?", is_integer)

Guarda el archivo datatypes.py.
Ejecuta el script utilizando el comando python en la terminal:
```
python ~/project/datatypes.py
```
Deberías ver la siguiente salida:
```
Integer: 10 Type: <class 'int'>
Float: 10.0 Type: <class 'float'>
Sum: 20.0 Type: <class 'float'>
Is integer_number an integer? True
Is float_number an integer? False
```
Como puedes ver, isinstance(integer_number, int) devuelve True porque integer_number es en realidad un entero. isinstance(float_number, int) devuelve False porque float_number es un número de punto flotante (float), no un entero.

Esta función es especialmente útil cuando necesitas realizar diferentes acciones según el tipo de datos de una variable. Por ejemplo, podrías querer realizar una división entera si una variable es un entero y una división de punto flotante si es un número de punto flotante.

Verificar con `type()` para Precisión

En este paso, explorarás cómo se puede utilizar la función type() para comprender la precisión de los números en Python. Mientras que isinstance() verifica si una variable pertenece a un tipo específico, type() devuelve el tipo real de la variable. Esto es útil para entender cómo Python maneja diferentes operaciones numéricas y su precisión resultante.

Continuemos modificando el archivo datatypes.py para demostrar esto.

Abre el archivo datatypes.py en el editor de VS Code.

Agrega el siguiente código al archivo:

## Assign an integer to the variable 'integer_number'
integer_number = 10

## Assign a float to the variable 'float_number'
float_number = 10.0

## Print the values and their types
print("Integer:", integer_number, "Type:", type(integer_number))
print("Float:", float_number, "Type:", type(float_number))

## Add an integer and a float
sum_result = integer_number + float_number

## Print the result and its type
print("Sum:", sum_result, "Type:", type(sum_result))

## Check if integer_number is an integer
is_integer = isinstance(integer_number, int)
print("Is integer_number an integer?", is_integer)

## Check if float_number is an integer
is_integer = isinstance(float_number, int)
print("Is float_number an integer?", is_integer)

## Perform division with integers
division_result = integer_number / 3
print("Division result:", division_result, "Type:", type(division_result))

## Perform integer division with integers
integer_division_result = integer_number // 3
print("Integer division result:", integer_division_result, "Type:", type(integer_division_result))

Guarda el archivo datatypes.py.
Ejecuta el script utilizando el comando python en la terminal:
```
python ~/project/datatypes.py
```
Deberías ver la siguiente salida:
```
Integer: 10 Type: <class 'int'>
Float: 10.0 Type: <class 'float'>
Sum: 20.0 Type: <class 'float'>
Is integer_number an integer? True
Is float_number an integer? False
Division result: 3.3333333333333335 Type: <class 'float'>
Integer division result: 3 Type: <class 'int'>
```
Observa lo siguiente:
- Cuando divides dos enteros utilizando el operador /, el resultado es un número de punto flotante (float), incluso si el resultado es un número entero. Esto se debe a que Python busca proporcionar el resultado más preciso posible.
- Cuando utilizas el operador // (división entera o piso), el resultado es un entero (int), descartando cualquier parte fraccionaria.

Comprender estas sutilezas es crucial para escribir código Python preciso y eficiente, especialmente cuando se trata de cálculos numéricos.

Resumen

En este laboratorio (lab), aprendiste a diferenciar entre enteros (integers) y números de punto flotante (floats) en Python. Los enteros son números enteros sin puntos decimales, mientras que los números de punto flotante son números que contienen un punto decimal. Creaste un script de Python para asignar valores enteros y de punto flotante a variables y luego imprimiste sus valores junto con sus respectivos tipos utilizando la función type(). La salida demostró que las variables a las que se les asignan números enteros son de tipo int, y aquellas con puntos decimales son de tipo float.