Modules mathématiques en Python décimal et fractions

Même les opérations mathématiques les plus élémentaires peuvent parfois donner un résultat erroné. Cela est dû à la limitation de la valeur exacte de certains nombres. Vous pouvez surmonter ces limitations en utilisant le module décimal en Python. De même, ni le math ni le cmath module que nous avons appris dans notre dernier tutoriel peut nous aider à faire de l'arithmétique basée sur des fractions. Cependant, le module fractions en Python fait exactement cela.

Dans ce tutoriel, vous allez apprendre à connaître ces deux modules et les différentes fonctions qu’ils offrent.. 

Pourquoi avons-nous besoin d'un module décimal?

Vous vous demandez probablement pourquoi nous avons besoin d'un module pour faire de l'arithmétique de base avec des nombres décimaux alors que nous pouvons déjà faire la même chose en utilisant des flottants.

Avant de répondre à cette question, je veux que vous deviniez la valeur de sortie si vous tapez 0,1 + 0,2 dans la console Python. Si vous avez deviné que la sortie devrait être 0.3, vous serez surpris lorsque vous extrayerez le résultat réel, qui est 0.30000000000000004. Vous pouvez essayer un autre calcul comme 0,05 + 0,1 et vous obtiendrez 0.15000000000000002. 

Pour comprendre ce qui se passe ici, essayez de représenter 1/3 sous forme décimale, et vous remarquerez que le nombre ne se termine pas en base 10. De même, certains nombres tels que 0,1 ou 1/10 ne se terminent pas en base 2. Comme ces nombres doivent encore être représentés, quelques des approximations sont faites lors de leur stockage, ce qui entraîne ces erreurs.

Le nombre 0.30000000000000004 est en réalité très proche de 0,3, nous pouvons donc nous en sortir avec cette approximation la plupart du temps. Malheureusement, cette approximation ne réduira pas les résultats lorsque vous simulez un lancement d'un satellite ou que vous traitez avec de l'argent. Un autre problème avec ces approximations est que les erreurs continuent à s'accumuler. 

Pour obtenir des résultats précis, comme ceux auxquels nous sommes habitués lorsque nous effectuons des calculs à la main, nous avons besoin de quelque chose qui prenne en charge une arithmétique rapide, correctement arrondie et décimale, et décimal le module fait exactement cela.

Utiliser le module décimal

Avant d'utiliser le module, vous devez d'abord l'importer. Après cela, vous pouvez créer des décimales à partir d'entiers, de chaînes, de flottants ou de n-uplets. Lorsque la décimale est construite à partir d'un entier ou d'un float, il y a une conversion exacte de la valeur de ce nombre. Regardez les exemples ci-dessous pour voir ce que je veux dire:

décimale décimale (121) # renvoie décimale ('121') décimale (0,05) # renvoie décimale ('0.05000000000000000277555756') décimale ('0,05') # renvoie décimale ('0,05') décimale ((0, (8, 3, 2, 4), -3)) # renvoie Decimal ('8.324') Decimal ((1, (8, 3, 2, 4), -1)) # renvoie Decimal ('- 832,4')

Comme vous pouvez le voir, la valeur de Décimal (0.05) est légèrement différent de Décimal ('0.05'). Cela signifie que lorsque vous ajoutez 0,05 et 0,1, vous devez utiliser decimal.Decimal ('0.05') et decimal.Decimal ('0.1') construire les décimales.

à partir de l'importation décimale décimale décimale ('0,05') + décimale ('0,1') # renvoie décimale ('0,15') décimale (0,05) + décimale (0,1) # renvoie décimale ('0,1500000000000000083266726847')

Maintenant que vous pouvez effectuer diverses opérations sur les décimales, vous pouvez contrôler la précision ou l’arrondi de ces opérations. Cela peut être fait en utilisant le getcontext () une fonction. Cette fonction vous permet d'obtenir et de définir la valeur des options de précision et d'arrondi, entre autres. 

N'oubliez pas que l'arrondi et la précision entrent en jeu uniquement pendant les opérations arithmétiques et non pendant la création des décimales..

