Tout ce que vous devez savoir – Real Python

By | mars 23, 2020

Formation Python

Dans cet article, vous apprendrez tout sur Python math module. Les calculs mathématiques sont une partie essentielle de la plupart des développements Python. Que vous travailliez sur un projet scientifique, une application financière ou tout autre type de programmation, vous ne pouvez tout simplement pas échapper au besoin de mathématiques.

Pour des calculs mathématiques simples en Python, vous pouvez utiliser la fonction mathématique intégrée les opérateurs, comme l'addition (+), soustraction (-), division (/) et la multiplication (*). Mais les opérations plus avancées, telles que les fonctions exponentielles, logarithmiques, trigonométriques ou de puissance, ne sont pas intégrées. Cela signifie-t-il que vous devez implémenter toutes ces fonctions à partir de zéro?

Heureusement non. Python fournit un module spécialement conçu pour les opérations mathématiques de niveau supérieur: le math module.

À la fin de cet article, vous apprendrez:

  • Qu'est-ce que le Python math module est
  • Comment utiliser math fonctions du module pour résoudre des problèmes réels
  • Quelles sont les constantes de la math module, y compris pi, tau et le nombre d'Euler
  • Quelles sont les différences entre les fonctions intégrées et math les fonctions sont
  • Quelles sont les différences entre math, cmathet NumPy sont

Une formation en mathématiques sera utile ici, mais ne vous inquiétez pas si les mathématiques ne sont pas votre point fort. Cet article vous expliquera les bases de tout ce que vous devez savoir.

Alors, commençons!

Apprendre à connaître le Python math Module

Le Python math module est une fonctionnalité importante conçue pour traiter des opérations mathématiques. Il est livré avec la version standard de Python et existe depuis le début. La plupart math Les fonctions du module sont des enveloppes minces autour des fonctions mathématiques de la plateforme C. Comme ses fonctions sous-jacentes sont écrites en CPython, le math le module est efficace et conforme à la norme C.

Le Python math module vous offre la possibilité d'effectuer des calculs mathématiques communs et utiles au sein de votre application. Voici quelques utilisations pratiques du math module:

  • Calcul des combinaisons et permutations à l'aide de factorielles
  • Calcul de la hauteur d'un poteau à l'aide de fonctions trigonométriques
  • Calcul de la désintégration radioactive à l'aide de la fonction exponentielle
  • Calcul de la courbe d'un pont suspendu à l'aide de fonctions hyperboliques
  • Résolution d'équations quadratiques
  • Simulation de fonctions périodiques, telles que les ondes sonores et lumineuses, à l'aide de fonctions trigonométriques

Depuis le math module est livré avec la version Python, vous n'avez pas besoin de l'installer séparément. L'utiliser est juste une question d'importer le module:

Vous pouvez importer le Python math module à l'aide de la commande ci-dessus. Après l'importation, vous pouvez l'utiliser immédiatement.

Constantes du math Module

Le Python math module offre une variété de prédéfinis constantes. L'accès à ces constantes présente plusieurs avantages. D'une part, vous n'avez pas à les coder en dur manuellement dans votre application, ce qui vous fait gagner beaucoup de temps. De plus, ils offrent une cohérence dans tout votre code. Le module comprend plusieurs constantes mathématiques célèbres et des valeurs importantes:

  • Pi
  • Tau
  • Numéro d'Euler
  • Infini
  • Pas un nombre (NaN)

Dans cette section, vous découvrirez les constantes et comment les utiliser dans votre code Python.

Pi

Pi (π) est le rapport de la circonférence d'un cercle (c) à son diamètre ():

π = c / d

Ce rapport est toujours le même pour n'importe quel cercle.

Pi est un nombre irrationnel, ce qui signifie qu'elle ne peut pas être exprimée sous la forme d'une simple fraction. Par conséquent, pi a un nombre infini de décimales, mais il peut être estimé à 22/7 ou 3,141.

Vous pouvez accéder à pi comme suit:

>>>

>>> math.pi
3.141592653589793

Comme vous pouvez le voir, la valeur pi est donnée à quinze décimales en Python. Le nombre de chiffres fournis dépend du compilateur C sous-jacent. Python imprime les quinze premiers chiffres par défaut, et math.pi renvoie toujours une valeur flottante.

Alors, quelles sont les façons dont pi peut vous être utile? Vous pouvez calculer la circonférence d'un cercle en utilisant 2πr, où r est le rayon du cercle:

>>>

>>> r = 3
>>> circonférence = 2 * math.pi * r
>>> F"Circonférence d'un cercle = 2 * math.pi: .4    * r    = circonférence: .4"
«Circonférence d'un cercle = 2 * 3,142 * 3 = 18,85»

Vous pouvez utiliser math.pi pour calculer la circonférence d'un cercle. Vous pouvez également calculer l'aire d'un cercle en utilisant la formule πr² comme suit:

>>>

>>> r = 5
>>> zone = math.pi * r * r
>>> F"Aire d'un cercle = math.pi: .4    * r    * r    = zone: .4"
«Aire ​​d'un cercle = 3,142 * 5 * 5 = 78,54»

Vous pouvez utiliser math.pi pour calculer l'aire et la circonférence d'un cercle. Lorsque vous effectuez des calculs mathématiques avec Python et que vous tombez sur une formule qui utilise π, il est préférable d'utiliser la valeur pi donnée par le math au lieu de coder en dur la valeur.

Tau

Tau (τ) est le rapport entre la circonférence d'un cercle et son rayon. Cette constante est égale à 2π, soit environ 6,28. Comme pi, tau est un nombre irrationnel car il est juste pi fois deux.

De nombreuses expressions mathématiques utilisent 2π, et l'utilisation de tau à la place peut aider à simplifier vos équations. Par exemple, au lieu de calculer la circonférence d'un cercle avec 2πr, on peut substituer tau et utiliser l'équation plus simple τr.

