Tipos de Números y Operaciones en Python

Introducción

En este laboratorio, obtendrá una comprensión fundamental de los tipos de números y las operaciones en Python. Exploraremos las características de los tipos de números enteros (integer), booleanos (boolean), de punto flotante (floating-point) y complejos (complex), incluida su inmutabilidad y cómo verificar sus tipos y direcciones de memoria. A través de ejercicios prácticos, aprenderá a convertir entre diferentes tipos de números y a realizar operaciones aritméticas básicas, solidificando su conocimiento de las capacidades numéricas de Python.

Explorar Tipos Enteros y Booleanos

En este paso, exploraremos los tipos de datos enteros (int) y booleanos (bool) en Python. Los enteros son números enteros, como 10, -5 o 0. Los booleanos representan uno de dos valores: True o False, y son un subtipo de los enteros.

Un concepto importante en Python es la inmutabilidad (immutability). Los tipos numéricos son inmutables, lo que significa que una vez que se crea un objeto numérico, su valor no puede cambiarse. Si reasigna una variable a un nuevo número, esta apuntará a un nuevo objeto en la memoria. Podemos verificar esto usando la función incorporada id(), que devuelve la dirección de memoria única de un objeto, y la función type(), que muestra su tipo de dato.

El entorno de laboratorio ya ha creado un archivo para usted. En el explorador de archivos del WebIDE a la izquierda, abra el archivo ~/project/number_types.py. Agregue el siguiente código:

## Demonstrate immutability of integers
a = 5
print(f"Initial value of a: {a}")
print(f"Type of a: {type(a)}")
print(f"ID of a: {id(a)}")

## Reassign 'a' to a new value
a = 6
print(f"\nNew value of a: {a}")
print(f"New ID of a: {id(a)}")

## Demonstrate boolean type
print("\n--- Boolean Types ---")
is_true = True
is_false = False
print(f"Value of is_true: {is_true}, Type: {type(is_true)}")
print(f"Value of is_false: {is_false}, Type: {type(is_false)}")

## Booleans behave like integers (1 and 0) in arithmetic
print(f"\nTrue + 5: {True + 5}")
print(f"False * 3: {False * 3}")

Después de agregar el código, guarde el archivo. Para ejecutar el script, abra la terminal integrada en el WebIDE y ejecute el siguiente comando:

python ~/project/number_types.py

Debería ver una salida similar a la siguiente. Tenga en cuenta que las direcciones de memoria (ID) serán diferentes en su sistema.

Initial value of a: 5
Type of a: <class 'int'>
ID of a: <memory_address_1>

New value of a: 6
New ID of a: <memory_address_2>

--- Boolean Types ---
Value of is_true: True, Type: <class 'bool'>
Value of is_false: False, Type: <class 'bool'>

True + 5: 6
False * 3: 0

La salida muestra que cuando a fue reasignado de 5 a 6, su ID cambió, lo que confirma que se creó un nuevo objeto entero. También demuestra que True se trata como 1 y False como 0 en los cálculos.

Trabajar con Números de Punto Flotante

En este paso, trabajaremos con números de punto flotante (float), que representan números reales con un punto decimal. Un problema común con los flotantes es su precisión limitada, ya que se almacenan en formato binario. Esto a veces puede provocar pequeñas imprecisiones en los cálculos.

Exploremos este comportamiento. Abra ~/project/number_types.py nuevamente y agregue el siguiente código al final del archivo. Este código demostrará el problema de precisión e introducirá dos formas de manejarlo: la función round() para el redondeo simple y el módulo decimal para la aritmética de alta precisión.

## Demonstrate floating-point numbers and precision
print("\n--- Floating-Point Numbers ---")
result = 1.1 + 2.2
print(f"1.1 + 2.2 = {result}")

## Using round() for approximation
print(f"round(result, 1) = {round(result, 1)}")

## Using the decimal module for accurate calculations
from decimal import Decimal

## Pass numbers as strings to Decimal to avoid initial float inaccuracy
d1 = Decimal('1.1')
d2 = Decimal('2.2')
decimal_result = d1 + d2
print(f"Decimal('1.1') + Decimal('2.2') = {decimal_result}")

Guarde el archivo y ejecute el script nuevamente desde la terminal:

python ~/project/number_types.py

Su salida ahora incluirá la siguiente sección:

--- Floating-Point Numbers ---
1.1 + 2.2 = 3.3000000000000003
round(result, 1) = 3.3
Decimal('1.1') + Decimal('2.2') = 3.3

Como puede ver, la suma estándar de flotantes 1.1 + 2.2 no da exactamente 3.3. Si bien round() puede ayudar a formatear la salida, el módulo decimal proporciona una forma de realizar cálculos con la representación decimal exacta, dando la respuesta precisa.

Introducir Números Complejos

Python tiene soporte incorporado para los números complejos, que son esenciales en muchos campos científicos y de ingeniería. Un número complejo tiene una parte real y una parte imaginaria, escrito en la forma a + bj, donde j representa la unidad imaginaria.

Puede crear números complejos usando esta notación o con el constructor complex(real, imag). Se puede acceder a las partes real e imaginaria utilizando los atributos .real y .imag.

Continúe editando el archivo ~/project/number_types.py. Agregue el siguiente código al final para explorar los números complejos:

