Calcular funções exponenciais e logarítmicas em Python (exp, log, log10, log2)

O negócio

Usando matemática, o módulo padrão de Python para funções matemáticas, é possível calcular funções exponenciais e logarítmicas (logaritmo natural, logaritmo normal, e logaritmo binário).

O seguinte é explicado aqui, juntamente com o código da amostra.

  • Base de logaritmo natural (número Napier):math.e
  • Poder::**operador,pow(),math.pow()
  • Raiz quadrada (raiz):math.sqrt()
  • Função exponencial (função exponencial natural):math.exp()
  • uma função logarítmica:math.log(),math.log10(),math.log2()

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

A base do logaritmo natural (número Napier) é fornecida como uma constante no módulo de matemática, denotada pela matemática.

import math

print(math.e)
# 2.718281828459045

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

Para calcular as potências, utilizar ou o ** operador, a função pow(), ou a matemática.pow().

O quadrado y de x é obtido da seguinte forma

  • 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 para um tipo de ponto flutuante. Por outro lado, a função Python's built-in function pow() utiliza __pow()__ definido para cada tipo.

Por exemplo, pow() permite que tipos complexos sejam especificados como argumentos, mas matemática.pow() não pode converter tipos complexos em tipos flutuantes, resultando num erro.

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

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

A função de Python integrada pow() também permite um terceiro argumento, pow(x, y, z), que devolve o restante (restante) de z à potência y de x. É o mesmo cálculo que pow(x, y) % z, mas pow(x, y, z) é mais eficiente.

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

Raiz quadrada (raiz): math.sqrt()

A raiz quadrada (raiz) pode ser definida para **0,5 usando ** ou matemática.sqrt().

print(2**0.5)
# 1.4142135623730951

print(math.sqrt(2))
# 1.4142135623730951

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

Tal como o math.pow(), o math.sqrt() converte argumentos em tipos de ponto flutuante para processamento, pelo que especificar um tipo que não pode ser convertido num tipo de ponto flutuante resultará num TypeError.

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

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

Além disso, o Math.sqrt() não pode processar valores negativos, resultando num ValueError.

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

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

Note-se que ao lidar com números complexos, o exemplo utilizando o operador ** mostra um erro, mas o módulo cmath fornece um valor mais exacto. Os valores negativos também podem ser tratados.

import cmath

print(cmath.sqrt(-3 + 4j))
# (1+2j)

print(cmath.sqrt(-1))
# 1j

Função exponencial (função exponencial natural): math.exp()

Para calcular a potência da base do logaritmo natural (número Napier) e, usar matemática.exp().

math.exp(x) retorna x ao quadrado de e.
math.exp(x) não é equivalente a “math.e ** x” e math.exp(x) é mais preciso.

print(math.exp(2))
# 7.38905609893065

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

uma função logarítmica: math.log(), math.log10(), math.log2()

Para calcular a função logarítmica, usar math.log(),math.log10(),math.log2().

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

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

Se o segundo argumento for omitido, o logaritmo natural é mostrado abaixo.

logaritmo

Em matemática, o logaritmo natural (logaritmo com o número Napier e como base), representado por log ou ln, pode ser calculado por math.log(x).

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

logaritmo (base 10)

O logaritmo normal (logaritmo com base 10) pode ser calculado com math.log10(x), que é mais preciso do que math.log(x, 10).

print(math.log10(100000))
# 5.0

logaritmo binário

O logaritmo binário (logaritmo com base 2) pode ser calculado com math.log2(x), que é mais preciso do que math.log(x, 2).

print(math.log2(1024))
# 10.0