Cependant, l'utilisation du tau comme constante du cercle fait toujours l'objet de débats. Vous avez la liberté d'utiliser 2π ou τ si nécessaire.

Vous pouvez utiliser tau comme ci-dessous:

>>>

>>> math.tau
6.283185307179586

Comme math.pi, math.tau renvoie quinze chiffres et est une valeur flottante. Vous pouvez utiliser tau pour calculer la circonférence d'un cercle avec τr, où r est le rayon, comme suit:

>>>

>>> r = 3
>>> circonférence = math.tau * r
>>> F"Circonférence d'un cercle = math.tau: .4    * r    = circonférence: .4"
«Circonférence d'un cercle = 6,283 * 3 = 18,85»

Vous pouvez utiliser math.tau au lieu de 2 * math.pi pour ranger les équations qui incluent l'expression 2π.

Numéro d'Euler

Numéro d'Euler (e) est une constante qui est la base de la un algorithme naturel, une fonction mathématique couramment utilisée pour calculer les taux de croissance ou de décroissance. Comme pour pi et tau, le nombre d'Euler est un nombre irrationnel avec des décimales infinies. La valeur de e est souvent estimé à 2,718.

Le nombre d'Euler est une constante importante car il a de nombreuses utilisations pratiques, telles que le calcul de la croissance démographique au fil du temps ou la détermination des taux de désintégration radioactive. Vous pouvez accéder au numéro d'Euler à partir du math module comme suit:

>>>

>>> math.e
2.718281828459045

Comme avec math.pi et math.tau, la valeur de math.e est attribué à quinze décimales et est renvoyé sous forme de valeur flottante.

Infini

L'infini ne peut pas être défini par un nombre. C'est plutôt un concept mathématique représentant quelque chose qui est sans fin ou sans limites. L'infini peut aller dans les deux sens, positif ou négatif.

Vous pouvez utiliser l'infini dans algorithmes lorsque vous souhaitez comparer une valeur donnée à une valeur maximale ou minimale absolue. Les valeurs de l'infini positif et négatif en Python sont les suivantes:

>>>

>>> F"Infini positif = math.inf"
«Infini positif = inf»
>>> F"Infinity négatif = -math.inf"
'Infinity négatif = -inf'

L'infini n'est pas une valeur numérique. Au lieu de cela, il est défini comme math.inf. Python a introduit cette constante dans la version 3.5 comme équivalent à float ("inf"):

>>>

>>> flotte("inf") == math.inf
Vrai

Tous les deux float ("inf") et math.inf représenter le concept de l'infini, faisant math.inf supérieur à toute valeur numérique:

>>>

>>> X = 1e308
>>> math.inf > X
Vrai

