Utilizando math, el módulo estándar de Python para funciones matemáticas, puedes calcular funciones exponenciales y logarítmicas (logaritmo natural, logaritmo ordinario y logaritmo binario).
Aquí se explica lo siguiente, junto con un código de ejemplo.
- Base del logaritmo natural (número Napier):
math.e - Poder::
**operador,pow(),math.pow() - Raíz cuadrada (raíz):
math.sqrt() - Función exponencial (función exponencial natural):
math.exp() - una función logarítmica:
math.log(),math.log10(),math.log2()
Base del logaritmo natural (número Napier): math.e
La base del logaritmo natural (número Napier) se proporciona como una constante en el módulo matemático, denotada por math.e.
import math
print(math.e)
# 2.718281828459045
Potencia: Operador **, pow(), math.pow(): **operador, pow(), math.pow()
Para calcular potencias, utilice el operador **, la función incorporada pow() o math.pow().
El y-cuadrado de x se obtiene de la siguiente manera
x**ypow(x, y)math.pow(x, y)
print(2**4)
# 16
print(pow(2, 4))
# 16
print(math.pow(2, 4))
# 16.0
math.pow() convierte el argumento en un tipo de punto flotante. Por otro lado, la función incorporada de Python pow() utiliza __pow()__ definida para cada tipo.
Por ejemplo, pow() permite especificar tipos complejos como argumentos, pero math.pow() no puede convertir tipos complejos a tipos float, lo que provoca un error.
print(pow(1 + 1j, 2))
# 2j
# print(math.pow(1 + 1j, 2))
# TypeError: can't convert complex to float
La función incorporada de Python pow() también permite un tercer argumento, pow(x, y, z), que devuelve el resto (resto) de z a la potencia de y de x. Es el mismo cálculo que pow(x, y) % z, pero pow(x, y, z) es más eficiente.
print(pow(2, 4, 5))
# 1
Raíz cuadrada (raíz): math.sqrt()
La raíz cuadrada (root) se puede establecer en **0,5 utilizando ** o math.sqrt().
print(2**0.5)
# 1.4142135623730951
print(math.sqrt(2))
# 1.4142135623730951
print(2**0.5 == math.sqrt(2))
# True
Al igual que math.pow(), math.sqrt() convierte los argumentos a tipos de punto flotante para su procesamiento, por lo que la especificación de un tipo que no puede ser convertido a un tipo float dará lugar a un TypeError.
print((-3 + 4j)**0.5)
# (1.0000000000000002+2j)
# print(math.sqrt(-3 + 4j))
# TypeError: can't convert complex to float
Además, math.sqrt() no puede procesar valores negativos, lo que provoca un ValueError.
print((-1)**0.5)
# (6.123233995736766e-17+1j)
# print(math.sqrt(-1))
# ValueError: math domain error
Tenga en cuenta que cuando se trata de números complejos, el ejemplo que utiliza el operador ** muestra un error, pero el módulo cmath proporciona un valor más preciso. También se pueden manejar valores negativos.
import cmath
print(cmath.sqrt(-3 + 4j))
# (1+2j)
print(cmath.sqrt(-1))
# 1j
Función exponencial (función exponencial natural): math.exp()
Para calcular la potencia de la base del logaritmo natural (número Napier) e, utiliza math.exp().
math.exp(x) devuelve x al cuadrado de e.
math.exp(x) no es equivalente a «math.e ** x» y math.exp(x) es más preciso.
print(math.exp(2))
# 7.38905609893065
print(math.exp(2) == math.e**2)
# False
una función logarítmica: math.log(), math.log10(), math.log2()
Para calcular la función logarítmica, utiliza math.log(),math.log10(),math.log2().
math.log(x, y) devuelve el logaritmo de x con y como base.
print(math.log(25, 5))
# 2.0
Si se omite el segundo argumento, el logaritmo natural se muestra a continuación.
logaritmo
En matemáticas, el logaritmo natural (logaritmo con el número e de Napier como base), representado por log o ln, se puede calcular mediante math.log(x).
print(math.log(math.e))
# 1.0
logaritmo (base 10)
El logaritmo ordinario (logaritmo con base 10) se puede calcular con math.log10(x), que es más preciso que math.log(x, 10).
print(math.log10(100000))
# 5.0
logaritmo binario
El logaritmo binario (logaritmo con base 2) se puede calcular con math.log2(x), que es más preciso que math.log(x, 2).
print(math.log2(1024))
# 10.0