import décimal à partir de décimal import décimal, getcontext Decimal (1) / Decimal (13) # renvoie Decimal ('0.07692307692307692307692') getcontext (). prec = 10 décimal (0.03) # renvoie Decimal ('0.029999999999999999988897767537' ') (7) # retourne Decimal ('0.1428571429') getcontext (). Arrondi = decimal.ROUND_DOWN Decimal (1) / Decimal (7) # retourne Decimal ('0.1428571428') 

Vous pouvez également utiliser certaines des fonctions mathématiques telles que sqrt (), exp (), et bûche() avec des décimales. Voici quelques exemples:

import décimal de décimal import décimal, getcontext Decimal (2) .sqrt () # renvoie Decimal ('1.414213562373095048801688724') getcontext (). prec = 4 décimal ('2'). sqrt () # renvoie Decimal ('1.414') décimal ('2000'). Log10 () # renvoie Decimal ('3.301')

Utilisation du module de fractions

Parfois, vous pouvez faire face à des situations où vous devez effectuer diverses opérations sur des fractions ou dont le résultat final doit être une fraction. Le module fractions peut être d'une grande aide dans ces cas. Il vous permet de créer un Fraction par exemple des nombres, des flottants, des décimales et même des chaînes. Tout comme le module décimal, il présente quelques problèmes en ce qui concerne la création de fractions à partir de flottants. Voici quelques exemples:

à partir de fractions import Fraction à partir décimale décimale Fraction (11, 35) # renvoie Fraction (11, 35) Fraction (10, 18) # retourne Fraction (5, 9) Fraction ('8/25') # renvoie Fraction (8, 25) Fraction (1.13) # renvoie la fraction (1272266894732165, 1125899906842624) Fraction ('1.13') # renvoie la fraction (113, 100) Fraction (décimale ('1.13')) # renvoie la fraction (113, 100)

Vous pouvez également effectuer des opérations mathématiques simples telles que l’addition et la soustraction sur des fractions, tout comme les nombres ordinaires.

de fractions import Fraction Fraction (113, 100) + Fraction (25, 18) # retourne Fraction (2267, 900) Fraction (18, 5) / Fraction (18, 10) # retourne Fraction (2, 1) Fraction (18, 5) * La fraction (16, 19) # renvoie la fraction (288, 95) La fraction (18, 5) * la fraction (15, 36) # renvoie la fraction (3, 2) La fraction (12, 5) ** La fraction (12, 10) # renvoie 2.8592589556010197

Le module a également quelques méthodes importantes comme limit_denominator (max_denominator) qui trouvera et retournera une fraction de valeur la plus proche de la fraction donnée dont le dénominateur est au plus max_denominator. Vous pouvez également renvoyer le numérateur d’une fraction donnée du terme le plus bas en utilisant le numérateur la propriété et le dénominateur en utilisant le dénominateur propriété.

de fractions importation Fraction Fraction ('3.14159265358979323846') # retourne Fraction (157079632679489661923, 50000000000000000000) Fraction ' Fraction (311, 99) Fraction ('3.14159265358979323846'). Limit_denominator (10) # renvoie Fraction (22, 7) Fraction (125, 50) .numérateur # renvoie 5 Fraction (125, 50) .denominator # renvoie 2

Vous pouvez également utiliser ce module avec diverses fonctions dans math module pour effectuer des calculs basés sur des fractions.

import math à partir de fractions import Fraction math.sqrt (Fraction (25, 4)) # renvoie 2.5 math.sqrt (Fraction (28,3)) # renvoie 3.0550504633038935 math.floor (Fraction (3558, 1213)) # renvoie 2 Fraction ( math.sin (math.pi / 3)) # renvoie Fraction (3900231685776981, 4503599627370496) Fraction (math.sin (math.pi / 3)). limit_denominator (10) # renvoie Fraction (6, 7)

Dernières pensées

Ces deux modules devraient être suffisants pour vous aider à effectuer des opérations courantes sur les décimales et les fractions. Comme indiqué dans la dernière section, vous pouvez utiliser ces modules avec le module mathématique pour calculer la valeur de toutes sortes de fonctions mathématiques dans le format souhaité..

Dans le prochain tutoriel de la série, vous en apprendrez plus sur les au hasard module en Python.