Dans le code ci-dessus, math.inf est supérieur à la valeur de X, dix308 (la taille maximale d'un nombre à virgule flottante), qui est un nombre à double précision.

De même, -math.inf est plus petit que n'importe quelle valeur:

>>>

>>> y = -1e308
>>> y > -math.inf
Vrai

L'infini négatif est inférieur à la valeur de y, qui est de -10308. Aucun nombre ne peut être supérieur à l'infini ou inférieur à l'infini négatif. C’est pourquoi les opérations mathématiques avec math.inf ne modifiez pas la valeur de l'infini:

>>>

>>> math.inf + 1e308
inf
>>> math.inf / 1e308
inf

Comme vous pouvez le voir, ni l'addition ni la division ne modifient la valeur de math.inf.

Pas un nombre (NaN)

Pas un nombre, ou NaN, n'est pas vraiment un concept mathématique. Il est né dans le domaine de l'informatique comme une référence à des valeurs qui ne sont pas numériques. Une valeur NaN peut être due à des entrées non valides, ou elle peut indiquer qu'une variable qui devrait être numérique a été corrompu par des caractères de texte ou des symboles.

Il est toujours recommandé de vérifier si une valeur est NaN. Si c'est le cas, cela pourrait entraîner des valeurs non valides dans votre programme. Python a introduit la constante NaN dans la version 3.5.

Vous pouvez observer la valeur de math.nan au dessous de:

NaN n'est pas une valeur numérique. Vous pouvez voir que la valeur de math.nan est nan, la même valeur que flotteur ("nan").

Fonctions arithmétiques

La théorie du nombre est une branche des mathématiques pures, qui est l'étude des nombres naturels. La théorie des nombres traite généralement des nombres entiers positifs ou entiers.

Le Python math module fournit des fonctions qui sont utiles dans la théorie des nombres ainsi que dans théorie de la représentation, un domaine connexe. Ces fonctions vous permettent de calculer une plage de valeurs importantes, notamment les suivantes:

  • le factoriels d'un certain nombre
  • le plus grand diviseur commun de deux nombres
  • La somme de itérables

Trouver des factorielles avec Python factorielle ()

Vous avez peut-être vu des expressions mathématiques comme 7! ou 4! avant. Les points d'exclamation ne signifient pas que les chiffres sont excités. Plutôt, "!" est le factorielle symbole. Les factorielles sont utilisées pour trouver des permutations ou des combinaisons. Vous pouvez déterminer la factorielle d'un nombre en multipliant tous les nombres entiers du nombre choisi par 1.

Le tableau suivant montre les valeurs factorielles pour 4, 6 et 7:

symbole Dans les mots Expression Résultat
4! Quatre factorielle 4 x 3 x 2 x 1 24
6! Six factorielle 6 x 5 x 4 x 3 x 2 x 1 720
sept! Sept factorielle 7 x 6 x 5 x 4 x 3 x 2 x 1 5040

Vous pouvez voir dans le tableau que 4 !, ou quatre factoriels, donne la valeur 24 en multipliant la plage de nombres entiers de 4 à 1. De même, 6! et 7! donner les valeurs 720 et 5040, respectivement.

Vous pouvez implémenter une fonction factorielle en Python en utilisant l'un des nombreux outils:

  1. pour boucles
  2. Fonctions récursives
  3. math.factorial ()

Vous allez d'abord regarder une implémentation factorielle en utilisant un pour boucle. Il s'agit d'une approche relativement simple:

def fact_loop(num):
    si num < 0:
        revenir 0
    si num == 0:
        revenir 1

    factorielle = 1
    pour je dans intervalle(1, num + 1):
        factorielle = factorielle * je
    revenir factorielle

Vous pouvez également utiliser une fonction récursive pour trouver la factorielle. C'est plus compliqué mais aussi plus élégant que d'utiliser un pour boucle. Vous pouvez implémenter la fonction récursive comme suit:

def fact_recursion(num):
    si num < 0:
        revenir 0
    si num == 0:
        revenir 1

    revenir num * fact_recursion(num - 1)

L'exemple suivant illustre comment vous pouvez utiliser le pour boucles et fonctions récursives:

>>>

>>> fact_loop(sept)
5040

>>> fact_recursion(sept)
5040

Même si leurs implémentations sont différentes, leurs valeurs de retour sont les mêmes.

Cependant, la mise en œuvre de vos propres fonctions juste pour obtenir la factorielle d'un nombre prend du temps et est inefficace. Une meilleure méthode consiste à utiliser math.factorial (). Voici comment trouver la factorielle d'un nombre en utilisant math.factorial ():

>>>

>>> math.factorielle(sept)
5040

Cette approche renvoie la sortie souhaitée avec une quantité minimale de code.

factorielle () accepte uniquement des valeurs entières positives. Si vous essayez de saisir une valeur négative, vous obtiendrez un ValueError:

>>>

>>> math.factorielle(-5)
Traceback (dernier appel le plus récent):
  Fichier "", ligne 1, dans 
ValueError: factorielle () non définie pour les valeurs négatives

La saisie d'une valeur négative entraînera une ValueError en train de lire factorielle () non définie pour les valeurs négatives.

factorielle () n'accepte pas non plus les nombres décimaux. Cela vous donnera un ValueError:

>>>

>>> math.factorielle(4.3)
Traceback (dernier appel le plus récent):
  Fichier "", ligne 1, dans 
ValueError: factorial () accepte uniquement les valeurs intégrales

La saisie d'une valeur décimale entraîne ValueError en train de lire factorial () accepte uniquement les valeurs intégrales.

Vous pouvez comparer les temps d'exécution pour chacune des méthodes factorielles en utilisant timeit ():

>>>

>>> importation timeit
>>> timeit.timeit("fact_loop (10)", globales=globales())
1.063997201999996

>>> timeit.timeit("fact_recursion (10)", globales=globales())
1.815312818999928

>>> timeit.timeit("math.factorial (10)", installer="importer des maths")
0,10671788000001925

L'échantillon ci-dessus illustre les résultats de timeit () pour chacune des trois méthodes factorielles.

timeit () exécute un million de boucles à chaque exécution. Le tableau suivant compare les temps d'exécution des trois méthodes factorielles:

Type Temps d'exécution
Avec boucles 1.0640 s
Avec récursivité 1.8153 s
Avec factorielle () 0,1067 s

Comme vous pouvez le voir sur les temps d'exécution, factorielle () est plus rapide que les autres méthodes. C'est à cause de sa mise en œuvre sous-jacente C. La méthode basée sur la récursivité est la plus lente des trois. Bien que vous puissiez obtenir des horaires différents selon votre CPU, l'ordre des fonctions doit être le même.

Non seulement factorielle () plus rapide que les autres méthodes, mais elle est également plus stable. Lorsque vous implémentez votre propre fonction, vous devez coder explicitement pour cas de catastrophe comme la gestion des nombres négatifs ou décimaux. Une erreur dans la mise en œuvre pourrait entraîner des bugs. Mais lors de l'utilisation factorielle (), vous n'avez pas à vous soucier des cas de sinistre, car la fonction les gère tous. Par conséquent, il est recommandé d'utiliser factorielle () dès que possible.

Trouvez la valeur de plafond avec plafond ()

math.ceil () renverra la plus petite valeur entière supérieure ou égale au nombre donné. Si le nombre est une décimale positive ou négative, la fonction renverra la prochaine valeur entière supérieure à la valeur donnée.

Par exemple, une entrée de 5,43 renverra la valeur 6 et une entrée de -12,43 renverra la valeur -12. math.ceil () peut prendre des nombres réels positifs ou négatifs comme valeurs d'entrée et renverra toujours une valeur entière.

Lorsque vous entrez une valeur entière pour plafond (), il renverra le même numéro:

>>>

>>> math.plafond(6)
6
>>> math.plafond(-11)
-11

math.ceil () renvoie toujours la même valeur lorsqu'un entier est donné en entrée. Pour voir la vraie nature de plafond (), vous devez saisir des valeurs décimales:

>>>

>>> math.plafond(4.23)
5
>>> math.plafond(-11.453)
-11

Lorsque la valeur est positive (4.23), la fonction renvoie le prochain entier supérieur à la valeur (5). Lorsque la valeur est négative (-11.453), la fonction renvoie également le prochain entier supérieur à la valeur (-11).

La fonction renverra un Erreur-type si vous entrez une valeur qui n'est pas un nombre:

>>>

>>> math.plafond("X")
Traceback (dernier appel le plus récent):
  Fichier "", ligne 1, dans 
Erreur-type: doit être un nombre réel, pas str

Vous devez saisir un nombre pour la fonction. Si vous essayez de saisir une autre valeur, vous obtiendrez un Erreur-type.

Trouvez la valeur de plancher avec sol()

sol() renverra la valeur entière la plus proche inférieure ou égale au nombre donné. Cette fonction se comporte à l'opposé de plafond (). Par exemple, une entrée de 8,72 renverra 8 et une entrée de -12,34 renverra -13. sol() peut prendre des nombres positifs ou négatifs en entrée et renverra une valeur entière.

Si vous entrez une valeur entière, la fonction renverra la même valeur:

>>>

>>> math.sol(4)
4
>>> math.sol(-17)
-17

Comme avec plafond (), lorsque l'entrée pour sol() est un entier, le résultat sera le même que le numéro d'entrée. La sortie ne diffère de l'entrée que lorsque vous entrez des valeurs décimales:

>>>

>>> math.sol(5,532)
5
>>> math.sol(-6,432)
-sept

Lorsque vous entrez une valeur décimale positive (5,532), il renvoie l'entier le plus proche inférieur au nombre d'entrée (5). Si vous entrez un nombre négatif (-6,432), il renverra la prochaine valeur entière la plus basse (-7).

Si vous essayez d'entrer une valeur qui n'est pas un nombre, la fonction renverra un Erreur-type:

>>>

>>> math.sol("X")
Traceback (dernier appel le plus récent):
  Fichier "", ligne 1, dans 
Erreur-type: doit être un nombre réel, pas str

Vous ne pouvez pas donner de valeurs non numériques en entrée à plafond (). Cela entraînera une Erreur-type.

Tronquer des nombres avec trunc ()

Lorsque vous obtenez un nombre avec un point décimal, vous souhaiterez peut-être conserver uniquement la partie entière et éliminer la partie décimale. le math module a une fonction appelée trunc () ce qui vous permet de faire exactement cela.

La suppression de la valeur décimale est un type d'arrondi. Avec trunc (), les nombres négatifs sont toujours arrondis vers le haut vers zéro et les nombres positifs sont toujours arrondis vers le bas vers zéro.

Voici comment le trunc () la fonction arrondit les nombres positifs ou négatifs:

>>>

>>> math.trunc(12,32)
12
>>> math.trunc(-43,24)
-43

Comme vous pouvez le voir, 12,32 est arrondi vers le bas vers 0, ce qui donne le résultat 12. De la même manière, -43,24 est arrondi vers le haut vers 0, ce qui donne la valeur -43. trunc () arrondit toujours vers zéro, que le nombre soit positif ou négatif.

Lorsqu'il s'agit de nombres positifs, trunc () se comporte de la même manière que sol():

>>>

>>> math.trunc(12,32) == math.sol(12,32)
Vrai

trunc () se comporte de la même manière que sol() pour les nombres positifs. Comme vous pouvez le voir, la valeur de retour des deux fonctions est la même.

Lorsque vous traitez avec des nombres négatifs, trunc () se comporte de la même manière que plafond ():

>>>

>>> math.trunc(-43,24) == math.plafond(-43,24)
Vrai

Lorsque le nombre est négatif, sol() se comporte de la même manière que plafond (). Les valeurs de retour des deux fonctions sont identiques.

Trouvez la proximité des nombres avec Python est près()

Dans certaines situations, en particulier dans le domaine de la science des données, vous devrez peut-être déterminer si deux nombres sont proches l'un de l'autre. Mais pour ce faire, vous devez d'abord répondre à une question importante: comment proche est proche? En d'autres termes, quelle est la définition de proche?

Eh bien, Merriam-Webster vous dira que fermer signifie «proche dans le temps, l'espace, l'effet ou le degré». Pas très utile, non?

Par exemple, prenez l'ensemble de nombres suivant: 2,32, 2,33 et 2,333. Lorsque vous mesurez la proximité par deux décimales, 2,32 et 2,33 sont proches. Mais en réalité, 2,33 et 2,333 sont plus proches. La proximité est donc un concept relatif. Vous ne pouvez pas déterminer la proximité sans une sorte de seuil.

Heureusement, le math module fournit une fonction appelée est près() qui vous permet de définir votre propre seuil, ou tolérance, pour la proximité. Il revient Vrai si deux nombres sont dans votre tolérance établie pour la proximité et sinon retourne Faux.

Voyons comment comparer deux nombres en utilisant les tolérances par défaut:

  • Tolérance relative, ou rel_tol, est la différence maximale pour être considéré comme «proche» par rapport à la magnitude des valeurs d'entrée. Il s'agit du pourcentage de tolérance. La valeur par défaut est 1e-09 ou 0.000000001.
  • Tolérance absolue, ou abs_tol, est la différence maximale pour être considéré comme «proche» quelle que soit l'amplitude des valeurs d'entrée. La valeur par défaut est 0,0.

est près() reviendra Vrai lorsque la condition suivante est remplie:

abs (a-b) <= max (rel_tol * max (abs (a), abs (b)), abs_tol).

est près utilise l'expression ci-dessus pour déterminer la proximité de deux nombres. Vous pouvez remplacer vos propres valeurs et observer si deux nombres sont proches.

Dans le cas suivant, 6 et 7 ne sont pas proche:

>>>

>>> math.est près(6, sept)
Faux

Les nombres 6 et 7 ne sont pas considérés comme proches car la tolérance relative est définie pour neuf décimales. Mais si vous entrez 6,999999999 et 7 sous la même tolérance, ils sont considéré comme proche:

>>>

>>> math.est près(6.999999999, sept)
Vrai

Vous pouvez voir que la valeur 6,999999999 est à neuf décimales près de 7. Par conséquent, sur la base de la tolérance relative par défaut, 6,999999999 et 7 sont considérés comme proches.

Vous pouvez ajuster la tolérance relative comme vous le souhaitez en fonction de vos besoins. Si vous définissez rel_tol à 0,2, puis 6 et 7 sont considérés comme proches:

>>>

>>> math.est près(6, sept, rel_tol=0,2)
Vrai

Vous pouvez observer que 6 et 7 sont proches maintenant. En effet, ils sont à moins de 20% les uns des autres.

Comme avec rel_tol, vous pouvez régler abs_tol valeur selon vos besoins. Pour être considérée comme proche, la différence entre les valeurs d'entrée doit être inférieure ou égale à la valeur de tolérance absolue. Vous pouvez définir abs_tol comme suit:

>>>

>>> math.est près(6, sept, abs_tol=1.0)
Vrai
>>> math.est près(6, sept, abs_tol=0,2)
Faux

Lorsque vous définissez la tolérance absolue sur 1, les nombres 6 et 7 sont proches car la différence entre eux est égale à la tolérance absolue. Cependant, dans le deuxième cas, la différence entre 6 et 7 n'est pas inférieure ou égale à la tolérance absolue établie de 0,2.

Vous pouvez utiliser le abs_tol pour de très petites valeurs:

>>>

>>> math.est près(1, 1.0000001, abs_tol=1e-08)
Faux
>>> math.est près(1, 1.00000001, abs_tol=1e-08)
Vrai

Comme vous pouvez le voir, vous pouvez déterminer la proximité de très petits nombres avec est près. Quelques cas particuliers concernant la proximité peuvent être illustrés en utilisant nan et inf valeurs:

>>>

>>> math.est près(math.nan, 1e308)
Faux
>>> math.est près(math.nan, math.nan)
Faux

>>> math.est près(math.inf, 1e308)
Faux
>>> math.est près(math.inf, math.inf)
Vrai

Vous pouvez voir dans les exemples ci-dessus que nan n'est proche d'aucune valeur, pas même d'elle-même. D'autre part, inf n'est proche d'aucune valeur numérique, même pas très grande, mais elle est proche de lui-même.

Fonctions de puissance

La fonction de puissance prend n'importe quel nombre X comme entrée, augmente X à un certain pouvoir net retourne Xn en sortie. Python math Le module fournit plusieurs fonctions liées à l'alimentation. Dans cette section, vous découvrirez les fonctions de puissance, les fonctions exponentielles et les fonctions de racine carrée.

Calculez la puissance d'un nombre avec pow ()

Les fonctions de puissance ont la formule suivante où la variable X est la base, la variable n est le pouvoir, et une peut être une constante:

Fonction de puissance
Fonction de puissance

Dans la formule ci-dessus, la valeur de la base X est élevé au pouvoir de n.

Vous pouvez utiliser math.pow () pour obtenir la puissance d'un nombre. Il y a une fonction intégrée, pow (), c'est différent de math.pow (). Vous apprendrez la différence plus loin dans cette section.

math.pow () prend deux paramètres comme suit:

>>>

>>> math.pow(2, 5)
32,0
>>> math.pow(5, 2.4)
47,59134846789696

Le premier argument est la valeur de base et le deuxième argument est la valeur de puissance. Vous pouvez donner un entier ou une valeur décimale en entrée et la fonction renvoie toujours une valeur flottante. Il existe certains cas particuliers définis dans math.pow ().

Lorsque la base 1 est élevée à la puissance d'un nombre quelconque n, elle donne le résultat 1.0:

>>>

>>> math.pow(1.0, 3)
1.0

Lorsque vous augmentez la valeur de base 1 à n'importe quelle valeur de puissance, vous obtiendrez toujours 1,0 comme résultat. De même, tout nombre de base élevé à la puissance de 0 donne le résultat 1.0:

>>>

>>> math.pow(4, 0,0)
1.0
>>> math.pow(-4, 0,0)
1.0

Comme vous pouvez le voir, tout nombre élevé à la puissance de 0 donnera 1,0 comme résultat. Vous pouvez voir ce résultat même si la base est nan:

>>>

>>> math.pow(math.nan, 0,0)
1.0

Un zéro élevé à la puissance d'un nombre positif donnera 0,0 comme résultat:

>>>

>>> math.pow(0,0, 2)
0,0
>>> math.pow(0,0, 2.3)
0,0

Mais si vous essayez d'élever 0,0 à une puissance négative, le résultat sera un ValueError:

>>>

>>> math.pow(0,0, -2)
Traceback (dernier appel le plus récent):
  Fichier "", ligne 1, dans 
ValueError: erreur de domaine mathématique

le ValueError se produit uniquement lorsque la base est 0. Si la base est un autre nombre que 0, la fonction renverra une valeur de puissance valide.

Excepté math.pow (), il existe deux façons intégrées de trouver la puissance d'un nombre en Python:

  1. x ** y
  2. pow ()

La première option est simple. Vous l'avez peut-être déjà utilisé une ou deux fois. Le type de retour de la valeur est déterminé par les entrées:

>>>

>>> 3 ** 2
9
>>> 2 ** 3.3
9.849155306759329

Lorsque vous utilisez des entiers, vous obtenez une valeur entière. Lorsque vous utilisez des valeurs décimales, le type de retour devient une valeur décimale.

La deuxième option est une fonction intégrée polyvalente. Vous n'avez pas besoin d'utiliser d'importations pour l'utiliser. Le intégré pow () La méthode a trois paramètres:

  1. le base nombre
  2. le Puissance nombre
  3. le module nombre

Les deux premiers paramètres sont obligatoires, tandis que le troisième paramètre est facultatif. Vous pouvez entrer des nombres entiers ou décimaux et la fonction renverra le résultat approprié en fonction de l'entrée:

>>>

>>> pow(3, 2)
9
>>> pow(2, 3.3)
9.849155306759329

Le intégré pow () a deux arguments requis qui fonctionnent de la même manière que la base et la puissance du x ** y syntaxe. le pow () La méthode a également un troisième paramètre facultatif: module. Ce paramètre est souvent utilisé en cryptographie. Intégré pow () avec le paramètre de module optionnel est équivalent à l'équation (x ** y)% z. La syntaxe Python ressemble à ceci:

>>>

>>> pow(32, 6, 5)
4
>>> (32 ** 6) % 5 == pow(32, 6, 5)
Vrai

pow () élève la base (32) à la puissance (6), puis la valeur de résultat est modulo divisé par le nombre de modules (5). Dans ce cas, le résultat est 4. Vous pouvez remplacer vos propres valeurs et voir que les deux pow () et l'équation donnée donne les mêmes résultats.

Même si les trois méthodes de calcul de la puissance font la même chose, il existe certaines différences de mise en œuvre entre elles. Les temps d'exécution de chaque méthode sont les suivants:

>>>

>>> timeit.timeit("10 ** 308")
1.0078728999942541

>>> timeit.timeit("pow (10, 308)")
1.047615700008464

>>> timeit.timeit("math.pow (10, 308)", installer="importer des maths")
0,1837239999877056

Le tableau suivant compare les temps d'exécution des trois méthodes mesurés par timeit ():

Type Temps d'exécution
x ** y 1.0079 s
pow (x, y) 1.0476 s
math.pow (x, y) 0,1837 s

Vous pouvez observer sur le tableau que math.pow () est plus rapide que les autres méthodes et intégré pow () est le plus lent.

La raison de l'efficacité de math.pow () est la façon dont il est mis en œuvre. Il repose sur le langage C sous-jacent. D'autre part, pow () et x ** y utiliser la propre implémentation de l'objet d'entrée ** opérateur. cependant, math.pow () ne peut pas gérer les nombres complexes (ce qui sera expliqué dans une section ultérieure), tandis que pow () et ** pouvez.

Trouvez l'exposant naturel avec exp ()

Vous avez découvert les fonctions d'alimentation dans la section précédente. Avec les fonctions exponentielles, les choses sont un peu différentes. Au lieu que la base soit la variable, la puissance devient la variable. Cela ressemble à ceci:

Fonction exponentielle générale
Fonction exponentielle générale

Ici une peut être une constante, et X, qui est la valeur de puissance, devient la variable.

Alors, quelle est la particularité des fonctions exponentielles? La valeur de la fonction croît rapidement à mesure que X la valeur augmente. Si la base est supérieure à 1, alors la fonction augmente continuellement en valeur comme X augmente. Une propriété particulière des fonctions exponentielles est que la pente de la fonction augmente également X augmente.

Vous avez découvert le numéro d'Euler dans une section précédente. C'est la base du logarithme naturel. Il joue également un rôle avec la fonction exponentielle. Lorsque le nombre d'Euler est incorporé dans la fonction exponentielle, il devient le fonction exponentielle naturelle:

Fonction exponentielle naturelle
Fonction exponentielle naturelle

Cette fonction est utilisée dans de nombreuses situations réelles. Vous avez peut-être entendu parler du terme croissance exponentielle, qui est souvent utilisé en relation avec la croissance de la population humaine ou les taux de décroissance radioactive. Ces deux éléments peuvent être calculés à l'aide de la fonction exponentielle naturelle.

Le Python math module fournit une fonction, exp (), qui vous permet de calculer l'exposant naturel d'un nombre. Vous pouvez trouver la valeur comme suit:

>>>

>>> math.exp(21)
1318815734.4832146
>>> math.exp(-1.2)
0,30119421191220214

Le numéro d'entrée peut être positif ou négatif et la fonction renvoie toujours une valeur flottante. Si le nombre n'est pas une valeur numérique, la méthode renverra un Erreur-type:

>>>

>>> math.exp("X")
Traceback (dernier appel le plus récent):
  Fichier "", ligne 1, dans 
Erreur-type: doit être un nombre réel, pas str

Comme vous pouvez le voir, si l'entrée est une valeur de chaîne, la fonction renvoie un Erreur-type en train de lire doit être un nombre réel, pas str.

Vous pouvez également calculer l'exposant en utilisant le math.e ** x expression ou en utilisant pow (math.e, x). Les temps d'exécution de ces trois méthodes sont les suivants:

>>>

>>> timeit.timeit("math.e ** 308", installer="importer des maths")
0,17853009998701513

>>> timeit.timeit("pow (math.e, 308)", installer="importer des maths")
0,21040189999621361

>>> timeit.timeit("math.exp (308)", installer="importer des maths")
0.125878200007719

Le tableau suivant compare les temps d'exécution des méthodes ci-dessus mesurés par timeit ():

Type Temps d'exécution
e ** x 0,1785 s
pow (e, x) 0,2104 s
math.exp (x) 0,1259 s

Tu peux voir ça math.exp () est plus rapide que les autres méthodes et pow (e, x) est le plus lent. Il s'agit du comportement attendu en raison de l'implémentation C sous-jacente du math module.

Il convient également de noter que e ** x et pow (e, x) retourner les mêmes valeurs, mais exp () renvoie une valeur légèrement différente. Cela est dû aux différences de mise en œuvre. La documentation Python note que exp () est plus précis que les deux autres méthodes.

Exemple pratique avec exp ()

La désintégration radioactive se produit lorsqu'un atome instable perd de l'énergie en émettant un rayonnement ionisant. Le taux de désintégration radioactive est mesuré en utilisant la demi-vie, qui est le temps nécessaire à la moitié de la quantité de noyau parent pour se désintégrer. Vous pouvez calculer le processus de désintégration à l'aide de la formule suivante:

Équation de désintégration radioactive d'un élément radioactif
Équation de désintégration radioactive

Vous pouvez utiliser la formule ci-dessus pour calculer la quantité restante d'un élément radioactif après un certain nombre d'années. Les variables de la formule donnée sont les suivantes:

  • N (0) est la quantité initiale de la substance.
  • NT) est la quantité qui reste et qui n'a pas encore pourri après un certain temps (t).
  • T est la demi-vie de la quantité en décomposition.
  • e est le numéro d'Euler.

