python floating number
Question: i am kind of confused why python add some additional decimal number in this
case, please help to explain

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


Answer: Floating point numbers are an approximation, they cannot store decimal numbers
exactly. Because they try to represent a very large range of numbers in only
64 bits, they must approximate to some extent.

It is very important to be aware of this, because it results in some weird
side-effects. For example, you might very reasonably think that the sum of ten
lots of `0.1` would be `1.0`. While this seems logical, it is also wrong when
it comes to floating point:

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

You might think that `n / m * m == n`. Once again, floating-point world
disagrees:

    
    
    >>> (1.0 / 103.0) * 103.0
    0.99999999999999989
    

Or perhaps just as strangely, one might think that for all `n`, `n + 1 != n`.
In floating point land, numbers just don't work like this:

    
    
    >>> 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
    

See [What every computer scientist should know about floating point
numbers](http://docs.sun.com/source/806-3568/ncg_goldberg.html) for an
excellent summary of the issues.

If you need exact decimal representation, check out the
[decimal](http://docs.python.org/library/decimal.html) module, part of the
python standard library since 2.4. It allows you to specify the number of
significant figures. The downside is, it is much slower than floating point,
because floating point operations are implemented in hardware whereas decimal
operations happen purely in software. It also has its own imprecision issues,
but if you need exact representation of decimal numbers (e.g. for a financial
application) it's ideal.

For example:

    
    
    >>> 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')
    

