nombre flottant python

Question

je suis un peu confus pourquoi python ajouter un nombre décimal supplémentaire dans ce cas, s'il vous plaît aider à expliquer

>>> mylist = ["list item 1", 2, 3.14] 
>>> print mylist ['list item 1', 2, 3.1400000000000001] 

Answer 1

nombres à virgule flottante sont une approximation, ils ne peuvent pas stocker des nombres décimaux exactement. Parce qu'ils essaient de représenter une très large gamme de nombres dans seulement 64 bits, ils doivent se rapprocher dans une certaine mesure.

Il est très important d'être conscient de cela, car il en résulte des effets secondaires bizarres. Par exemple, vous pourriez très raisonnablement penser que la somme de dix lots de 0.1 serait 1.0. Bien que cela semble logique, il est également faux quand il vient à virgule flottante:

>>> f = 0.0 
>>> for _ in range (10): 
... f += 0.1 
... 
>>> print f == 1.0 
False 
>>> f 
0.99999999999999989 
>>> str(f) 
1.0 

Vous pourriez penser que n/m * m == n. Encore une fois, le monde à virgule flottante est en désaccord:

>>> (1.0/103.0) * 103.0 
0.99999999999999989 

Ou peut-être tout aussi étrangement, on pourrait penser que pour tous n, n + 1 != n. En flottant terre point, les chiffres ne fonctionnent pas comme ceci:

>>> 10.0**200 
9.9999999999999997e+199 
>>> 10.0**200 == 10.0**200 + 1 
True 
# How much do we have to add to 10.0**200 before its 
# floating point representation changes? 
>>> 10.0**200 == 10.0**200 + 10.0**183 
True 
>>> 10.0**200 == 10.0**200 + 10.0**184 
False 

Voir What every computer scientist should know about floating point numbers pour un excellent résumé des questions.

Si vous avez besoin d'une représentation décimale exacte, consultez le module decimal, qui fait partie de la bibliothèque standard python depuis la version 2.4. Cela vous permet de spécifier le nombre de chiffres significatifs. L'inconvénient est, il est beaucoup plus lent que le virgule flottante, parce que les opérations en virgule flottante sont implémentées dans le matériel tandis que les opérations décimales se produisent purement dans le logiciel. Il a également ses propres problèmes d'imprécision, mais si vous avez besoin d'une représentation exacte des nombres décimaux (par exemple pour une application financière), c'est idéal.

Par exemple:

>>> 3.14 
3.1400000000000001 
>>> import decimal 
>>> decimal.Decimal('3.14') 
>>> print decimal.Decimal('3.14') 
3.14 
# change the precision: 
>>> decimal.getcontext().prec = 6 
>>> decimal.Decimal(1)/decimal.Decimal(7) 
Decimal('0.142857') 
>>> decimal.getcontext().prec = 28 
>>> decimal.Decimal(1)/decimal.Decimal(7) 
Decimal('0.1428571428571428571428571429') 

Answer 2

Comme mentionné précédemment, il est tout au sujet des points flottants étant une approximation.

Si vous voulez EXACTITUDE vous pouvez utiliser une décimale (qui est une représentation précise): http://docs.python.org/library/decimal.html

a = [1.5, 1.49999] 
a 
[1.5, 1.4999899999999999] 

from decimal import Decimal 
b = [1.5, Decimal('1.4999')] 
b 
[1.5, Decimal('1.4999')] 

Answer 3

Il est intéressant de noter que Python 3.1 a une nouvelle routine de sortie de virgule flottante qui arrondit ce dans le manière attendue (il a également été rétroportés à Python 2.7):

Python 3.1 (r31:73572, Aug 15 2009, 17:12:41) 
[GCC 4.0.1 (Apple Computer, Inc. build 5367)] on darwin 
Type "help", "copyright", "credits" or "license" for more information. 
>>> a = [3.14] 
>>> print(a) 
[3.14] 

a partir du document What's New in Python 3.1:

Python now uses David Gay’s algorithm for finding the shortest floating point representation that doesn’t change its value. This should help mitigate some of the confusion surrounding binary floating point numbers.

The significance is easily seen with a number like 1.1 which does not have an exact equivalent in binary floating point. Since there is no exact equivalent, an expression like float('1.1') evaluates to the nearest representable value which is 0x1.199999999999ap+0 in hex or 1.100000000000000088817841970012523233890533447265625 in decimal. That nearest value was and still is used in subsequent floating point calculations.

Answer 4

Nous pouvons le réparer par cette commande:

>>> x = 1.2 - 1.0 
>>> x 
0.19999999999999996 
>>> y = float(str(x)) 
>>> y 
0.2 

ajouter une réponse de