Номера округления - Что здесь не так?

Question

1. У меня есть K список поплавков, что происходит от некоторых предыдущих расчетов, такие как:

   K = numpy.arange(0.01, 0.3, 0.01) 
   K = [0.01, .... 0.28999999999999998, 0.29999999999999999] 
   

2. Теперь, давайте круглый эти цифры на 2-ой десятичный:

   K_rounded_2 = [ round(kk, 2) for kk in K ] 
   

   Дает:

   >>> K_rounded_2 
   [0.01, 0.02, 0.029999999999999999, 0.040000000000000001, 0.050000000000000003, 0.059999999999999998, 0.070000000000000007, 0.080000000000000002, 0.089999999999999997, 0.10000000000000001, 0.11, 0.12, 0.13, 0.14000000000000001, 0.14999999999999999, 0.16, 0.17000000000000001, 0.17999999999999999, 0.19, 0.20000000000000001, 0.20999999999999999, 0.22, 0.23000000000000001, 0.23999999999999999, 0.25, 0.26000000000000001, 0.27000000000000002, 0.28000000000000003, 0.28999999999999998, 0.29999999999999999] 
   

Теперь, если я был для ручного ввода K в виде списка, просто писать каждый элемент:

K = [ enter value 1, enter value 2, ...] 

, а затем сделать:

K_rounded_2 = [ round(kk, 2) for kk in K ] 

, то результат, как и ожидалось:

>>> K_rounded_2 
[0.01, 0.02, 0.03, 0.04, 0.05, 0.06, 0.07, 0.08, 0.09, 0.1, 0.11, 0.12, 0.13, 0.14, 0.15, 0.16, 0.17, 0.18, 0.19, 0.2, 0.21, 0.22, 0.23, 0.24, 0.25, 0.26, 0.27, 0.28, 0.29, 0.3] 

Таким образом, существует различная трактовка между списком, который обеспечивается некоторым подсчетом и тот, который просто вводится? Зачем ?

Answer 1

Это различие связано с тем, что в первом случае результат содержит np.float64 сек, а при вводе номера непосредственно вы используете питона встроенный floatкоторый имеет умную строковое представление:

In [1]: import numpy as np 

In [2]: a = np.arange(0.01, 0.3, 0.01) 

In [3]: a 
Out[3]: 
array([ 0.01, 0.02, 0.03, 0.04, 0.05, 0.06, 0.07, 0.08, 0.09, 
     0.1 , 0.11, 0.12, 0.13, 0.14, 0.15, 0.16, 0.17, 0.18, 
     0.19, 0.2 , 0.21, 0.22, 0.23, 0.24, 0.25, 0.26, 0.27, 
     0.28, 0.29]) 

In [4]: [round(elem, 2) for elem in a] 
Out[4]: 
[0.01, 
0.02, 
0.029999999999999999, 
0.040000000000000001, 
0.050000000000000003, 
0.059999999999999998, 
0.070000000000000007, 
0.080000000000000002, 
0.089999999999999997, 
0.10000000000000001, 
0.11, 
0.12, 
0.13, 
0.14000000000000001, 
0.14999999999999999, 
0.16, 
0.17000000000000001, 
0.17999999999999999, 
0.19, 
0.20000000000000001, 
0.20999999999999999, 
0.22, 
0.23000000000000001, 
0.23999999999999999, 
0.25, 
0.26000000000000001, 
0.27000000000000002, 
0.28000000000000003, 
0.28999999999999998] 

In [5]: b = [0.01, 
    ...: 0.02, 
    ...: 0.029999999999999999, 
    ...: 0.040000000000000001, 
    ...: 0.050000000000000003, 
    ...: 0.059999999999999998, 
    ...: 0.070000000000000007, 
    ...: 0.080000000000000002, 
    ...: 0.089999999999999997, 
    ...: 0.10000000000000001, 
    ...: 0.11, 
    ...: 0.12, 
    ...: 0.13, 
    ...: 0.14000000000000001, 
    ...: 0.14999999999999999, 
    ...: 0.16, 
    ...: 0.17000000000000001, 
    ...: 0.17999999999999999, 
    ...: 0.19, 
    ...: 0.20000000000000001, 
    ...: 0.20999999999999999, 
    ...: 0.22, 
    ...: 0.23000000000000001, 
    ...: 0.23999999999999999, 
    ...: 0.25, 
    ...: 0.26000000000000001, 
    ...: 0.27000000000000002, 
    ...: 0.28000000000000003, 
    ...: 0.28999999999999998] 

In [6]: [round(elem, 2) for elem in b] 
Out[6]: 
[0.01, 
0.02, 
0.03, 
0.04, 
0.05, 
0.06, 
0.07, 
0.08, 
0.09, 
0.1, 
0.11, 
0.12, 
0.13, 
0.14, 
0.15, 
0.16, 
0.17, 
0.18, 
0.19, 
0.2, 
0.21, 
0.22, 
0.23, 
0.24, 
0.25, 
0.26, 
0.27, 
0.28, 
0.29] 

Теперь, если мы проверяем типы элементов этих списков:

In [10]: rounded_a = [round(elem, 2) for elem in a] 
    ...: rounded_b = [round(elem, 2) for elem in b] 
    ...: 

In [11]: type(rounded_a[0]), type(rounded_b[0]) 
Out[11]: (numpy.float64, builtins.float) 

Однако цифры, представленные в то же самое!

In [12]: rounded_a[0] == rounded_b[0] 
Out[12]: True 
In [13]: rounded_a[-1] == rounded_b[-1] 
Out[13]: True 

Напечатанного значение отличается тем, что питон встроенных поплавки умнее и отобразить более короткий литерал, который будет представлять данное число с плавающей точкой (см 3.1 What's new документа питона и связанным с issue1580):

In [15]: 0.28999999999999998 
Out[15]: 0.29 

Numpy делает это и вместо этого выводит только «отображаемое число с плавающей запятой/фактическое число с плавающей запятой». Но обратите внимание, что результат тот же, только отображается по-разному, хотя и эквивалентным образом.