Calcula funcións exponenciais e logarítmicas en Python (exp, log, log10, log2)

Negocios

Usando matemáticas, o módulo estándar de Python para funcións matemáticas, pode calcular funcións exponenciais e logarítmicas (logaritmo natural, logaritmo ordinario e logaritmo binario).

Aquí explícase o seguinte, xunto co código de mostra.

  • Base do logaritmo natural (número de Napier):math.e
  • Potencia::**operador,pow(),math.pow()
  • Raíz cadrada (raíz):math.sqrt()
  • Función exponencial (función exponencial natural):math.exp()
  • unha función logarítmica:math.log(),math.log10(),math.log2()

Base do logaritmo natural (número de Napier):math.e

A base do logaritmo natural (número de Napier) preséntase como unha constante no módulo de matemáticas, denotada por math.e.

import math

print(math.e)
# 2.718281828459045

Potencia: ** operador, pow(), math.pow():**operador,pow(),math.pow()

Para calcular potencias, use o operador **, a función integrada pow() ou math.pow().

O cadrado y de x obtense do seguinte xeito

  • x**y
  • pow(x, y)
  • math.pow(x, y)
print(2**4)
# 16

print(pow(2, 4))
# 16

print(math.pow(2, 4))
# 16.0

math.pow() converte o argumento nun tipo de punto flotante. Por outra banda, a función integrada de Python pow() usa __pow()__ definido para cada tipo.

Por exemplo, pow() permite que se especifiquen tipos complexos como argumentos, pero math.pow() non pode converter os tipos complexos en tipos flotantes, o que provoca un erro.

print(pow(1 + 1j, 2))
# 2j

# print(math.pow(1 + 1j, 2))
# TypeError: can't convert complex to float

A función integrada de Python pow() tamén permite un terceiro argumento, pow(x, y, z), que devolve o resto (resto) de z á potencia y de x. É o mesmo cálculo que pow(x, y) % z, pero pow(x, y, z) é máis eficiente.

print(pow(2, 4, 5))
# 1

Raíz cadrada (raíz):math.sqrt()

A raíz cadrada (raíz) pódese establecer en **0,5 usando ** ou math.sqrt().

print(2**0.5)
# 1.4142135623730951

print(math.sqrt(2))
# 1.4142135623730951

print(2**0.5 == math.sqrt(2))
# True

Do mesmo xeito que math.pow(), math.sqrt() converte os argumentos en tipos de coma flotante para procesar, polo que especificar un tipo que non se pode converter nun tipo flotante producirá un TypeError.

print((-3 + 4j)**0.5)
# (1.0000000000000002+2j)

# print(math.sqrt(-3 + 4j))
# TypeError: can't convert complex to float

Ademais, math.sqrt() non pode procesar valores negativos, polo que se produce un ValueError.

print((-1)**0.5)
# (6.123233995736766e-17+1j)

# print(math.sqrt(-1))
# ValueError: math domain error

Teña en conta que cando se trata de números complexos, o exemplo que usa o operador ** mostra un erro, pero o módulo cmath proporciona un valor máis preciso. Tamén se poden manexar 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 a potencia da base do logaritmo natural (número de Napier) e, use math.exp().

math.exp(x) devolve x ao cadrado de e.
math.exp(x) non é equivalente a “math.e ** x” e math.exp(x) é máis preciso.

print(math.exp(2))
# 7.38905609893065

print(math.exp(2) == math.e**2)
# False

unha función logarítmica:math.log(),math.log10(),math.log2()

Para calcular a función logarítmica, use math.log(),math.log10(),math.log2().

math.log(x, y) devolve o logaritmo de x con y como base.

print(math.log(25, 5))
# 2.0

Se se omite o segundo argumento, a continuación móstrase o logaritmo natural.

logaritmo

En matemáticas, o logaritmo natural (logaritmo co número de Napier e como base), representado por log ou ln, pódese calcular mediante math.log(x).

print(math.log(math.e))
# 1.0

logaritmo (base 10)

O logaritmo ordinario (logaritmo con base 10) pódese calcular con math.log10(x), que é máis preciso que math.log(x, 10).

print(math.log10(100000))
# 5.0

logaritmo binario

O logaritmo binario (logaritmo con base 2) pódese calcular con math.log2(x), que é máis preciso que math.log(x, 2).

print(math.log2(1024))
# 10.0