Compare Floating-Point Results with math.isclose

Select a timestamp to watch that moment on YouTube.

1. 00:00

   Imagine a program that calculates a sensor reading in one place and receives the expected reading from another. Both are displayed as 0.3, but an equality check says they differ. We can reproduce this with the familiar expression 0.1 plus 0.2. The important question is not whether Python forgot how to add. We need to ask what values are actually stored, what exact equality means, and what amount of numerical error the application permits. In this lesson we will print the real difference, use math.isclose with a relative tolerance, then meet a case that relative tolerance alone cannot handle: comparison with zero.

2. 00:41

   We will finish a function that makes the tolerance visible to callers and rejects invalid negative settings. You can run every stage in the browser console on the lesson page. Notice that this is a lesson about approximate numerical calculations. Prices and accounting amounts can require decimal representation and explicit cent- rounding rules; our separate Decimal lesson covers that different contract. Here, the goal is to make an approximation policy explicit instead of changing the data until a test happens to pass. The first line is False. Equality compares the stored float values exactly, and those values are not

3. 01:21

   identical. The second line tells us how far apart they are: about five and a half times ten to the minus seventeen. That is tiny compared with a value near three tenths, but it is not zero. The last line displays the computed value with one decimal place. It says 0.3 because formatting rounds the text shown to us. It has not modified left, and it has not changed the equality result. Many decimal fractions have repeating binary expansions. A float stores a finite approximation, so the stored result of one expression can land on a different representable value from another expression that looks

4. 02:02

   equivalent in decimal notation. A common attempted fix is round(left, 1) == round(right, 1). That can hide a genuine error if one decimal place is too coarse for the measurement. We should choose a comparison rule from the required accuracy, not from the number of digits that happens to make this one test green. math.isclose compares the absolute difference with an allowance computed from the two magnitudes. The decimal-sum difference is much smaller than a relative allowance of one part in a billion, so the first answer is True. The second pair differs by one out of roughly one hundred.

5. 02:43

   A tolerance of one part in a thousand is too narrow, so it returns False. The third pair also differs by one unit, but one is a very small fraction of a million, so it returns True. This is why one unexplained epsilon is not appropriate for every calculation. Relative tolerance is useful when acceptable error scales with the size of the result. It might fit a physical measurement with a proportional accuracy specification. If the application says that even large values must agree within a fixed number of units, use an absolute tolerance instead. math.isclose has a default relative tolerance, but using that default silently still makes a policy choice.

6. 03:27

   At a code boundary, state the tolerance and units. In tests, include values that should definitely pass and values that should definitely fail; otherwise a tolerance can be made too generous simply to satisfy one example. The function has keyword-only tolerance parameters, so a call that overrides a threshold has to name what it is changing. It checks for negative settings and then delegates the numerical comparison to math.isclose. The first call handles the small binary approximation from our opening example. The next two calls describe a hypothetical sensor whose readings within one hundredth of zero are treated as zero.

7. 04:09

   With abs_tol set to 0.01, 0.005 qualifies, while 0.02 does not. Without that absolute threshold, a nonzero value is not normally close to zero by relative tolerance alone: the relative allowance shrinks along with the magnitude. This does not mean 0.01 is a universal noise floor. Another sensor, a scientific calculation, or a financial total needs its own specification. Also observe that the function returns a Boolean; it does not alter either input or manufacture a rounded result. Keep calculation and comparison separate.

8. 04:50

   If the product ultimately needs a displayed value with a certain number of decimal places, format it after the calculation rather than using display formatting as the comparison policy. The task on the site starts with exact equality; replace it with this explicit rule and use the checker to examine multiple boundaries. The assertions test both acceptance and rejection. The familiar decimal sum should pass, and a sensor reading of 0.009 is within the illustrative absolute threshold. A reading of 0.02 is beyond it, so the next assertion requires False. The pair one hundred and one hundred one must also fail under a much tighter

9. 05:33

   relative allowance; this catches an implementation that returns True for everything. Exact equality remains a valid special case and should still pass. Finally, the negative tolerance is rejected with ValueError, rather than being treated as a mysterious comparison result. Notice what these tests cannot do: they cannot choose the right tolerance for your real project. That requires knowing the input's units, measurement accuracy, and consequence of a false match. A single passing example says very little about whether a threshold is safe at other magnitudes. Try changing the absolute threshold from 0.01 to 0.001 and predict which near-zero

10. 06:16

    assertions change before running them. Then compare a large pair under two relative tolerances and explain why the decision changes. This is the skill to carry forward: inspect the numerical difference, state the allowable error, and verify the boundary where the answer flips. On the lesson page, complete the task and quiz after experimenting with those inputs.