En Python, le gamme de flotteur les valeurs dépendent de l’implémentation et de la plateforme. La spécification du langage Python exige seulement que point flottant les chiffres supportent au moins 1e-308 à 1e+308 avec une précision d'au moins 53 bits .

En pratique, la plupart des implémentations Python modernes utilisent le IEEE 754 standard à virgule flottante, qui fournit une plage d'environ 1.7e-308 à 1.7e+308 avec une précision de 53 bits . Cette plage est la même sur toutes les plates-formes et est prise en charge par le type intégré float.

Cependant, il est important de noter que l’arithmétique à virgule flottante est sujette à des erreurs d’arrondi et à d’autres sources d’imprécision, notamment lors de l’exécution d’opérations sur des nombres très grands ou très petits. Cela peut entraîner des comportements inattendus et des bugs dans certains cas.

Pour éviter ces problèmes, il est souvent recommandé d'utiliser décimal ou un point fixe arithmétique lorsque vous travaillez avec des valeurs monétaires ou d'autres applications nécessitant une grande précision. Le module décimal en Python prend en charge l'arithmétique à virgule fixe avec une précision configurable et constitue une bonne alternative à l'arithmétique à virgule flottante pour ces applications.

cpp est égal

Le IEEE 754 La norme définit la plage et la précision des nombres à virgule flottante utilisés par la plupart des langages de programmation modernes, y compris Python. La norme définit deux formats de base pour les nombres à virgule flottante :

Format simple précision

Il utilise 32 bits et fournit environ 7 décimales chiffres de précision.

Format double précision

Il utilise 64 bits et fournit environ 16 décimales chiffres de précision.

Python utilise double precision nombres à virgule flottante par défaut, ce qui signifie que la plage des valeurs flottantes est d'environ 1.7e-308 à 1.7e+308 avec une précision de 53 bits . Cette plage est déterminée par les exposants maximum et minimum qui peuvent être représentés à l'aide de 11 bits , combiné avec les significations maximales et minimales (c'est-à-dire la partie fraction du nombre) qui peuvent être représentées à l'aide de 52 bits .

La précision réelle de l'arithmétique à virgule flottante peut être affectée par de nombreux facteurs, notamment la manière dont les nombres sont stockés en mémoire, l'ordre des opérations et le choix du mode d'arrondi. Cela peut conduire à de subtiles erreurs d’arrondi et à d’autres sources d’imprécision dans certains cas.

Pour éviter ces problèmes, il est souvent recommandé d’utiliser des approches alternatives lorsque l’on travaille avec des nombres très grands ou très petits, ou lorsqu’une grande précision est requise. Par exemple:

1. Utiliser arithmétique à virgule fixe ou arithmétique décimale , qui fournit un nombre fixe de décimales de précision et évite les erreurs d'arrondi.
2. Utiliser précision arbitraire des bibliothèques comme 'mpmath' ou 'gmpy2' , qui permettent d'effectuer des calculs avec une très grande précision et d'éviter les erreurs d'arrondi.

Un aspect important à noter est que lorsque vous effectuez des opérations arithmétiques sur des nombres à virgule flottante en Python, vous pouvez rencontrer un comportement inattendu en raison du fonctionnement de l'arithmétique à virgule flottante.

Certaines opérations arithmétiques peuvent donner lieu à des nombres très petits ou très grands qui ne peuvent pas être représentés avec précision à l'aide de l'arithmétique à virgule flottante. Dans ces cas, le résultat peut être arrondi ou tronqué , entraînant un comportement inattendu ou des inexactitudes dans vos calculs.

Arithmétique à virgule flottante n'est pas associatif , ce qui signifie que l'ordre dans lequel vous effectuez les opérations peut affecter le résultat. Par exemple, (une + b) + c peut ne pas être égal à une + (b + c) en raison d'erreurs d'arrondi et d'autres sources d'imprécision.

L'arithmétique à virgule flottante n'est pas non plus distributif , ce qui signifie que (une + b) * c peut ne pas être égal à a*c + b*c en raison d'erreurs d'arrondi et d'autres sources d'imprécision. Pour minimiser l'impact de ces problèmes, il est souvent recommandé d'utiliser le module mathématique ou d'autres bibliothèques numériques qui fournissent des fonctions permettant d'effectuer des opérations arithmétiques sur des nombres à virgule flottante de manière plus précise et fiable. C'est également une bonne pratique d'éviter de comparer des nombres à virgule flottante pour vérifier l'égalité et d'utiliser plutôt un seuil de tolérance ou d'autres méthodes pour comparer l'ampleur de la différence entre deux valeurs.

Exemple:

Prenons un exemple pour montrer comment arithmétique à virgule flottante peut conduire à un comportement inattendu en python :

 a = 0.1 b = 0.2 c = 0.3 result1 = (a + b) + c result2 = a + (b + c) print(result1) print(result2) 

Sortir:

 0.6000000000000001 0.6 

Explication:

Dans cet exemple, nous effectuons deux calculs différents en utilisant les mêmes valeurs de un B, et c . Dans le premier calcul, on ajoute un et b d'abord, puis ajoutez le résultat à c . Dans le deuxième calcul, on ajoute b et c d'abord, puis ajoutez le résultat à un .

On pourrait s’attendre à ce que les deux calculs produisent le même résultat, puisqu’ils utilisent les mêmes valeurs de un B , et c . Cependant, en raison des limites de l'arithmétique à virgule flottante, les deux calculs produisent des résultats légèrement différents.

Le premier calcul produit un résultat de 0,60000000000000001 , tandis que le deuxième calcul produit un résultat de 0,6 . En effet, les résultats intermédiaires du premier calcul sont légèrement différents des résultats intermédiaires du deuxième calcul, en raison d'erreurs d'arrondi et d'autres sources d'imprécision.

Pour éviter ces problèmes, il est souvent recommandé d'utiliser le module décimal ou d'autres méthodes pour effectuer opérations arithmétiques sur point flottant chiffres de manière plus précise et plus fiable.

Par exemple:

 import decimal a = decimal.Decimal('0.1') b = decimal.Decimal('0.2') c = decimal.Decimal('0.3') result1 = (a + b) + c result2 = a + (b + c) print(result1) print(result2) 

Sortir:

 0.6 0.6 

Explication:

Dans cet exemple, nous utilisons le module décimal effectuer les mêmes calculs en utilisant un point fixe arithmétique avec une précision de 1 décimale. Cela nous permet d'éviter les erreurs d'arrondi et autres sources d'imprécision qui peuvent affecter point flottant arithmétique. En conséquence, les deux calculs donnent le même résultat de 0,6 .