Un guide de la fonction pow() de Python

Les exposants sont des nombres en exposant qui décrivent combien de fois vous voulez multiplier un nombre par lui-même. Le calcul d'une valeur élevée à la puissance d'une autre valeur est une opération fondamentale en mathématiques appliquées telles que la finance, l'apprentissage automatique, les statistiques et la science des données. Ce tutoriel vous montre comment le faire en Python !

Définition

Pour pow(x, y) , le pow() la fonction renvoie la valeur de x élevé à la puissance y . Il remplit la même fonction que l'opérateur électrique ** , soit x**y , mais diffère en ce qu'il est fourni avec un argument facultatif appelé mod.

Exemples sans mod

>>> pow(5, 2)
25
>>> pow(-3, 3)
-27
>>> pow(2, -2)
0.25

Paramètres et syntaxe

Le pow() la fonction inclut deux arguments obligatoires, base et exp , et un argument facultatif, mod , dont la valeur par défaut est None . Tous les arguments doivent être de type numérique.

Valeur de retour : La sortie de base élevé à la puissance exp et sera un type de données numérique, int, float ou complexe, selon ce que vous saisissez.

Utiliser la fonction pow() sans l'argument mod

Lors de l'utilisation du pow(x, y) fonction sans l'argument optionnel mod, il effectuera la même opération que l'opérateur power x**y , élevant x à la puissance y .

Comparaison des deux méthodes

>>> pow(6, 4)
1296
>>> 6 ** 4
1296

Le pow() La fonction accepte tous les types de données numériques, c'est-à-dire int, float et même les nombres complexes. En général, la valeur de retour dépendra des types de données que vous entrez. L'exemple ci-dessus montre que les deux arguments sont de type int, par conséquent, un type int est renvoyé. Cependant, si vous deviez utiliser à la place un nombre flottant comme un ou les deux arguments, la fonction renverra automatiquement un type flottant.

Exemples utilisant des types flottants

>>> pow(3.0, 4)
81.0
>>> pow(4.5, 2.3)
31.7971929089206

Comme pour les entrées de type flottant conduisant à des sorties flottantes, le même raisonnement s'applique aux nombres complexes. Si vous entrez un nombre complexe comme un ou les deux arguments, un nombre complexe sera renvoyé.

Exemple utilisant des nombres complexes

>>> pow(4+2j, 3)
(16+88j)

Le type de retour dépendra également du fait que vos arguments soient non négatifs ou négatifs, comme indiqué dans le tableau ci-dessous.

Exemples de valeurs de retour avec différents types d'entrée

>>> pow(7, 2)
49
>>> pow(4, -5)
0.0009765625
>>> pow(-6, 3)
-216
>>> pow(-9, -4)
0.00015241579027587258

Utiliser la fonction pow() avec un argument mod

Qu'est-ce qui définit le pow() fonction en dehors du ** L'opérateur est son troisième argument facultatif, mod , ce qui vous permet d'effectuer une opération modulo dans la fonction.

Le processus des opérations lors de l'utilisation de l'argument mod est le suivant :

Si nous avons pow(x, y, z) , la fonction effectue d'abord la tâche d'élever x à la puissance y puis ce résultat est utilisé pour effectuer la tâche modulo par rapport à z . Ce serait l'équivalent de (x**y) % z .

Exemples utilisant le mod

>>> pow(14, 7, 5)
4
>>> pow(-8, 3, 5)
3
>>> pow(2, 4, -3)
-2

La règle générale pour l'utilisation de l'argument mod est que toutes les valeurs doivent être de type entier, le exp l'argument doit être non négatif et l'argument mod doit être différent de zéro. Cependant, Python 3.8 est désormais livré avec la fonctionnalité de calcul des inverses modulaires. Dans ce cas, le exp l'argument peut être négatif, à condition que base soit relativement premier à mod, c'est-à-dire que le seul diviseur entier commun de base et mod est 1.

Ainsi, lors de l'utilisation du pow() fonction avec exp négatif , la fonction s'exécutera comme suit :

pow(inv_base, -exp, mod)

En d'autres termes, la fonction calculera d'abord l'inverse modulaire de base et mod, puis ce résultat sera utilisé dans le pow() fonction comme base à calculer normalement, l'argument exp étant converti en sa contrepartie non négative.

Exemple d'inverse modulaire

>>> pow(87, -1, 25)
23

