Comment calculer puissance d'un nombre en python ?

Comment calculer la puissance d’un nombre en Python ? Découvrez toutes les manières de faire l’exposant en Python !

Pour élever un nombre à une puissance en Python, on utilise l’opérateur Python exposant **.

Ainsi, pour mettre m à la puissance n, on utilisera :

n ** m

Par exemple :

4 ** 2  # Résultat : 16

Dans ce guide complet, découvrons ensemble quelles sont les différentes opérations qu’on peut utiliser pour élever un nombre à une puissance.

En plus, on apprendra comment la notation des exposants aide à écrire les grands nombres dans un format plus compact.

On verra aussi quelle manière de faire l’exposant est la plus optimisée et performante !

Commençons sans plus tarder avec un rappel de ce qu’est un exposant.

Qu’est-ce qu’un exposant en maths ?

Un exposant est le nombre de fois qu’un nombre est multiplié par lui-même. En mathématiques, l’exposant est indiqué par un chiffre en exposant, comme 2⁴. Dans l’exemple, 2 est la base, et 4 est l’exposant : base ^ exposant.

Par exemple, quatre à la puissance 3 signifie 4^4^4, soit 64.

Maintenant qu’on sait ce que ça veut dire en math, voyons comment calculer les exposants en Python.

Comment faire l’exposant en Python ?

Il existe trois façons d’élever un nombre à la puissance en Python :

• L’opérateur **
• La fonction intégrée pow()
• La fonction math.pow() du module math

Voici un tableau qui résume chaque méthode de calcul des exposants en Python :

Voyons ensemble comment utiliser chacunes de ces méthodes.

1. L’opérateur double astérisques (**) en Python

On peut utiliser l’opérateur double astérisque ** pour élever un nombre à une puissance en Python.

Par exemple :

2 ** 3  # donne 8

Il s’agit d’une manière claire et efficace de calculer les puissances en Python. C’est la manière que je vous recommande pour calculer des puissances en Python. Mais quand est-il de ses performances ? On voit ça ensemble plus tard dans l’article.

2. La fonction pow() en Python

On peut aussi utiliser la fonction intégrée pow() pour élever un nombre à la puissance.

Par exemple :

pow(2, 3)  # donne 8

3. La fonction math.pow() en Python

Pour finir, on peut utiliser une autre fonction pow(), celle qui vient du module math de Python.

Par exemple:

import math
math.pow(2, 3)  # -> 8.0

Cette fonction fait la même chose que les deux approches précédentes de calcul de puissance. Mais elle est plus efficace avec les nombres flottants.

Mais alors pourquoi utiliser math.pow() plutôt que pow() ? Et pourquoi pas simplement utiliser ** tout le temps ?

** vs pow() vs math.pow()

Comme on l’a vu, il existe trois façons principales d’élever un nombre à la puissance en Python. Voyons leur principales différences.

Ces trois approches fonctionnent de manière presque identique. Mais il y a quelques légères différences que vous serez peut-être intéressé d’apprendre.

1. ** est généralement plus rapide
2. pow() accepte un modulo comme troisième argument
3. math.pow() utilise uniquement des nombres décimaux
4. math.pow() n’autorise pas les nombres imaginaires

Passons en revue chacune de ces principales différences de manière un peu plus détaillée.

1. Comment faire une puissance rapidement sur Python ?

Mettre à la puissance avec les 2 astérisques ** est légèrement plus rapide que pow() ou math.pow(). Ça s’explique principalement car Python ne doit pas appeler une fonction mais utilise l’opérateur directement.

Par exemple, on peut utiliser timeit dans Jupyter pour avoir directement le temps d’exécution des différentes méthodes.

## On fait boucler 100 fois ** et on prend les 5 meilleurs
%timeit -r5 -n100 2 ** 3

## On fait boucler 100 fois pow() et on prend les 5 meilleurs
%timeit -r5 -n100 pow(2, 3)

## On fait boucler 100 fois math.pow() et on prend les 5 meilleurs
import math
%timeit -r5 -n100 math.pow(2, 3)

Ce qui donne :

• 🥇 ** s’exécute en 9.54 ns
• 🥈 pow() s’exécute en 59.6 ns
• 🥉 math.pow() s’exécute en 81.1 ns