La recherche scientifique a identifié la demi-vie de tous les éléments radioactifs. Vous pouvez substituer des valeurs à l'équation pour calculer la quantité restante de toute substance radioactive. Essayons ça maintenant.

Le radio-isotope strontium-90 a une demi-vie de 38,1 ans. Un échantillon contient 100 mg de Sr-90. Vous pouvez calculer les milligrammes restants de Sr-90 après 100 ans:

>>>

>>> demi vie = 38,1
>>> initiale = 100
>>> temps = 100
>>> restant = initiale * math.exp(-0,693 * temps / demi vie)
>>> F"Quantité restante de Sr-90: restant"
«Quantité restante de Sr-90: 16.22044604811303»

Comme vous pouvez le voir, la demi-vie est fixée à 38,1 et la durée est fixée à 100 ans. Vous pouvez utiliser math.exp pour simplifier l'équation. En substituant les valeurs à l'équation, vous pouvez constater qu'après 100 ans, 16,22 mg de Sr-90 reste.

Fonctions logarithmiques

Fonctions logarithmiques peut être considéré comme l'inverse des fonctions exponentielles. Ils sont notés sous la forme suivante:

Fonction logarithmique générale
Fonction logarithmique générale

Ici une est la base du logarithme, qui peut être n'importe quel nombre. Vous avez découvert les fonctions exponentielles dans une section précédente. Les fonctions exponentielles peuvent être exprimées sous forme de fonctions logarithmiques et vice versa.

