4

Let's consider the code below

code:

#!/usr/bin/env python

class Foo():
    def __init__(self, b):
        self.a = 0.0
        self.b = b
    def count_a(self):
        self.a += 0.1

foo = Foo(1)
for i in range(0, 15):
    foo.count_a()
    print "a =", foo.a, "b =", foo.b, '"a == b" ->', foo.a == foo.b

Output:

a = 0.2 b = 1 "a == b" -> False
a = 0.4 b = 1 "a == b" -> False
a = 0.6 b = 1 "a == b" -> False
a = 0.8 b = 1 "a == b" -> False
a = 1.0 b = 1 "a == b" -> True
a = 1.2 b = 1 "a == b" -> False
a = 1.4 b = 1 "a == b" -> False
a = 1.6 b = 1 "a == b" -> False
a = 1.8 b = 1 "a == b" -> False
a = 2.0 b = 1 "a == b" -> False
a = 2.2 b = 1 "a == b" -> False
a = 2.4 b = 1 "a == b" -> False
a = 2.6 b = 1 "a == b" -> False
a = 2.8 b = 1 "a == b" -> False
a = 3.0 b = 1 "a == b" -> False

But if I change code on line 11 to foo = Foo(2), the output is turned to be:

a = 0.2 b = 2 "a == b" -> False
a = 0.4 b = 2 "a == b" -> False
a = 0.6 b = 2 "a == b" -> False
a = 0.8 b = 2 "a == b" -> False
a = 1.0 b = 2 "a == b" -> False
a = 1.2 b = 2 "a == b" -> False
a = 1.4 b = 2 "a == b" -> False
a = 1.6 b = 2 "a == b" -> False
a = 1.8 b = 2 "a == b" -> False
a = 2.0 b = 2 "a == b" -> False *
a = 2.2 b = 2 "a == b" -> False
a = 2.4 b = 2 "a == b" -> False
a = 2.6 b = 2 "a == b" -> False
a = 2.8 b = 2 "a == b" -> False
a = 3.0 b = 2 "a == b" -> False

You will see that the output a = 2.0 b = 2 "a == b" -> False is totally weird. I think I might misunderstand some concept of OOP in Python. Please explain to me why this unexpected output is happened and how to solve this problem.

fronthem
  • 4,011
  • 8
  • 34
  • 55

2 Answers2

2

This has nothing to do with Object Orientation - it has to do with the way computers represent floating point numbers internally, and rounding errors. http://floating-point-gui.de/basic/

The Python specificity here is the default string representation of floating point numbers, which will round them at less decimal places than the internal representation for pretty printing.

Although, for people needing correct comparisons, respecting the scale of floating point numbers, Python has introduced a nice mechanism with PEP 485, which added the math.isclose function to the standard library.

jsbueno
  • 99,910
  • 10
  • 151
  • 209
0

Aside from the, correct, explanation by jsbueno, remember that Python often allows casting of "basic types" to themselves.

i.e. str("a") == "a"

So, if you need a workaround in addition to the reason, just convert your int/float mix to all floats and test those.

a = 2.0 
b = 2 
print "a == b", float(a) == float(b)

output:

a == b True
JL Peyret
  • 10,917
  • 2
  • 54
  • 73
  • One should probably still make the epsilon comparison (abs(a-b) – Martin Thoma Aug 02 '16 at 20:41
  • As I've said, Python incorporates the "isclose" function which takes care of using a relative comparison by default - so it is valid for floats >> 10 and floats << 1 without one having to worry about picking an apropriate epsilon for each situation. (And it also works with a fixed epsilon if one's usecase demand so) – jsbueno Aug 03 '16 at 17:22