Dominando Números, Conversión de Tipos y Matemáticas en Python

Dominando Números, Conversión de Tipos y Matemáticas en Python

Descubre cómo Python maneja datos numéricos, los matices de la conversión de tipos y las potentes utilidades matemáticas para la programación diaria.

Tipos de Datos Numéricos en Python

Python categoriza los números en tres tipos principales: int para números enteros, float para números reales con parte fraccionaria y complex para números con componentes real e imaginario. La presencia de un punto decimal distingue int de float (ej. 5 es entero, 5.0 es float). Los números complejos siguen la notación x + yj, donde x es la parte real e y la imaginaria.

Usa type() para inspeccionar la clase de un valor y isinstance() para verificar pertenencia a un tipo particular. Por ejemplo:

a = 5
print(type(a))
print(type(5.0))
c = 5 + 3j
print(c + 3)
print(isinstance(c, complex))

Salida:

<class 'int'> <class 'float'> (8+3j) True

Los enteros en Python tienen precisión arbitraria; los floats mantienen unos 15 dígitos decimales de precisión. Para desarrolladores que trabajan con representaciones binarias, hexadecimales u octales, Python ofrece prefijos convenientes:

Sistema Numérico	Prefijo
Binario	0b o 0B
Octal	0o o 0O
Hexadecimal	0x o 0X

Ejemplos:

# Salida: 107
print(0b1101011)
# Salida: 253 (251 + 2)
print(0xFB + 0b10)
# Salida: 13
print(0o15)

Resultado:

107 253 13

Conversión de Tipos (Coerción)

Python promueve automáticamente enteros a floats durante operaciones aritméticas cuando hay un operando float. Por ejemplo:

>>> 1 + 2.0
3.0

Las conversiones explícitas son igual de sencillas con int(), float() y complex(), que también pueden parsear cadenas:

>>> int(2.3)
2
>>> int(-2.8)
-2
>>> float(5)
5.0
>>> complex('3+5j')
(3+5j)

Al convertir un float a int, Python trunca la parte decimal en lugar de redondear.

Decimal en Python

La aritmética de punto flotante puede producir resultados sorprendentes debido a los límites de la representación binaria. Por ejemplo:

>>> (1.1 + 2.2) == 3.3
False

Como números como 0.1 no se pueden representar exactamente en binario, las operaciones generan pequeños errores de redondeo. El módulo decimal mitiga esto proporcionando aritmética decimal de precisión arbitraria:

import decimal
print(0.1)
print(decimal.Decimal(0.1))

Salida:

0.1 0.1000000000000000055511151231257827021181583404541015625

Usar Decimal preserva dígitos significativos y representaciones decimales exactas, esencial para cálculos financieros:

from decimal import Decimal as D
print(D('1.1') + D('2.2'))
print(D('1.2') * D('2.50'))

Salida:

3.3 3.000

Como las operaciones decimales son más lentas que los floats binarios, reserva Decimal para escenarios que requieren precisión exacta, como valores monetarios, precisión configurable o control de dígitos significativos.

¿Cuándo Usar Decimal en Lugar de Float?

• Aplicaciones financieras o monetarias que exigen representación decimal exacta.
• Escenarios donde la precisión debe controlarse explícitamente.
• Aplicaciones que requieren el concepto de lugares decimales significativos.

Fracciones en Python

El módulo fractions ofrece soporte para números racionales, permitiendo aritmética exacta con numerador y denominador como enteros:

import fractions
print(fractions.Fraction(1.5))
print(fractions.Fraction(5))
print(fractions.Fraction(1,3))

Salida:

3/2 5 1/3

Crear una Fraction desde un float puede producir resultados contraintuitivos por el redondeo binario, así que prefiere entradas de cadena para números decimales:

import fractions
# Desde float
print(fractions.Fraction(1.1))
# Desde cadena
print(fractions.Fraction('1.1'))

Salida:

2476979795053773/2251799813685248 11/10

Las fracciones soportan todos los operadores aritméticos:

from fractions import Fraction as F
print(F(1, 3) + F(1, 3))
print(1 / F(5, 6))
print(F(-3, 10) > 0)
print(F(-3, 10) < 0)

Salida:

2/3 6/5 False True

Matemáticas en Python

El módulo math de Python provee funciones para trigonometría, logaritmos, factoriales y más:

import math
print(math.pi)
print(math.cos(math.pi))
print(math.exp(10))
print(math.log10(1000))
print(math.sinh(1))
print(math.factorial(6))

Salida:

3.141592653589793 -1.0 22026.465794806718 3.0 1.1752011936438014 720

Para aleatoriedad y muestreo, el módulo random ofrece:

import random
print(random.randrange(10, 20))
x = ['a', 'b', 'c', 'd', 'e']
print(random.choice(x))
random.shuffle(x)
print(x)
print(random.random())

Salida de ejemplo (los valores varían):

18 e ['c', 'e', 'd', 'b', 'a'] 0.5682821194654443

Ambos módulos proporcionan documentación completa detallando todas las funciones y atributos disponibles.