Чому 1 // 0,01 == 99 у Python?

Я думаю, це класичне питання точності з плаваючою точкою, але я намагаюся обернути голову навколо цього результату, працюючи 1//0.01в Python 3.7.5 99.

Я думаю, це очікуваний результат, але чи є спосіб вирішити, коли безпечніше використовувати, int(1/f)а не 1//f?

Якби це поділ на реальні числа, 1//0.01було б рівно 100. Оскільки вони наближені з плаваючою комою, хоча 0.01трохи більше 1/100, тобто коефіцієнт трохи менше 100. Це 99. деяке значення, яке потім закреслюється до 99.

Причини такого результату, як ви заявляєте, пояснюються в розділі Чи порушена математика з плаваючою комою? та багато інших подібних запитань.

Коли ви знаєте кількість десяткових знаків чисельника та знаменника, більш надійним способом є спочатку помножити ці числа, щоб вони могли розглядатися як цілі числа, а потім виконати на них ціле ділення:

Тож у вашому випадку 1//0.01спочатку слід перетворити на 1*100//(0.01*100)100.

У більш крайніх випадках ви все одно можете отримати "несподівані" результати. Можливо, буде потрібно додати roundвиклик до чисельника та знаменника, перш ніж виконувати ціле ділення:

1 * 100000000000 // round(0.00000000001 * 100000000000)

Але якщо мова йде про роботу з фіксованими десятковою комою (гроші, центи), то розгляньте роботу з копійками як одиницю , так що вся арифметика може бути виконана як ціла арифметика, а при перетворенні лише в основну грошову одиницю (долар) I / O.

Або ж використайте бібліотеку для десяткових знаків, як десятковий , який:

... надає підтримку швидкої арифметики з десятковою плаваючою колом.

from decimal import Decimal
cent = Decimal(1) / Decimal(100) # Contrary to floating point, this is exactly 0.01
print (Decimal(1) // cent) # 100

Те, що ви повинні врахувати, це те, що //це floorоператор, і, як такий, вам слід спочатку подумати, ніби ви маєте рівну ймовірність впасти в 100, як у 99 (*) (тому що операція буде мати 100 ± epsilonза epsilon>0умови, що шанси отримати рівно 100,00 ..0 надзвичайно низькі.)

Ви насправді можете бачити те саме зі знаком мінус,

>>> 1//.01
99.0
>>> -1//.01
-100.0

і ви повинні бути настільки ж (не) здивовані.

З іншого боку, int(-1/.01)виконує спочатку ділення, а потім застосовує число int()в номері, яке не є підлогою, а відсіканням до 0 ! що означає, що в такому випадку,

>>> 1/.01
100.0
>>> -1/.01
-100.0

отже,

>>> int(1/.01)
100
>>> int(-1/.01)
-100

Округлення, однак, дасть вам ВАШ очікуваний результат для цього оператора, оскільки, знову ж таки, помилка мала для цих цифр.

(*) Я не кажу, що ймовірність однакова, я просто кажу, що апріорі, коли ви виконуєте таке обчислення з плаваючою арифметикою, це оцінка того, що ви отримуєте.

Числа з плаваючою комою не можуть точно представляти більшість десяткових чисел, тому при введенні літералу з плаваючою комою ви фактично отримуєте наближення цього букваря. Наближення може бути більшим або меншим, ніж число, яке ви ввели.

Ви можете побачити точне значення числа з плаваючою точкою, відкинувши його до десяткової або дробу.

>>> from decimal import Decimal
>>> Decimal(0.01)
Decimal('0.01000000000000000020816681711721685132943093776702880859375')
>>> from fractions import Fractio
>>> Fraction(0.01)
Fraction(5764607523034235, 576460752303423488) 

Ми можемо використовувати тип Дроби, щоб знайти помилку, спричинену нашим неточним буквалом.

>>> float((Fraction(1)/Fraction(0.01)) - 100)
-2.0816681711721685e-15

Ми також можемо дізнатись, як гранульовані цифри з плаваючою крапкою з подвійною точністю приблизно 100, використовуючи наступний від нумета.

>>> from numpy import nextafter
>>> nextafter(100,0)-100
-1.4210854715202004e-14

З цього можна припустити, що найближче число з плаваючою точкою 1/0.01000000000000000020816681711721685132943093776702880859375насправді становить саме 100.

Різниця між 1//0.01і int(1/0.01)полягає в округленні. 1 // 0,01 округляє точний результат до наступного цілого числа за один крок. Таким чином ми отримуємо результат 99.

int (1 / 0,01), з іншого боку, обводиться у два етапи, спочатку він округляє результат до найближчого числа з плаваючою точкою подвійної точності (що рівно 100), потім округляє число з плаваючою точкою до наступного цілого числа (яке є знову рівно 100).

Якщо ви виконаєте наступне

from decimal import *

num = Decimal(1) / Decimal(0.01)
print(num)

Вихід буде:

99.99999999999999791833182883

Ось як це представлено внутрішньо, тому округлення його вниз //дасть99