À l'aide de math, le module standard de Python pour les fonctions mathématiques, vous pouvez calculer les fonctions exponentielles et logarithmiques (logarithme naturel, logarithme ordinaire et logarithme binaire).
Ce qui suit est expliqué ici, avec un exemple de code.
- Base du logarithme naturel (nombre de Napier):
math.e - Puissance ::
**opérateur,pow(),math.pow() - Racine carrée (racine):
math.sqrt() - Fonction exponentielle (fonction exponentielle naturelle):
math.exp() - une fonction logarithmique:
math.log(),math.log10(),math.log2()
Base du logarithme naturel (nombre de Napier): math.e
La base du logarithme naturel (nombre de Napier) est fournie comme une constante dans le module mathématique, désignée par math.e.
import math
print(math.e)
# 2.718281828459045
Puissance : ** opérateur, pow(), math.pow(): **opérateur, pow(), math.pow()
Pour calculer des puissances, utilisez soit l'opérateur **, soit la fonction intégrée pow(), soit math.pow().
Le carré des y de x est obtenu comme suit
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() convertit l'argument en un type à virgule flottante. D'autre part, la fonction intégrée de Python, pow(), utilise __pow()__ définie pour chaque type.
Par exemple, pow() permet de spécifier des types complexes comme arguments, mais math.pow() ne peut pas convertir les types complexes en types flottants, ce qui entraîne une erreur.
print(pow(1 + 1j, 2))
# 2j
# print(math.pow(1 + 1j, 2))
# TypeError: can't convert complex to float
La fonction intégrée Python pow() permet également un troisième argument, pow(x, y, z), qui renvoie le reste (résidu) de z à la puissance y de x. C'est le même calcul que pow(x, y) % z, mais pow(x, y, z) est plus efficace.
print(pow(2, 4, 5))
# 1
Racine carrée (racine): math.sqrt()
La racine carrée (root) peut être fixée à **0,5 en utilisant ** ou math.sqrt().
print(2**0.5)
# 1.4142135623730951
print(math.sqrt(2))
# 1.4142135623730951
print(2**0.5 == math.sqrt(2))
# True
Comme math.pow(), math.sqrt() convertit les arguments en types à virgule flottante pour le traitement, de sorte que la spécification d'un type qui ne peut pas être converti en type flottant entraînera une TypeError.
print((-3 + 4j)**0.5)
# (1.0000000000000002+2j)
# print(math.sqrt(-3 + 4j))
# TypeError: can't convert complex to float
En outre, math.sqrt() ne peut pas traiter les valeurs négatives, ce qui entraîne une ValueError.
print((-1)**0.5)
# (6.123233995736766e-17+1j)
# print(math.sqrt(-1))
# ValueError: math domain error
Notez que lorsqu'on traite des nombres complexes, l'exemple utilisant l'opérateur ** montre une erreur, mais le module cmath fournit une valeur plus précise. Les valeurs négatives peuvent également être traitées.
import cmath
print(cmath.sqrt(-3 + 4j))
# (1+2j)
print(cmath.sqrt(-1))
# 1j
Fonction exponentielle (fonction exponentielle naturelle): math.exp()
Pour calculer la puissance de la base du logarithme naturel (nombre de Napier) e, utilisez math.exp().
math.exp(x) renvoie x au carré de e.
math.exp(x) n'est pas équivalent à “math.e ** x” et math.exp(x) est plus précis.
print(math.exp(2))
# 7.38905609893065
print(math.exp(2) == math.e**2)
# False
une fonction logarithmique: math.log(), math.log10(), math.log2()
Pour calculer la fonction logarithmique, utilisez math.log(),math.log10(),math.log2().
math.log(x, y) renvoie le logarithme de x avec y comme base.
print(math.log(25, 5))
# 2.0
Si le deuxième argument est omis, le logarithme naturel est représenté ci-dessous.
logarithme
En mathématiques, le logarithme naturel (logarithme avec le nombre de Napier e comme base), représenté par log ou ln, peut être calculé par math.log(x).
print(math.log(math.e))
# 1.0
logarithme (base 10)
Le logarithme ordinaire (logarithme en base 10) peut être calculé avec math.log10(x), qui est plus précis que math.log(x, 10).
print(math.log10(100000))
# 5.0
logarithme binaire
Le logarithme binaire (logarithme en base 2) peut être calculé avec math.log2(x), qui est plus précis que math.log(x, 2).
print(math.log2(1024))
# 10.0