Dans cet exemple, l'inverse modulaire droit est calculé car inv_base sera élevé à la puissance 1.

Exemple d'inverse modulaire lorsque exp n'est pas -1

>>> pow(34, -5, 19)
10
# The modular inverse of 34 mod 19 is 14, therefore, we end up with the function pow(14, 5, 19)
>>> pow(14, 5, 19)
10

Calculer le nème racine d'un nombre en utilisant pow()

Malheureusement, Python n'a pas de fonction intégrée pour calculer le nième racine d'un nombre. Le module mathématique n'a qu'une fonction pour calculer les racines carrées, math.sqrt() , par conséquent, nous devons faire preuve de créativité afin de calculer nième racines.

Nous savons que nx est équivalent à x1n . Ainsi, en utilisant ces connaissances, nous pouvons calculer la nième racine en Python en utilisant soit pow(x, (1/n)) ou x**(1/n) .

Exemples de calcul de nième racines

>>> pow(625, (1/4))
4.0
>>> 729**(1/3)
8.999999999999998

Notez que l'exécution d'un nième le calcul racine renverra toujours un flottant lorsqu'il n'utilise pas de nombres complexes. Étant donné que le type flottant de Python fonctionne sur des approximations, il renverra souvent l'approximation plutôt que le nombre exact, même lorsqu'une réponse exacte est possible. Ceci est démontré dans le deuxième exemple ci-dessus.

Lors du calcul de la nième racine d'un nombre négatif, la valeur de retour sera un nombre complexe, qu'un nombre entier soit possible ou non.

Exemples de calcul de nième racines des bases négatives

>>> pow(-16, (1/2))
(2.4492935982947064e-16+4j)
>>> pow(-27, (1/3))
(1.5000000000000004+2.598076211353316j)

Nous nous attendrions à ce que le deuxième exemple ci-dessus, la racine cubique de -27, donne -3, mais à la place, nous obtenons un nombre complexe. En effet, Python renvoie la racine principale plutôt que la vraie racine. Pour une explication de ces différents types de racines, vous pouvez consulter le théorème fondamental de l'algèbre.

Fonction math.pow()

Dans le module mathématique de Python, il existe une fonction similaire appelée math.pow() . Pour l'utiliser, nous devons d'abord importer la fonction mathématique, donc le pow() intégré fonction sera très légèrement plus rapide. La principale différence entre les deux fonctions est que math.pow() n'autorise pas l'argument optionnel mod et il renverra toujours un flottant. Donc, si vous voulez vous assurer que vous obtenez un résultat flottant, math.pow() est une meilleure option.

Exemple d'utilisation de math.pow()

>>> import math
>>> math.pow(9, 5)
59049.0

Quand utiliser la fonction pow() vs quand utiliser l'opérateur **

Lorsque vous décidez d'utiliser le pow() fonction ou le ** opérateur, le facteur le plus important à considérer serait l'efficacité de votre code. Nous pouvons utiliser le timeit.timeit() fonction du timeit module pour savoir à quelle vitesse Python exécute notre code.

Exemples d'utilisation de timeit avec des nombres simples

>>> import timeit
>>> timeit.timeit('pow(5, 2)')
0.25059129999863217
>>> timeit.timeit('5**2')
0.008814800001346157

Lors d'un calcul de puissance simple, le ** l'opérateur semble être beaucoup plus rapide.

Exemples utilisant le modulo

>>> timeit.timeit('pow(52, 2, 4)')
0.7482693000001746
>>> timeit.timeit('52**2 % 4')
0.012026999998852261

La même chose est vraie même lorsque nous incluons une opération modulo.

Cependant, lorsque nous voulons effectuer des opérations de puissance avec de très grands nombres, le pow() est beaucoup plus rapide, ce qui montre que la puissance du pow() fonction réside dans l'exécution de calculs plus longs.

Exemples utilisant de grands nombres

>>> timeit.timeit('pow(5234, 2341, 124)')
0.9020593000004737
>>> timeit.timeit('5234**2341 % 124')
152.56075580000106

Ici le pow() la fonction est extrêmement rapide par rapport au ** opérateur. Par conséquent, nous pouvons généraliser ces résultats en disant que lorsque vous souhaitez effectuer des calculs courts et simples, l'opérateur ** est la meilleure option, cependant, si vos opérations impliquent de très grands nombres, le pow() la fonction est beaucoup plus efficace.