Módulo math en Python: operaciones matemáticas esenciales

El módulo math de Python reúne funciones matemáticas optimizadas para trabajar con números reales: raíces, potencias, redondeos, logaritmos, trigonometría, constantes y comprobaciones numéricas. Está incluido en la biblioteca estándar, por lo que no necesita instalación. Es una herramienta adecuada para cálculos científicos sencillos, geometría, simulaciones, validaciones y procesamiento numérico cuando no hace falta utilizar bibliotecas más grandes.

Para aprovecharlo conviene conocer los números enteros en Python, las particularidades de los números de punto flotante y la creación de funciones reutilizables. El módulo trabaja principalmente con valores int y float.

Importar math correctamente

import math

Después se accede a cada función con el prefijo math.. También es posible importar funciones concretas, pero mantener el nombre del módulo suele mejorar la claridad:

from math import sqrt, pi

print(sqrt(25))
print(pi)

No llames a tu archivo math.py, porque puede ocultar el módulo estándar y provocar errores de importación.

Raíces y potencias

math.sqrt() calcula la raíz cuadrada:

import math

lado = 9
raiz = math.sqrt(lado)
print(raiz)

Si se entrega un número negativo, se produce ValueError, porque math trabaja con números reales. Para números complejos existe el módulo cmath.

math.pow(a, b) eleva un valor a una potencia y devuelve un float:

resultado = math.pow(2, 8)
print(resultado)

El operador ** suele ser más directo y puede conservar enteros:

resultado = 2 ** 8

Usa math.pow() cuando quieras expresar explícitamente que trabajas con una operación matemática de punto flotante.

Redondear hacia arriba y hacia abajo

ceil() devuelve el entero menor que sea mayor o igual al valor. floor() devuelve el entero mayor que sea menor o igual:

precio = 12.3

print(math.ceil(precio))   # 13
print(math.floor(precio))  # 12

Con números negativos, el comportamiento puede sorprender:

print(math.ceil(-2.7))   # -2
print(math.floor(-2.7))  # -3

math.trunc() elimina la parte decimal aproximándose a cero. No es igual que floor() para valores negativos.

Valor absoluto y distancia

Python incluye la función integrada abs(), pero math.fabs() devuelve siempre un float:

print(abs(-10))
print(math.fabs(-10))

Para calcular la distancia euclidiana entre dos puntos, math.dist() simplifica el código:

punto_a = (1, 2)
punto_b = (4, 6)

print(math.dist(punto_a, punto_b))

Otra función útil es hypot(), que calcula la longitud de una hipotenusa o la norma de varias coordenadas:

diagonal = math.hypot(3, 4)
print(diagonal)  # 5.0

Constantes matemáticas

El módulo ofrece constantes con buena precisión para cálculos de punto flotante:

print(math.pi)
print(math.e)
print(math.tau)
print(math.inf)
print(math.nan)

pi se utiliza en geometría y trigonometría; e aparece en crecimiento exponencial y logaritmos; tau equivale a dos veces pi. inf representa infinito y nan significa “no es un número”.

Calcular áreas y circunferencias

import math

def datos_circulo(radio):
    if radio < 0:
        raise ValueError("El radio no puede ser negativo")

    area = math.pi * radio ** 2
    circunferencia = 2 * math.pi * radio
    return area, circunferencia

area, longitud = datos_circulo(5)
print(f"Área: {area:.2f}")
print(f"Circunferencia: {longitud:.2f}")

La validación evita resultados sin sentido y hace que la función sea más fácil de reutilizar.

Logaritmos y exponenciales

math.log(x) calcula el logaritmo natural. También puedes indicar una base:

print(math.log(math.e))
print(math.log(1000, 10))

Para bases comunes existen funciones especializadas:

print(math.log10(1000))
print(math.log2(1024))
print(math.exp(2))

El argumento de un logaritmo real debe ser positivo. Cero o valores negativos producen ValueError.

Trigonometría y radianes

Las funciones trigonométricas utilizan radianes, no grados:

angulo_grados = 30
angulo_radianes = math.radians(angulo_grados)

print(math.sin(angulo_radianes))
print(math.cos(angulo_radianes))
print(math.tan(angulo_radianes))

Para convertir el resultado nuevamente a grados utiliza math.degrees(). Confundir grados con radianes es uno de los errores más frecuentes.

Comparar floats con isclose

Los valores decimales no siempre se representan de forma exacta. Por eso esta comparación puede fallar:

print(0.1 + 0.2 == 0.3)  # False

math.isclose() compara usando tolerancias:

resultado = math.isclose(0.1 + 0.2, 0.3)
print(resultado)

Puedes ajustar rel_tol y abs_tol. Una tolerancia absoluta es especialmente importante cerca de cero:

math.isclose(valor, 0.0, abs_tol=1e-9)

Detectar infinito y NaN

valores = [10.0, math.inf, math.nan]

for valor in valores:
    if math.isnan(valor):
        print("NaN")
    elif math.isinf(valor):
        print("Infinito")
    elif math.isfinite(valor):
        print("Finito")

No compares un valor con math.nan usando ==, porque NaN no es igual ni siquiera a sí mismo.

Factorial, combinaciones y máximo común divisor

El módulo también incluye herramientas para matemática discreta:

print(math.factorial(5))
print(math.comb(10, 3))
print(math.perm(10, 3))
print(math.gcd(48, 18))
print(math.lcm(6, 8))

factorial() acepta enteros no negativos. comb() cuenta combinaciones sin importar el orden y perm() cuenta selecciones donde el orden sí importa.

Sumas más precisas

math.fsum() puede ser más precisa que sum() con muchos floats:

valores = [0.1] * 10
print(sum(valores))
print(math.fsum(valores))

Cuando el error acumulado importa, fsum() es una buena opción. Para dinero o precisión decimal exacta, considera decimal.Decimal.

Medir el rendimiento

No asumas que una operación es lenta sin medirla. La guía de timeit en Python muestra cómo comparar implementaciones evitando mediciones engañosas.

La documentación oficial del módulo math contiene la lista completa de funciones, restricciones y cambios por versión. La documentación oficial de decimal explica cuándo necesitas aritmética decimal controlada en lugar de floats binarios.

Errores frecuentes

Los problemas habituales son pasar negativos a sqrt(), usar grados directamente en funciones trigonométricas, comparar floats con igualdad exacta, confundir floor() con truncamiento y esperar precisión financiera de un float. También es frecuente ignorar nan e infinito al procesar datos externos.

Conclusión

El módulo math ofrece una base sólida para cálculos numéricos. Permite trabajar con raíces, potencias, logaritmos, trigonometría, redondeos, combinaciones y validaciones de punto flotante con una interfaz coherente. La elección correcta depende del problema: math para números reales, cmath para complejos, decimal para precisión decimal y bibliotecas como NumPy para grandes colecciones. Comprender estas diferencias evita errores silenciosos y hace que los cálculos sean más confiables.