Apprenez à coder gratuitement en moins de 30 jours !   📕

Comment calculer puissance d'un nombre en python ?

Article mis à jour le mardi 7 février 2023.

Comment faire une puissance 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 tader 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 24. 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 :

Méthode Description Exemple Résultat
1. a ** b élève a à la puissance de b 2 ** 4 16
2. pow(a,b) élève a à la puissance de b pow(3,4) 81
3. math.pow(a,b) élève a à la puissance de b math.pow(5,2) 25

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 flottants
  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 appelé une fonction mais utilise l’opérateur directement.

Par exemple, on peut utiliser timeit dans Jupyter pour avoir directement le temps d’execution 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’éxécute en 9.54 ns
  • 🥈 pow() s’éxécute en 59.6 ns
  • 🥉 math.pow() s’éxé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 ab mod c. Pour ce faire, passez un troisième argument à l’appel pow().

Par exemple, calculons 32 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’éxécute en 9.54 ns
  • 🥈 pow(2, 3, 4) s’éxé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 109. Ç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 millard
1E09  # Pareil que 1e09
1_000_000_000  # Depuis Python 3.6, on peut aussi écire 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élicitation ! 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 :

APPRENEZ GRATUITEMENT À CODER EN MOINS DE 30 JOURS !
Vous voulez apprendre la programmation ?
Recevez mon ebook GRATUIT : "9 astuces pour apprendre à coder".
Découvrez si le code est fait pour vous !
Comment Coder

Je m'appelle Thomas. J'ai commencé à coder dans mon enfance. Depuis ma sortie de la première promo de l'École 42, j'ai développé des centaines d'applications et sites web. Sur ce blog, je vous donne les meilleurs conseils et astuces pour apprendre comment apprendre à coder efficacement.