Journal naturel Python avec Journal()

le un algorithme naturel d'un nombre est son logarithme à la base de la constante mathématique eou le numéro d'Euler:

Fonction logarithmique naturelle
Fonction logarithmique naturelle

Comme pour la fonction exponentielle, le logarithme naturel utilise la constante e. Il est généralement représenté par f (x) = ln (x), où e est implicite.

Vous pouvez utiliser le journal naturel de la même manière que vous utilisez la fonction exponentielle. Il est utilisé pour calculer des valeurs telles que le taux de croissance de la population ou le taux de décroissance radioactive dans les éléments.

Journal() a deux arguments. Le premier est obligatoire et le second est facultatif. Avec un argument, vous pouvez obtenir le journal naturel (à la base e) du numéro d'entrée:

>>>

>>> math.Journal(4)
1.3862943611198906
>>> math.Journal(3.4)
1.2237754316221157

Cependant, la fonction renvoie un ValueError si vous entrez un nombre non positif:

>>>

>>> math.Journal(-3)
Traceback (dernier appel le plus récent):
  Fichier "", ligne 1, dans 
ValueError: erreur de domaine mathématique

Comme vous pouvez le voir, vous ne pouvez pas saisir de valeur négative dans Journal(). En effet, les valeurs de journal ne sont pas définies pour les nombres négatifs et zéro.

