Comment faire des exposantsen Python

1. Utilisation de l’opérateur ** pour faire l’exposant en Python
2. Utilisez pow() ou math.power() pour faire l’exposant en Python
3. Utiliser numpy.np() pour faire un exposant en Python
4. Comparaison des durées d’exécution pour chaque solution

Ce tutoriel montre comment faire des exponentielles en Python.

En mathématiques, l’exponentiation est une opération où un nombre est multiplié un certain nombre de fois avec lui-même.

Python fournit des opérations et des fonctions intégrées pour aider à effectuer l’exponentiation.

Utilisation de l’opérateur ** pour faire l’exposant en Python

La plupart des développeurs semblent penser que le symbole du signe d’insertion ^ est l’opérateur qui permet d’obtenir la puissance d’un nombre, car le signe d’insertion est utilisé comme symbole pour les exposants en mathématiques. Cependant, dans la plupart des langages de programmation, le symbole du signe d’insertion est réservé à l’opérateur xor au niveau des bits.

En Python, l’opérateur d’exposant est symbolisé par deux astérisques consécutifs ** entre le nombre de base et l’exposant.

La fonctionnalité de l’opérateur d’exposant complète le comportement de l’opérateur de multiplication * ; la différence est que le second opérande de l’opérateur d’exposant sert à fixer le nombre de fois que le premier opérande est multiplié par lui-même.

print(5 ** 6)

Pour multiplier le nombre 5 par lui-même 6 fois, utilisez l’opérateur ** entre l’opérande de base 5 et l’opérande d’exposant 6.

Production :

15625

Testons cet opérateur sur différents types de valeurs.

Nous allons initialiser un nombre entier, un nombre entier négatif, zéro, et deux valeurs float inférieures à 1 et supérieures à 1. Ensuite, nous assignerons des entiers aléatoires comme exposants.

num1 = 2
num2 = -5
num3 = 0
num4 = 1.025
num5 = 0.5

print(num1, "^12=", num1 ** 12)
print(num2, "^4=", num2 ** 4)
print(num3, "^9999=", num3 ** 9999)
print(num4, "^-3=", num4 ** -3)
print(num5, "^8=", num5 ** 8)

Production :

2^12= 4096
-5^4= 625
0^9999= 0
1.025^-3= 0.928599410919749
0.5^8= 0.00390625

Utilisez pow() ou math.power() pour faire l’exposant en Python

Une autre façon de faire l’exposant en Python est d’utiliser la fonction pow() conçue pour exponencier les valeurs données à la base et à l’exposant. Le module math a également sa propre implémentation de pow() dans le même but.

Ces deux fonctions ont 2 arguments, le premier argument est pour le nombre de base, et le second est pour l’exposant.

Essayons d’appeler les deux fonctions plusieurs fois avec les mêmes arguments afin de pouvoir comparer leurs résultats.

import math

print(pow(-8, 7))
print(math.pow(-8, 7))

print(pow(2, 1.5))
print(math.pow(2, 1.5))

print(pow(4, 3))
print(math.pow(4, 3))

print(pow(2.0, 5))
print(math.pow(2.0, 5))

Production :

-2097152
-2097152.0
2.8284271247461903
2.8284271247461903
64
64.0
32.0
32.0

La seule différence dans les résultats est que math.pow() retourne toujours une valeur float même si des arguments de nombre entier sont passés, alors que pow() ne renverra float que s’il y a au moins un argument float.

Utiliser numpy.np() pour faire un exposant en Python

Le module NumPy a également sa propre fonction power() pour l’exponentiation. La fonction power() accepte les mêmes arguments que les fonctions pow(), où le premier argument est la valeur de base et le deuxième argument est la valeur de l’exposant.

Pour utiliser NumPy, nous devons l’installer via pip ou pip3.

• Python 2 :

pip install numpy

• Python 3 :

pip3 install numpy

Imprimons le même ensemble d’exemples dans pow() en utilisant numpy.power().

print(np.power(-8, 7))
print(np.power(2, 1.5))
print(np.power(4, 3))
print(np.power(2.0, 5))

Production :

-2097152
2.8284271247461903
64
32.0

power() produit la même sortie que la fonction Python intégrée pow() où elle retournera un nombre entier s’il n’y a pas d’arguments float.

Comparaison des durées d’exécution pour chaque solution

Comparons le temps nécessaire pour que ces 3 fonctions et l’opérateur ** fonctionnent avec une grande valeur d’exposant. Pour les fonctions de chronométrage, nous allons importer le module timeit pour imprimer le temps d’exécution de chacune des solutions.

La valeur de la base sera 2, et la valeur de l’exposant sera 99999.

import numpy as np
import math
import time

start = time.process_time()
val = 2 ** 99999
print("** took", time.process_time() - start, "ms")

start = time.process_time()
val = pow(2, 99999)
print("pow() took", time.process_time() - start, "ms")

start = time.process_time()
val = np.power(2, 99999)
print("np.power() took", time.process_time() - start, "ms")

start = time.process_time()
val = math.pow(2, 99999)
print("math.pow() took", time.process_time() - start, "ms")

Production :

** took 0.0006959999999999744 ms

pow() took 0.00039000000000000146 ms

np.power() took 1.6999999999989246e-05 ms

Traceback (most recent call last):
  File "/Users/rayven/python/timeit.py", line 15, in <module>
    val = math.pow(2,99999)
OverflowError: math range error

La chose la plus évidente à noter est que math.pow() a donné une OverflowError. Cela signifie que math.pow() ne peut pas supporter les exposants de grande valeur, très probablement à cause de la façon dont ce module a implémenté l’exponentiation.

La différence entre les 3 autres méthodes est triviale, mais d’après cet exemple, np.power() est la fonction la plus rapide pour effectuer une exponentiation.

Et si nous essayons de réduire l’exposant à 9999 ? Voyons ce que math.pow() produit.

** took 1.0000000000010001e-05 ms
pow() took 4.000000000004e-06 ms
np.power() took 2.0000000000020002e-05 ms
math.pow() took 2.9999999999752447e-06 ms