• Choose a category
• All
• Classic-Fiction

Setting precision globally

Other tools in the decimal module can be used to set the precision of all decimal numbers, set up error handling, and more. For instance, a context object in this module allows for specifying precision (number of decimal digits) and rounding modes (down, ceiling, etc.). The precision is applied globally for all decimals created in the calling thread:

>>> import decimal

>>> decimal.Decimal(1) / decimal.Decimal(7)

Decimal('0.1428571428571428571428571429')

>>> decimal.getcontext().prec = 4

>>> decimal.Decimal(1) / decimal.Decimal(7)

Decimal('0.1429')

This is especially useful for monetary applications, where cents are represented as two decimal digits. Decimals are essentially an alternative to manual rounding and string formatting in this context:

>>> 1999 + 1.33

2000.3299999999999

>>>

>>> decimal.getcontext().prec = 2

>>> pay = decimal.Decimal(str(1999 + 1.33))

>>> pay

Decimal('2000.33')

Decimal context manager

In Python 2.6 and 3.0 (and later), it’s also possible to reset precision temporarily by using the with context manager statement. The precision is reset to its original value on statement exit:

C:\misc> C:\Python30\python

>>> import decimal

>>> decimal.Decimal('1.00') / decimal.Decimal('3.00')

Decimal('0.3333333333333333333333333333')

>>>

>>> with decimal.localcontext() as ctx:

... ctx.prec = 2

... decimal.Decimal('1.00') / decimal.Decimal('3.00')

...

Decimal('0.33')

>>>

>>> decimal.Decimal('1.00') / decimal.Decimal('3.00')

Decimal('0.3333333333333333333333333333')

Though useful, this statement requires much more background knowledge than you’ve obtained at this point; watch for coverage of the with statement in Chapter 33.

Because use of the decimal type is still relatively rare in practice, I’ll defer to Python’s standard library manuals and interactive help for more details. And because decimals address some of the same floating-point accuracy issues as the fraction type, let’s move on to the next section to see how the two compare.

Fraction Type

Python 2.6 and 3.0 debut a new numeric type, Fraction, which implements a rational number object. It essentially keeps both a numerator and a denominator explicitly, so as to avoid some of the inaccuracies and limitations of floating-point math.

The basics

Fraction is a sort of cousin to the existing Decimal fixed-precision type described in the prior section, as both can be used to control numerical accuracy by fixing decimal digits and specifying rounding or truncation policies. It’s also used in similar ways—like Decimal, Fraction resides in a module; import its constructor and pass in a numerator and a denominator to make one. The following interaction shows how:

>>> from fractions import Fraction

>>> x = Fraction(1, 3) # Numerator, denominator

>>> y = Fraction(4, 6) # Simplified to 2, 3 by gcd

>>> x

Fraction(1, 3)

>>> y

Fraction(2, 3)

>>> print(y)

2/3

Once created, Fractions can be used in mathematical expressions as usual:

>>> x + y

Fraction(1, 1)

>>> x – y # Results are exact: numerator, denominator

Fraction(-1, 3)

>>> x * y

Fraction(2, 9)

Fraction objects can also be created from floating-point number strings, much like decimals:

>>> Fraction('.25')

Fraction(1, 4)

>>> Fraction('1.25')

Fraction(5, 4)

>>>

>>> Fraction('.25') + Fraction('1.25')

Fraction(3, 2)

Numeric accuracy

Notice that this is different from floating-point-type math, which is constrained by the underlying limitations of floating-point hardware. To compare, here are the same operations run with floating-point objects, and notes on their limited accuracy:

>>> a = 1 / 3.0 # Only as accurate as floating-point hardware

>>> b = 4 / 6.0 # Can lose precision over calculations

>>> a

0.33333333333333331

>>> b

0.66666666666666663

>>> a + b

1.0

>>> a - b

-0.33333333333333331

>>> a * b

0.22222222222222221

This floating-point limitation is especially apparent for values that cannot be represented accurately given their limited number of bits in memory. Both