Avec deux arguments, vous pouvez calculer le journal du premier argument à la base du deuxième argument:

>>>

>>> math.Journal(math.pi, 2)
1.651496129472319
>>> math.Journal(math.pi, 5)
0,711260668712669

Vous pouvez voir comment la valeur change lorsque la base de journaux est modifiée.

Comprendre log2 () et log10 ()

Le Python math Le module fournit également deux fonctions distinctes qui vous permettent de calculer les valeurs de journal à la base de 2 et 10:

  1. log2 () est utilisé pour calculer la valeur logarithmique de la base 2.
  2. log10 () est utilisé pour calculer la valeur logarithmique de la base 10.

Avec log2 () vous pouvez obtenir la valeur du journal à la base 2:

>>>

>>> math.log2(math.pi)
1.6514961294723187
>>> math.Journal(math.pi, 2)
1.651496129472319

Les deux fonctions ont le même objectif, mais la documentation Python note que log2 () est plus précis que l'utilisation journal (x, 2).

Vous pouvez calculer la valeur de log d'un nombre à base 10 avec log10 ():

>>>

>>> math.log10(math.pi)
0,4971498726941338
>>> math.Journal(math.pi, dix)
0,4971498726941338

La documentation Python mentionne également que log10 () est plus précis que journal (x, 10) même si les deux fonctions ont le même objectif.

