Módulos en Python: Módulos incluidos
En el artículo anterior introducimos el concepto de módulos en python, y vimos que que un módulo no es más que un programa que actúa como un contenedor de funciones. Vimos que los módulos pueden ser importados y podemos hacer uso de las funciones que están contenidos en el módulo referenciando el nombre del módulo seguido de un punto y luego el nombre de la función. También aprendimos que podemos importar funciones específicas de un módulo, así como cambiar el nombre de la función importada. Comenzamos describiendo brevemente el módulo math. En este artículo y en los próximos describiremos con un poco más de detalle las funciones que están contenidas en el módulo math y describiremos otros modulos que estan incluidos en python.
Módulo math
El módulo math está constituido por funciones matemáticas, las cuales no se aplican a números complejos. Estas funciones están divididas en las siguientes categorías:
- Funciones de Teoria de Numeros y Representación
- Funciones Potenciales y Logarítmicas
- Funciones Trigonométricas
- Funciones de Conversión Angular
- Funciones Hiperbólicas
- Funciones Especiales
- Constantes
Funciones de Teoria de Numeros y Representación
math.ceil(x)
Esta función devuelve el valor del techo (ceiling) del valor x. En términos simple devuelve el número entero que es mayor o igual que x. Por ejemplo si aplicamos la función a un número entero, devolverá el valor del número, si colocamos un número de tipo float, devolvera el numero entero mayor a x.
>>>
>>> math.ceil(18)
18
>>> math.ceil(18.1)
19
>>> math.ceil(18.95)
19
>>>
math.copysign(x,y)
Devuelve un número de tipo float con la magnitud (valor absoluto) de x, y con el signo de y. En algunas plataformas se acepta el uso de cero con signo.
>>> math.copysign(2.56, -7)
-2.56
>>> math.copysign(2.56, -0.0)
-2.56
>>> math.copysign(2.56, 0.0)
2.56
>>> math.copysign(-2.56, 0.0)
2.56
>>>
math.fabs(x)
Devuelve el valor absoluto del valor x.
>>>
>>> math.fabs(5.754)
5.754
>>> math.fabs(-5.754)
5.754
>>>
math.factorial(x)
Devuelve el valor de la función factorial de un número. Da error si se aplica a números no enteros y a números negativos.
Factorial(n) = n*(n-1)*(n-2)* …..1
Factorial(8) = 8*7*6*5*4*3*2*1
>>> math.factorial(8)
40320
>>> math.factorial(-8)
Traceback (most recent call last):
File “”, line 1, in
math.factorial(-8)
ValueError: factorial() not defined for negative values
>>> math.factorial(8.25)
Traceback (most recent call last):
File “”, line 1, in
math.factorial(8.25)
ValueError: factorial() only accepts integral values
math.floor(x)
Devuelve el piso (floor) de x. Este es el valor del mayor entero que es menor o igual que x.
>>>
>>> math.floor(8)
8
>>> math.floor(8.05)
8
>>> math.floor(8.99)
8
>>>
math.fmod(x,y)
Esta función calcula el módulo de x con respecto a y. Esto es equivalente al residuo de la división de x entre y. Esta es una función útil para definir la divisibilidad de un número por otro número. Si el módulo de x de y es igual a cero, entonces x es divisible por y.
>>> math.fmod(27,3)
0.0
>>> math.fmod(28,3)
1.0
>>>
math.frexp(x)
Devuelve la mantisa y exponente de un número x, como un par (m, e). Donde m es un número de tipo float y e es un entero de forma que, x==m*2**e exactamente. Si x es cero, devuelve (0.0, 0), de cualquier otra forma 0.5 <= abs(m) < 1. Esto se utiliza para separar la representación de un número tipo float en una forma portable.
>>> math.frexp(0)
(0.0, 0)
>>> math.frexp(5.1)
(0.6375, 3)
>>> 0.6375*2**3
5.1
>>>
math.fsum(iteración)
Calcula de forma exacta la suma de valores de punto flotante. Evita la perdida de precisión mediante el rastreo de las múltiples sumas parciales intermedias.
>>> 0.1+0.1+0.1+0.1+0.1+0.1+0.1+0.1+0.1+0.1
0.9999999999999999
>>> math.fsum([0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1])
1.0
>>>
Se observa que una suma de 10 valores que debería resultar en un valor exacto de 1.0 daba un resultado de 0.99999999. Sin embargo cuando se utiliza math.fsum el valor da exactamente 1.0.
math.gcd(a,b)
Devuelve el valor del máximo común divisor de los números enteros a y b. Si a y b son dos enteros diferentes de cero, entonces el valor de gcd(a,b) es el valor del mayor entero positivo que divide a ambos números a y b. Si alguno de los números es cero, y el otro es un entero diferente de cero, entonces el maximo comun divisor es el entero diferente de cero.
>>> math.gcd(0,0)
0
>>> math.gcd(2,0)
2
>>> math.gcd(12,6)
6
>>> math.gcd(12,8)
4
>>>
math.isclose(a, b, *, rel_tol=1e-09, abs_tol=0.0)
Devuelve True si los valores a y b están próximos el uno del otro, en caso contrario devuelve False.
Para considerar que a y b están próximos se utilizan las tolerancias relativas y absolutas.
La rel_tol es la tolerancia relativa. Es la máxima diferencia entre a y b , relativo al mayor valor absoluto de a o b. Por ejemplo para establecer una tolerancia de 5%, se utiliza una rel_tol=0.05. La tolerancia por defecto es 1e-09, lo que asegura que los dos valores son iguales dentro de aproximadamente 9 cifras decimales. La rel-tol debe ser mayor que cero.
La abs-tol es el valor de la minima tolerancia absoluta. Útil para comparaciones cerca de cero. La abs-tol debe ser al menos cero.
Cuando no se utilizan los parámetros rel_tol y abs_tol, se utilizan los valores por defecto de estos parámetros, por lo que al evaluar la función para los valores 1 y 1.005 da False.
>>> math.isclose(1, 1.005)
False
Hay que utilizar la identificación de los parámetros, de lo contrario da error.
>>> math.isclose(1, 1.005, 0.5, 0)
Traceback (most recent call last):
File “”, line 1, in
math.isclose(1, 1.005, 0.5, 0)
TypeError: Function takes at most 2 positional arguments (4 given)
En este ejemplo se coloca el parámetro rel-tol=0.05 y la función da un valor de True, lo que indica que 1 y 1.005 están cercanos cuando se utiliza una tolerancia relativa de 0.05 (5%).
>>> math.isclose(1, 1.005, rel_tol=0.05)
True
En este ejemplo se utilizan ambos parámetros rel_tol y abs_tol. La evaluación de la función nos indica que 1 y 1.0005 están cercanos cuando se evalúan con los parámetros de tolerancia indicados, rel_tol=0.05, abs_tol=0.001.
>>> math.isclose(1, 1.0005, rel_tol=0.05, abs_tol=0.001)
True
Para que la función de como resultado True debe cumplirse la siguiente la siguiente expresión:
abs(a-b) <= max(rel_tol * max(abs(a), abs(b)), abs_tol).
Estamos evaluando el valor absoluto de la diferencia entre a y b y los estamos comparando con el valor máximo entre las tolerancias relativas y absolutas. Si el valor máximo de las tolerancias no es mayor que el valor absoluto de las diferencias entre a y b, entonces los valores a y b no están cercanos y la función evaluará False.
math.isfinite(x)
Devuelve True si x no es infinito o NaN, y False en caso contrario. (0.0 se considera como finito).
math.isinf(x)
Devuelve True si x no es ni infinito ni NaN, y False en caso contrario.
math.isnan(x)
Devuelve True si x es NaN (Not a number) no un número, y False en caso contrario.
math.ldexp(x, i)
Calcula y regresa el valor numérico de la expresión
x * (2**i)
Esta función es esencialmente la función inversa de frexp(x)
>>> math.frexp(16)
(0.5, 5)
>>> math.ldexp(0.5, 5)
16.0
math.modf(x)
Regresa la parte fraccional y la parte entera de x. Ambos resultados tienen el signo de x y son de tipo float.
>>> math.modf(15.87654)
(0.8765400000000003, 15.0)
math.trunc(x)
Devuelve el valor real de x, truncado a un valor entero.
>>> math.trunc(15.87654)
15
>>> math.trunc(-1.4142)
-1
En el próximo artículo revisaremos las otras funciones que están contenidas en el módulo math.