## Demonstrate complex numbers
print("\n--- Complex Numbers ---")
c1 = 3 + 4j
print(f"Complex number c1: {c1}")
print(f"Type of c1: {type(c1)}")
print(f"Real part of c1: {c1.real}")
print(f"Imaginary part of c1: {c1.imag}")

## Creating a complex number with the constructor
c2 = complex(5, -2)
print(f"\nComplex number c2: {c2}")
print(f"Real part of c2: {c2.real}")
print(f"Imaginary part of c2: {c2.imag}")

Guarde el archivo y ejecute el script desde la terminal:

python ~/project/number_types.py

La nueva salida será:

--- Complex Numbers ---
Complex number c1: (3+4j)
Type of c1: <class 'complex'>
Real part of c1: 3.0
Imaginary part of c1: 4.0

Complex number c2: (5-2j)
Real part of c2: 5.0
Imaginary part of c2: -2.0

Observe que tanto la parte real como la imaginaria se almacenan como números de punto flotante, incluso si las define con enteros.

Convertir Entre Tipos de Números

Python proporciona funciones integradas para convertir entre diferentes tipos de números, como int(), float() y complex(). Esto se conoce como conversión de tipos (type casting).

• int(x): Convierte x a un entero. Al convertir un flotante, trunca (corta) la parte decimal, no redondea.
• float(x): Convierte x a un número de punto flotante.
• complex(real, imag): Crea un número complejo.

Practiquemos la conversión de tipos. Agregue el siguiente código al final de su script ~/project/number_types.py:

## Demonstrate type conversion
print("\n--- Type Conversion ---")

## Convert float to int (truncation)
float_num = 9.9
int_num = int(float_num)
print(f"float_num = {float_num}")
print(f"int(float_num) = {int_num}")

## Convert int to float
int_val = 10
float_val = float(int_val)
print(f"\nint_val = {int_val}")
print(f"float(int_val) = {float_val}")

## Convert string to number
str_num = "123.45"
converted_float = float(str_num)
converted_int = int(float(str_num)) ## Must convert to float first
print(f"\nstr_num = '{str_num}'")
print(f"float(str_num) = {converted_float}")
print(f"int(float(str_num)) = {converted_int}")

Guarde el archivo y ejecute el script una vez más:

python ~/project/number_types.py

La salida ahora incluirá esta sección:

--- Type Conversion ---
float_num = 9.9
int(float_num) = 9

int_val = 10
float(int_val) = 10.0

str_num = '123.45'
float(str_num) = 123.45
int(float(str_num)) = 123

Esta salida muestra claramente cómo int() trunca la parte decimal de 9.9 a 9. También ilustra el proceso de dos pasos requerido para convertir una cadena que contiene un decimal a un entero.

Realizar Operaciones Aritméticas Básicas

Python soporta todas las operaciones aritméticas estándar. Cuando se realiza una operación con operandos de diferentes tipos numéricos (por ejemplo, un int y un float), Python automáticamente "promociona" (widens) el resultado al tipo más general. La jerarquía es int -> float -> complex.

Aquí están los operadores comunes:

• + (Suma)
• - (Resta)
• * (Multiplicación)
• / (División - siempre resulta en un flotante)
• // (División entera o Floor Division - divide y redondea hacia abajo al entero más cercano)
• % (Módulo - devuelve el resto de una división)
• ** (Exponenciación)

Para concluir nuestra exploración, agreguemos una sección final a ~/project/number_types.py para practicar estas operaciones.

## Demonstrate basic arithmetic operations
print("\n--- Basic Arithmetic Operations ---")
a = 10
b = 3

print(f"{a} + {b} = {a + b}")
print(f"{a} - {b} = {a - b}")
print(f"{a} * {b} = {a * b}")
print(f"{a} / {b} = {a / b}")
print(f"{a} // {b} = {a // b}")
print(f"{a} % {b} = {a % b}")
print(f"{a} ** {b} = {a ** b}")

## Demonstrate mixed-type operations
print("\n--- Mixed-Type Operations ---")
int_op = 5
float_op = 2.5
result_mixed = int_op * float_op
print(f"{int_op} (int) * {float_op} (float) = {result_mixed} ({type(result_mixed)})")

Guarde el archivo y ejecute el script completo:

python ~/project/number_types.py

La salida final incluirá:

--- Basic Arithmetic Operations ---
10 + 3 = 13
10 - 3 = 7
10 * 3 = 30
10 / 3 = 3.3333333333333335
10 // 3 = 3
10 % 3 = 1
10 ** 3 = 1000

--- Mixed-Type Operations ---
5 (int) * 2.5 (float) = 12.5 (<class 'float'>)

Esta salida confirma el comportamiento de cada operador. Observe que la división estándar / produce un flotante, mientras que la división entera // produce un entero. La operación de tipo mixto entre un entero y un flotante da como resultado un flotante, como se esperaba.

Resumen

En este laboratorio, ha adquirido una base sólida en los tipos de datos numéricos de Python. Ha aprendido sobre enteros (integers), booleanos (booleans), flotantes (floats) y números complejos (complex numbers). Exploró el concepto de inmutabilidad (immutability) y utilizó las funciones id() y type() para inspeccionar objetos. Practicó el manejo de problemas de precisión de punto flotante con el módulo decimal, la conversión entre diferentes tipos de números usando int(), float() y complex(), y la realización de una variedad de operaciones aritméticas. Este conocimiento es crucial para cualquier tarea de programación o análisis de datos posterior en Python.