Exemple pratique avec Natural Log

Dans une section précédente, vous avez vu comment utiliser math.exp () pour calculer la quantité restante d'un élément radioactif après une certaine période de temps. Avec math.log (), vous pouvez trouver la demi-vie d'un élément radioactif inconnu en mesurant la masse à un intervalle. L'équation suivante peut être utilisée pour calculer la demi-vie d'un élément radioactif:

Équation de demi-vie d'un élément radioactif
Équation de désintégration radioactive

En réorganisant la formule de désintégration radioactive, vous pouvez faire la demi-vie (T) l'objet de la formule. Les variables de la formule donnée sont les suivantes:

  • T est la demi-vie de la quantité en décomposition.
  • N (0) est la quantité initiale de la substance.
  • NT) is the quantity that remains and has not yet decayed after a period of time (t).
  • ln is the natural log.

You can substitute the known values to the equation to calculate the half-life of a radioactive substance.

For example, imagine you are studying an unidentified radioactive element sample. When it was discovered 100 years ago, the sample size was 100mg. After 100 years of decay, only 16.22mg is remaining. Using the formula above, you can calculate the half-life of this unknown element:

>>>

>>> initial = 100
>>> remaining = 16.22
>>> temps = 100
>>> half_life = (-0.693 * temps) / math.log(remaining / initial)
>>> f"Half-life of the unknown element: half_life"
'Half-life of the unknown element: 38.09942398335152'

You can see that the unknown element has a half-life of roughly 38.1 years. Based on this information, you can identify the unknown element as strontium-90.

Other Important math Module Functions

The Python math module has many useful functions for mathematical calculations, and this article only covered a few of them in depth. In this section, you will briefly learn about some of the other important functions available in the math module.

Calculate the Greatest Common Divisor

le greatest common divisor (GCD) of two positive numbers is the largest positive integer that divides both numbers without a remainder.

For example, the GCD of 15 and 25 is 5. You can divide both 15 and 25 by 5 without any remainder. There is no greater number that does the same. If you take 15 and 30, then the GCD is 15 because both 15 and 30 can be divided by 15 without a remainder.

You don’t have to implement your own functions to calculate GCD. The Python math module provides a function called math.gcd() that allows you to calculate the GCD of two numbers. You can give positive or negative numbers as input, and it returns the appropriate GCD value. You can’t input a decimal number, however.

Calculate the Sum of Iterables