2. math.pow() pour les flottants

math.pow() traite ses arguments différemment de la fonction intégrée pow() ou de l’opérateur **. math.pow() convertit les arguments en flottants et renvoie le résultat sous forme de flottant. En comparaison, la fonction intégrée pow() et l’opérateur ** renvoient le résultat sous forme d’un nombre entier avec des entrées entières.

math.pow(4, 2) # 8.0
pow(4, 2)      # 8
4 ** 2         # 8

Si vous souhaitez élever un nombre à une puissance et obtenir le résultat sous forme de flottant, vous pouvez utiliser math.pow(). De cette façon, vous n’avez pas à convertir séparément le résultat en valeur flottante.

3. Les nombres imaginaires et math.pow()

Avec pow() et **, on peut utiliser les nombres imaginaires mais pas avec math.pow().

Par exemple :

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

La méthode math.pow() lance une erreur. Donc si vous voulez traiter des nombres imaginaires avec des puissances, utilisez pow() ou **.

4. Calculer le modulo en utilisant pow()

La fonction intégrée pow() a un cas d’utilisation spécial pour calculer a^b mod c. Pour ce faire, passez un troisième argument à l’appel pow().

Par exemple, calculons 3² mod 4 :

pow(3, 2, 4)  # donne 1

On peut aussi utiliser l’opérateur ** pour faire la même chose :

(3 ** 2) % 4

Faisons une comparaison en utilisant le module timeit et utilisons des chiffres importants :

%timeit -r5 -n100 2 ** 3 % 4
%timeit -r5 -n100 pow(2, 3, 4)

• 🥇 2 ** 3 % 4 s’exécute en 9.54 ns
• 🥈 pow(2, 3, 4) s’exécute en 100 ns

En résumé, il existe de petites différences entre pow(), math.pow() et **. Ce n’est pas utile de vous encombrer le cerveau inutilement si vous commencez avec Python. Sachez juste que vous serez mieux d’utiliser ** la quasi-totalité du temps. Et ça tombe bien, l’opérateur est plus simple à utiliser que les deux autres fonctions !

Jusqu’à présent, vous avez appris à élever un nombre à une puissance en Python avec des exposants. Mais il existe un autre cas d’utilisation important des exposants en Python qui vous aide à exprimer des nombres petits et grands.

Comment écrire 10 puissance en Python ?

L’exposant Python est également lié à un autre sujet similaire. La notation de l’exposant est un moyen d’exprimer des nombres grands ou petits avec beaucoup de zéros. Vous pouvez utiliser la notation de l’exposant e ou E pour remplacer les puissances de dix.

Comme un milliard (1 000 000 000) vaut 10⁹. Ça veut dire signifie qu’on peut l’écrire avec une notation exponentielle 1e09 en utilisant la lettre e ou E suivie du nombre de zéros :

1000000000  # Plein de 0, difficile à lire
1e09  # Beaucoup plus clair, c'est 1 milliard
1E09  # Pareil que 1e09
1_000_000_000  # Depuis Python 3.6, on peut aussi écrire les grands nombres comme ça

C’est pareil pour les petits nombres, par exemple un miliardième (0,000000001) peut être difficile à lire.

Pour désigner un petit nombre sous forme d’exposant, on peut utiliser la notation e. On peut utiliser un exposant négatif (car le nombre est inférieur à 1). Ainsi, milliard devient 1e-09.

0.000000001  # Difficile à lire
1e-09  # Facile à lire
1E-09  # Pareil que 1e-09

Aller plus loin avec Python

Félicitations ! Vous savez maintenant représenter des nombres à la puissance avec Python ! Vous savez aussi quelles sont les différences entre **, pow() et math.pow() (préférez **, vraiment 😛). Aussi, on a vu comment représenter des nombres scientifiques très grands ou très petits.

Python est un langage passionnant, j’en parle souvent sur ce blog, voici quelques articles qui vous intéresseront peut-être :

• Top 10 des meilleurs livres pour apprendre Python en 2024

• 12 des meilleurs cours Python en Français

• La fonction range en Python

• Les expressions conditionnelles en Python

• Les Boucles For en Python

• 9 idées de projets en Python pour débutants

• Python vs Java : Quel est le meilleur langage en 2024 ?