If you ever want to find the sum of the values of an iterable without using a loop, then math.fsum() is probably the easiest way to do so. You can use iterables such as arrays, tuples, or lists as input and the function returns the sum of the values. A built-in function called sum() lets you calculate the sum of iterables as well, but fsum() is more accurate than sum(). You can read more about that in the documentation.

Calculate the Square Root

The square root of a number is a value that, when multiplied by itself, gives the number. Vous pouvez utiliser math.sqrt() to find the square root of any positive real number (integer or decimal). The return value is always a float value. The function will throw a ValueError if you try to enter a negative number.

Convert Angle Values

In real-life scenarios as well as in mathematics, you often come across instances where you have to measure angles to perform calculations. Angles can be measured either by degrees or by radians. Sometimes you have to convert degrees to radians and vice versa. le math module provides functions that let you do so.

If you want to convert degrees to radians, then you can use math.radians(). It returns the radian value of the degree input. Likewise, if you want to convert radians to degrees, then you can use math.degrees().

Calculate Trigonometric Values

Trigonometry is the study of triangles. It deals with the relationship between angles and the sides of a triangle. Trigonometry is mostly interested in right-angled triangles (in which one internal angle is 90 degrees), but it can also be applied to other types of triangles. The Python math module provides very useful functions that let you perform trigonometric calculations.

You can calculate the sine value of an angle with math.sin(), the cosine value with math.cos(), and the tangent value with math.tan(). le math module also provides functions to calculate arc sine with math.asin(), arc cosine with math.acos(), and arc tangent with math.atan(). Finally, you can calculate the hypotenuse of a triangle using math.hypot().

New Additions to the math Module in Python 3.8

With the release of Python version 3.8, a few new additions and changes have been made to the math module. The new additions and changes are as follows:

  • comb(n, k) returns the number of ways to choose k items from n items without repetition and without particular order.

  • perm(n, k) returns the number of ways to choose k items from n items without repetition and with order.

  • isqrt() returns the integer square root of a non-negative integer.

  • prod() calculates the product of all of the elements in the input iterable. As with fsum(), this method can take iterables such as arrays, lists, or tuples.

  • dist() returns the Euclidean distance between two points p et q, each given as a sequence (or iterable) of coordinates. The two points must have the same dimension.

  • hypot() now handles more than two dimensions. Previously, it supported a maximum of two dimensions.

cmath contre math

UNE complex number is a combination of a real number and an imaginary number. It has the formula of a + bi, where une is the real number and bi is the imaginary number. Real and imaginary numbers can be explained as follows:

  • UNE real number is literally any number you can think of.
  • Un imaginary number is a number that gives a negative result when squared.

A real number can be any number. For example, 12, 4.3, -19.0 are all real numbers. Imaginary numbers are shown as je. The following image shows an example of a complex number:

Complex Number
Complex Number

In the example above, sept is the real number and 3i is the imaginary number. Complex numbers are mostly used in geometry, calculus, scientific calculations, and especially in electronics.

The functions of the Python math module aren’t equipped to handle complex numbers. However, Python provides a different module that can specifically deal with complex numbers, the cmath module. The Python math module is complemented by the cmath module, which implements many of the same functions but for complex numbers.

You can import the cmath module as follows:

Depuis le cmath module is also packaged with Python, you can import it the same way you imported the math module. Before you work with the cmath module, you have to know how to define a complex number. You can define a complex number as follows:

>>>

>>> c = 2 + 3j
>>> c
(2+3j)

>>> type(c)

As you can see, you can determine that a number is indeed complex by using type().

Python also provides a special built-in function called complex() that lets you create complex numbers. Vous pouvez utiliser complex() comme suit:

>>>

>>> c = complex(2, 3)
>>> c
(2+3j)

>>> type(c)

You can use either method to create complex numbers. Vous pouvez également utiliser le cmath module to calculate mathematical functions for complex numbers as follows:

>>>

>>> cmath.sqrt(c)
(1.8581072140693775+0.6727275964137814j)

>>> cmath.log(c)
(1.3622897515267103+0.6947382761967031j)

>>> cmath.exp(c)
(-16.091399670844+12.02063434789931j)

This example shows you how to calculate the square root, logarithmic value, and exponential value of a complex number. You can read the documentation if you want to learn more about the cmath module.

NumPy vs math

Several notable Python libraries can be used for mathematical calculations. One of the most prominent libraries is Numerical Python, or NumPy. It is mainly used in scientific computing and in data science fields. Unlike the math module, which is part of the standard Python release, you have to install NumPy in order to work with it.

The heart of NumPy is the high-performance N-dimensional (multidimensional) array data structure. This array allows you to perform mathematical operations on an entire array without looping over the elements. All of the functions in the library are optimized to work with the N-dimensional array objects.

Both the math module and the NumPy library can be used for mathematical calculations. NumPy has several similarities with the math module. NumPy has a subset of functions, similar to math module functions, that deal with mathematical calculations. Both NumPy and math provide functions that deal with trigonometric, exponential, logarithmic, hyperbolic and arithmetic calculations.

There are also several fundamental differences between math and NumPy. The Python math module is geared more towards working with scalar values, whereas NumPy is better suited for working with arrays, vectors, and even matrices.

When working with scalar values, math module functions can be faster than their NumPy counterparts. This is because the NumPy functions convert the values to arrays under the hood in order to perform calculations on them. NumPy is much faster when working with N-dimensional arrays because of the optimizations for them. Except for fsum() et prod(), les math module functions can’t handle arrays.

Conclusion

In this article, you learned about the Python math module. The module provides useful functions for performing mathematical calculations that have many practical applications.

In this article you’ve learned:

  • What the Python math module is
  • How to use math functions with practical examples
  • What the constants of the math module, including pi, tau, and Euler’s number are
  • What the differences between built-in functions and math functions are
  • What the differences between math, cmath, and NumPy are

Understanding how to use the math functions is the first step. Now it’s time to start applying what you learned to real-life situations. If you have any questions or comments, then please leave them in the comments section below.